Compare commits

..

578 Commits

Author SHA1 Message Date
Scott Lahteine 04acb12148 etc 2025-03-17 21:00:23 -05:00
Scott Lahteine cfe5bf2929 reuse, update lcd_preheat 2025-03-17 20:29:54 -05:00
Scott Lahteine a131edd6ff misc 2025-03-17 20:10:00 -05:00
Scott Lahteine ed60c3c68b wide strings 2025-03-17 20:04:33 -05:00
Scott Lahteine 4051eae885 Merge branch 'bugfix-2.1.x' into pr/26864 2025-03-17 20:00:16 -05:00
thinkyhead 0a07bba213 [cron] Bump distribution date (2025-03-18) 2025-03-18 00:28:49 +00:00
Andrew 2f4f2bce15 🔨 PowerShell compatibility (#27720) 2025-03-17 18:04:59 -05:00
David Buezas 0d87dd9d51 LCD_DOUBLE_BUFFER (#26713) 2025-03-17 16:27:51 -05:00
Scott Lahteine e11a5ee717 📝 Some config comment updates
Co-Authored-By: Andrew <18502096+classicrocker883@users.noreply.github.com>
2025-03-17 16:24:05 -05:00
Scott Lahteine e8c0363051 🎨 cosmetics 2025-03-17 15:19:21 -05:00
Scott Lahteine 2d6454b352 🩹 Update some SD SS pins
Followup to #27650
2025-03-17 15:06:35 -05:00
ellensp 28548efa75 🚸 Improve TFT touch calibrate (#26200) 2025-03-17 12:54:21 -05:00
thinkyhead da0bef50e1 [cron] Bump distribution date (2025-03-17) 2025-03-17 00:30:31 +00:00
Scott Lahteine b954959f55 M550 CONFIGURABLE_MACHINE_NAME (#27731) 2025-03-16 03:24:00 -05:00
Scott Lahteine 434bf81f8e 🩹 Fix max Y/Z endstop pins on GMARSH X6 REV1 2025-03-16 00:52:22 -05:00
Scott Lahteine 82d3d78e31 🔧 BOARD_LCD_SERIAL_PORT 2025-03-15 21:40:06 -05:00
thinkyhead fb4d465360 [cron] Bump distribution date (2025-03-16) 2025-03-16 00:32:26 +00:00
Marcio T. 3827ceaf66 🩹 Fix color game compile (#27721) 2025-03-15 17:31:32 -05:00
thinkyhead 6ba08130f0 [cron] Bump distribution date (2025-03-15) 2025-03-15 00:28:35 +00:00
Keith Bennett 78f871567f 🔨 Rename FYSETC S6/Spider envs (#27122) 2025-03-14 13:11:45 -05:00
thinkyhead 9e30173b13 [cron] Bump distribution date (2025-03-14) 2025-03-14 00:28:40 +00:00
ellensp f0bd400002 🩹🔧 Fix LCD_LANGUAGE for HD44780 (#27729) 2025-03-13 17:21:28 -05:00
Scott Lahteine 0fa3d2642a MIN_POWER (#27742)
Followup to #14746

Co-authored-by: mikeshub <2420379+mikeshub@users.noreply.github.com>
2025-03-13 17:19:23 -05:00
ellensp 4cf4647c9a 🔧 More serial ports for Teensy HALs (#27736)
Followup to #27648

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2025-03-12 20:35:12 -05:00
thinkyhead 5766dc0ece [cron] Bump distribution date (2025-03-13) 2025-03-13 00:29:12 +00:00
Scott Lahteine 01990f2bf4 📝 Document planner modifier methods 2025-03-12 17:28:22 -05:00
thinkyhead d74ee8ccc4 [cron] Bump distribution date (2025-03-12) 2025-03-12 00:28:38 +00:00
Scott Lahteine 953b6844ca 📝 Config comments with units 2025-03-10 22:12:40 -05:00
thinkyhead e6ccf3b72b [cron] Bump distribution date (2025-03-11) 2025-03-11 00:28:55 +00:00
Scott Lahteine d9229ff355 🔨 Fix CONFIG_EXPORT 1, (embed = 101)
Followup to #27628
See #27612
2025-03-10 19:06:47 -05:00
thinkyhead ee35929b61 [cron] Bump distribution date (2025-03-10) 2025-03-10 00:25:20 +00:00
Scott Lahteine 07b979012a 🧑‍💻 Probe Wizard comments 2025-03-09 15:52:25 -05:00
Scott Lahteine 126e78dcce 🐛 Fix quoted string value detection 2025-03-09 15:46:13 -05:00
thinkyhead e02de3a256 [cron] Bump distribution date (2025-03-07) 2025-03-07 06:09:07 +00:00
narno2202 97a7c2160e ️ FT Motion: Fill window in makeVector (#27718) 2025-03-06 19:43:02 -06:00
thinkyhead caf5d5b134 [cron] Bump distribution date (2025-03-05) 2025-03-05 06:09:08 +00:00
Fly3DTeam 05a46084b6 FLY_D5, FLY_DP5, FLY_D7, FLY_D8, FLY_D8_PRO, FLY_SUPER8_PRO, FLY_CDY_V3 (#27580) 2025-03-04 21:08:04 -06:00
thinkyhead e676d833a3 [cron] Bump distribution date (2025-03-02) 2025-03-02 00:30:52 +00:00
ellensp 73a0f33767 BUILD_INFO_MENU_ITEM (#27590) 2025-03-01 17:45:31 -06:00
ellensp e787c8f26b 🚸 Fix extra echo: in M218 report (#27674) 2025-03-01 15:00:28 -06:00
Scott Lahteine 147dcaf600 📝 Update MAX31865 comment 2025-03-01 14:30:15 -06:00
Farva42 dd3bf2995b 🔧 Static assert Dual X min/max (#27701) 2025-03-01 00:26:56 -06:00
thinkyhead 142177426b [cron] Bump distribution date (2025-03-01) 2025-03-01 06:07:59 +00:00
Keith Bennett 072b90d105 💚 Fix Simulator CI build (#27712) 2025-02-28 20:57:40 -06:00
thinkyhead efba06c4ce [cron] Bump distribution date (2025-02-20) 2025-02-20 00:28:00 +00:00
Scott Lahteine 2cc35a9ad1 🎨 Wrap BABYSTEP_SIZE_* 2025-02-19 15:36:59 -06:00
Farva42 b748506230 🩹 Fix MKS boards runout sensor pins (#27687)
Followup to #27640
2025-02-19 12:45:40 -06:00
thinkyhead c3a4ef77af [cron] Bump distribution date (2025-02-19) 2025-02-19 06:08:42 +00:00
narno2202 86c1fde309 ️ Always "optimize" FT Motion DIR states (#27692) 2025-02-18 19:38:28 -06:00
Luc 89def456e8 🔨 Fix pioarduino path check for xtensa-esp32 (#27693) 2025-02-18 19:33:54 -06:00
thinkyhead 0518737119 [cron] Bump distribution date (2025-02-16) 2025-02-16 00:30:26 +00:00
Keith Bennett 12b3f18bb2 🔨 mac_gcc: Use configured brew/port paths (#27655) 2025-02-15 16:11:57 -06:00
thinkyhead 4d0c6841f8 [cron] Bump distribution date (2025-02-04) 2025-02-04 12:10:52 +00:00
Scott Lahteine 99c3a7136d 🎨 Standard logical FLIP(X) 2025-02-03 15:43:17 -06:00
Scott Lahteine cd3997f045 🧑‍💻 More binary file types 2025-02-03 15:43:17 -06:00
thinkyhead 479074ccba [cron] Bump distribution date (2025-02-02) 2025-02-02 06:07:35 +00:00
Scott Lahteine a21fc27056 🎨 Minor config style updates 2025-02-01 00:12:26 -06:00
thinkyhead 485fbf2040 [cron] Bump distribution date (2025-01-28) 2025-01-28 06:08:30 +00:00
Scott Lahteine 09a519bfb5 🔥 Not using .astylerc 2025-01-27 21:18:29 -06:00
Scott Lahteine 81ef02e41f 🔨 Fix sim build with gcc-14 2025-01-27 21:17:53 -06:00
thinkyhead 0226692e6b [cron] Bump distribution date (2025-01-27) 2025-01-27 00:28:09 +00:00
Andrew 0cd1d9c3c9 🩹 Update some hex-printing (#27654)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2025-01-25 23:58:40 -06:00
Scott Lahteine ab7137ab8e 🩹 RP2040 has PIN_SPI_SS
Followup to #27650
2025-01-25 20:17:59 -06:00
Scott Lahteine 84113367fc 📝 CardReader comments 2025-01-25 20:17:59 -06:00
thinkyhead c24ecfb6f0 [cron] Bump distribution date (2025-01-26) 2025-01-26 00:27:46 +00:00
Scott Lahteine 442f0baf14 🔨 Script for gcc setup on macOS (Simulator build) 2025-01-25 17:11:37 -06:00
thinkyhead 40aab1e298 [cron] Bump distribution date (2025-01-25) 2025-01-25 00:26:20 +00:00
Scott Lahteine 09fbe372da 🔨 Elegoo Neptune boards ("elegoo.bin") (#24895) 2025-01-24 17:53:19 -06:00
Scott Lahteine 279a393e81 🌐 Attach media messages 2025-01-24 17:51:34 -06:00
Scott Lahteine 1e2e0c3a36 🎨 Flash EEPROM pins cleanup 2025-01-24 17:51:34 -06:00
Scott Lahteine 86f03cf57a 🎨 Shared USB build flags 2025-01-24 17:51:34 -06:00
rondlh 7f598ae66d ️ STM32H7 Serial DMA (#27633) 2025-01-23 21:18:46 -06:00
Andrew 0a598071af 🎨 Adjust some Python formatting (#27649) 2025-01-23 19:48:58 -06:00
thinkyhead 861dd33fa1 [cron] Bump distribution date (2025-01-24) 2025-01-24 00:27:01 +00:00
Scott Lahteine ac14c65643 ♻️ SD- and SPI-related pins cleanup (#27650) 2025-01-23 18:00:17 -06:00
Scott Lahteine 0f7fb5d88d 🧑‍💻 Media conditionals 2025-01-22 22:46:45 -06:00
Scott Lahteine 428f721cbf 🔧 Sequential Opulo boards 2025-01-22 19:09:08 -06:00
thinkyhead 31bc23b6e3 [cron] Bump distribution date (2025-01-23) 2025-01-23 00:26:51 +00:00
Scott Lahteine a1ba166740 ♻️ Common serial ports header (#27648) 2025-01-22 14:46:04 -06:00
thinkyhead 88829bd92d [cron] Bump distribution date (2025-01-22) 2025-01-22 06:08:44 +00:00
narno2202 7e0208940b 🚸 Disable FT Motion during Biqu Microprobe use (#27368)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2025-01-21 21:10:52 -06:00
Scott Lahteine 12d491c5f7 🐛 Don't reset axis_did_move in ftmotion.reset
Co-Authored-By: narno2202 <130909513+narno2202@users.noreply.github.com>
2025-01-21 21:09:13 -06:00
Scott Lahteine 29635232d3 🔨 Prevent ESP32 bad dependency 2025-01-21 20:57:43 -06:00
thinkyhead 4e72b17a88 [cron] Bump distribution date (2025-01-17) 2025-01-17 00:26:47 +00:00
Scott Lahteine 8b8c862615 🔨 Skip _xfer builds unless uploading 2025-01-16 15:41:26 -06:00
thinkyhead 45ca25a4ab [cron] Bump distribution date (2025-01-16) 2025-01-16 00:27:01 +00:00
Andrew 8f35e9a797 🧑‍💻 Update types forward decl (#27637) 2025-01-15 14:30:00 -06:00
thinkyhead b4688346ab [cron] Bump distribution date (2025-01-15) 2025-01-15 00:27:11 +00:00
Scott Lahteine e0c60a83a2 🩹 Fix VALIDATE_HOMING_ENDSTOPS missing header 2025-01-14 15:21:18 -06:00
Scott Lahteine b7358449e0 🚸 Enabled probe clearance in do_move_after_z_homing (#27593) 2025-01-14 13:37:48 -06:00
Scott Lahteine 85ebd170a9 🔧 Standard filament runout pins for MKS_UI / MKS TFT (#27640) 2025-01-14 13:13:29 -06:00
Scott Lahteine 70cdfbe8fc 📝 Add'l homeaxis comments 2025-01-14 12:47:10 -06:00
Keith Bennett 5dc55150bd 🔧 BTT SKRat UART driver support pending (#27639) 2025-01-14 12:42:06 -06:00
thinkyhead ef34fd1a3f [cron] Bump distribution date (2025-01-14) 2025-01-14 00:26:31 +00:00
phizev 854cfc016d Teensy 4 hardware PWM for laser/spindle/fan (#27608) 2025-01-13 16:14:16 -06:00
ellensp b7f628ce2f 🩹 Fix EEPROM CRC display (#27631) 2025-01-13 13:12:09 -06:00
thinkyhead f54ec92ba8 [cron] Bump distribution date (2025-01-13) 2025-01-13 00:30:03 +00:00
RomanFaktor 2e142725a6 🐛 Fix ERYONE Ery32 mini SPI for SD (#27600) 2025-01-11 21:16:34 -06:00
ellensp 6eca4bbab1 🔨 Migrate use_example_configs to Python (#27632) 2025-01-11 21:06:24 -06:00
Giuliano Zaro de7ac7f594 🐛 Fix M119 filament sensor part (#27596)
Fix from #27576
2025-01-11 21:00:10 -06:00
rondlh 28c591309f ️ STM32H7 Flash Wear Leveling (#27634) 2025-01-11 20:58:26 -06:00
thinkyhead 55add905cb [cron] Bump distribution date (2025-01-12) 2025-01-12 00:36:21 +00:00
Andrew 8d7ecad531 🔨 Fix cmake build on Linux (#27605) 2025-01-11 15:09:49 -06:00
thinkyhead a7d79618b9 [cron] Bump distribution date (2025-01-10) 2025-01-10 00:28:20 +00:00
Scott Lahteine acd825972c EVENT_GCODE_BEFORE_G29 (#27566) 2025-01-08 23:03:41 -06:00
ellensp 7eee772f60 MAX31865 Bed settings (#27611) 2025-01-08 22:41:03 -06:00
Red Echidna UK 63bc413da8 🧑‍💻 Add STM32/STM32F1 Open Drain (OD) pin mode (#27616) 2025-01-08 22:30:53 -06:00
Chris 22977c885b Games for E3V2 + MarlinUI (#27620) 2025-01-08 18:53:15 -06:00
thinkyhead de76f2f21a [cron] Bump distribution date (2025-01-09) 2025-01-09 00:27:38 +00:00
Erik van Luijk d57feeadaf 🐛 Fix JG Aurora A1 implementation (#27622) 2025-01-08 16:48:32 -06:00
ellensp 36623a2382 🐛 Fix config embed and restore (#27628)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2025-01-08 16:44:31 -06:00
ellensp 83278bdc17 🔨 Some boards with both LPC1768/9 (#27586) 2025-01-08 16:41:53 -06:00
Scott Lahteine 30697cb53f 🩹 Fix DGUS_LCD_UI_MKS typo
Fixes #27508

Co-Authored-By: vehystrix <7142781+vehystrix@users.noreply.github.com>
2025-01-08 16:41:49 -06:00
thinkyhead 4eb8a87193 [cron] Bump distribution date (2024-12-18) 2024-12-18 00:28:42 +00:00
ellensp d2814c7aa7 ✏️ Fix variant.h comment typo (#27594) 2024-12-17 14:09:01 -06:00
Giuliano Zaro 6f71a14150 🐛 Fix S6 V2 TMC communication error (#27595) 2024-12-17 14:07:05 -06:00
Scott Lahteine 1067950697 🔨 Fix and improve schema exports 2024-12-17 14:03:34 -06:00
Scott Lahteine 7b7add3843 📝 Config feedrate units
Followup to #27579
2024-12-17 14:03:34 -06:00
thinkyhead 05e67a9262 [cron] Bump distribution date (2024-12-17) 2024-12-17 00:29:50 +00:00
Scott Lahteine c4ef2d63e1 🔥 Remove obsolete support files
Followup to #15347
Originally from #10849
2024-12-16 15:30:01 -06:00
Scott Lahteine 2a137d6744 🩹 Fix build with Color UI touch items 2024-12-16 14:58:12 -06:00
Scott Lahteine c0becd6ce1 🔨 Scripted build/archive multiple envs (2) 2024-12-16 14:49:38 -06:00
Scott Lahteine d5dfd18c24 🔨 Scripted build/archive multiple envs 2024-12-15 20:35:05 -06:00
Scott Lahteine dcc10565f8 📝 @section calibration => calibrate 2024-12-15 20:35:05 -06:00
Scott Lahteine 4c388d7118 🚸 Limited number of DGUS fans 2024-12-15 18:44:18 -06:00
thinkyhead 94ca5487ab [cron] Bump distribution date (2024-12-16) 2024-12-16 00:31:26 +00:00
Scott Lahteine a23212bd95 🔨 Versioned ststm32 for BLACKBEEZMINI_V1 2024-12-15 16:31:08 -06:00
Scott Lahteine a748eaade7 🔨 Add offset_address for convenience 2024-12-15 16:31:08 -06:00
thinkyhead ba88365364 [cron] Bump distribution date (2024-12-13) 2024-12-13 00:30:12 +00:00
ellensp 8d9db0f899 🚸 Prevent very slow 'G29 S{value}' (ABL Mesh) (#27579)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-12-12 15:55:22 -06:00
thinkyhead 23bc810e6e [cron] Bump distribution date (2024-12-11) 2024-12-11 00:29:50 +00:00
Scott Lahteine 7ad4de2c08 🚸 Filter 'G29 S0' in ABL 2024-12-10 13:49:22 -06:00
thinkyhead d21e1d4dc8 [cron] Bump distribution date (2024-12-10) 2024-12-10 00:31:55 +00:00
Scott Lahteine 8b7cfa0429 🧑‍💻 Comment temperature methods, fix error spam 2024-12-09 15:00:35 -06:00
thinkyhead 906dcc7536 [cron] Bump distribution date (2024-12-09) 2024-12-09 06:09:45 +00:00
Scott Lahteine 061e026384 🎨 Remove extra hotend temp update
Followup to #24898
2024-12-08 23:42:27 -06:00
Mihai 5d591fd91d ️ Improve pulse timing, fix LPC176x jitter (#27131) 2024-12-08 18:55:16 -06:00
thinkyhead 854da5fd9e [cron] Bump distribution date (2024-12-08) 2024-12-08 06:08:33 +00:00
MageDelfador 7e45d56e66 🩹 Advance tone queue when muted, tuning (#26278) 2024-12-07 22:50:41 -06:00
Andrew 71ce7803e7 🎨 LCD conditional cleanup (#27539)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-12-07 20:11:30 -06:00
thinkyhead c5bf705717 [cron] Bump distribution date (2024-12-07) 2024-12-07 00:29:16 +00:00
Scott Lahteine e82b4e98a4 🔨 More informative probe conflict message (2) 2024-12-06 17:15:03 -06:00
Scott Lahteine c271a89a4f 🎨 Servo angles tweaks 2024-12-05 22:06:23 -06:00
Scott Lahteine ea993a657f 🔨 More informative probe conflict message 2024-12-05 22:06:23 -06:00
thinkyhead 5813488412 [cron] Bump distribution date (2024-12-06) 2024-12-06 00:29:38 +00:00
ellensp a365163ff0 🔨 Fix ESP32 build (for xtensa32) (2) (#27570)
Followup to #27561
2024-12-05 17:20:25 -06:00
Andrew 4668b27158 🔨 Reduce some 256KB Maple builds (#27488) 2024-12-05 13:57:57 -06:00
thinkyhead e733e50207 [cron] Bump distribution date (2024-12-05) 2024-12-05 00:29:46 +00:00
Red Echidna UK 5549d07da3 🚸 G34 Z-align in ProUI Home menu (#27567)
Co-authored-by: Ashley Baker <ashley.baker@redechidna.com>
2024-12-04 18:20:10 -06:00
Chris 257ffe98b1 🐛 Fix HC32 Clock Configuration (#27099) 2024-12-03 19:44:54 -06:00
thinkyhead 2ed5937daf [cron] Bump distribution date (2024-12-04) 2024-12-04 01:01:37 +00:00
Andrew 00c28eb9e3 🔨 Update hc32.ini (board_upload.offset_address) (#27550) 2024-12-03 17:59:45 -06:00
ellensp 63a7d42f30 📝 TinyBee note: 5V out-only pins! (#27563) 2024-12-03 17:55:33 -06:00
ellensp 94bd6d52e9 🔨 Fix ESP32 build (for xtensa32) (#27561) 2024-12-03 17:50:25 -06:00
Keith Bennett 9cbab467b4 📝 Add Bluesky badge (#27560) 2024-12-03 17:47:57 -06:00
thinkyhead db7828504e [cron] Bump distribution date (2024-12-03) 2024-12-03 00:30:39 +00:00
Scott Lahteine 4797f25428 🔨 Update config.ini, move undefs (#27562) 2024-12-01 23:05:34 -06:00
thinkyhead 6bd541d730 [cron] Bump distribution date (2024-12-02) 2024-12-02 00:30:57 +00:00
Andrew 3591eb5d5d 🔨 Improve build script compatibility (#27549) 2024-11-30 21:22:52 -06:00
Scott Lahteine 22182d9a98 🎨 #include cleanup 2024-11-30 19:40:58 -06:00
Scott Lahteine 1f61b743a6 📝 Delete extra Ender-3 V2 README 2024-11-30 19:38:25 -06:00
thinkyhead f071274493 [cron] Bump distribution date (2024-12-01) 2024-12-01 00:35:39 +00:00
Keith Bennett 2a4a89d8cb 📌 Update, pin LPC PIO framework (#27554) 2024-11-30 14:25:55 -06:00
Scott Lahteine a9f44e37a9 🔨 Improve build scripts 2024-11-30 14:21:16 -06:00
thinkyhead af05b6e482 [cron] Bump distribution date (2024-11-28) 2024-11-28 00:29:15 +00:00
Scott Lahteine 2b39e51a40 🔨 Fix schema.py ; Add build_example --index=N 2024-11-26 21:21:17 -06:00
thinkyhead 37f490fdd0 [cron] Bump distribution date (2024-11-27) 2024-11-27 00:29:14 +00:00
Scott Lahteine c57f715d00 🎨 Trinamic cleanup 2024-11-26 01:44:55 -06:00
thinkyhead 580c99ece2 [cron] Bump distribution date (2024-11-26) 2024-11-26 00:29:00 +00:00
saddfox eaab2dea92 🚸 Fix/improve Sovol SV06 Plus (#27531)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-11-24 21:52:58 -06:00
Andrew a7bd35b993 🧑‍💻 Python scripts cleanup, improve (#27533) 2024-11-24 21:12:24 -06:00
Vovodroid 8d864d797a 🚸 Adapt runout distance for FILAMENT_MOTION_SENSOR (#27540) 2024-11-24 21:07:14 -06:00
belge96 61649aa3c0 Mellow/Fly RRF E3 V1.0 (STM32F407VG) (#27466) 2024-11-24 19:45:10 -06:00
thinkyhead 220cd5a640 [cron] Bump distribution date (2024-11-25) 2024-11-25 00:29:51 +00:00
Scott Lahteine 72f2657a0e 📝 Update HAL documentation, README 2024-11-23 20:27:28 -06:00
thinkyhead fb61a50e21 [cron] Bump distribution date (2024-11-24) 2024-11-24 00:32:01 +00:00
ellensp 21257f7e21 🔧 Update Octopus EXP-2-10, WiFi pins (#27515) 2024-11-23 16:45:13 -06:00
Scott Lahteine 8df61893c3 🐛 Show probe/level menu for tramming (#27532) 2024-11-23 16:41:42 -06:00
rondlh 095f060c24 🧑‍💻 Fix some ExtUI return types (#27542) 2024-11-23 16:33:20 -06:00
Scott Lahteine f5a5d7a620 🧑‍💻 Fix up APPLY_STEP macros 2024-11-23 16:26:29 -06:00
thinkyhead fabc2002ed [cron] Bump distribution date (2024-11-23) 2024-11-23 06:07:43 +00:00
Scott Lahteine 3f264942cb 📝 Update README.md 2024-11-22 22:10:46 -06:00
thinkyhead 3810986dba [cron] Bump distribution date (2024-11-21) 2024-11-21 06:08:46 +00:00
Scott Lahteine 5951e646d0 🧑‍💻 Fix archive clean for build_example 2024-11-20 22:11:05 -06:00
thinkyhead d4c34205b5 [cron] Bump distribution date (2024-11-19) 2024-11-19 06:08:59 +00:00
Scott Lahteine c6bbed7cdb 🔥 Drop support for DevIoT, Atom
Followup to #15347
2024-11-18 23:58:07 -06:00
Scott Lahteine a531c01889 🩹 Update RP2040 pins debugging 2024-11-18 19:48:21 -06:00
Scott Lahteine 0f0e239264 Use Marlin-maintained TMCStepper 2024-11-18 19:18:18 -06:00
Scott Lahteine fa55caed1f 🩹 Daily cleanup Nov 18 2024-11-18 19:18:09 -06:00
Scott Lahteine bf98c16a00 🧑‍💻 Improve scripts to build examples 2024-11-18 19:16:13 -06:00
thinkyhead 72603b627a [cron] Bump distribution date (2024-11-16) 2024-11-16 00:28:18 +00:00
Scott Lahteine 284d07d4d8 📝 Describe more codes in gcode.h 2024-11-15 17:35:20 -06:00
thinkyhead 09a290cc61 [cron] Bump distribution date (2024-11-15) 2024-11-15 00:29:01 +00:00
d 25b9bb35ab 🐛 Fix BLTouch, Runout pins for Ender 2P v2.4 S4 (#27520) 2024-11-14 03:07:49 -06:00
thinkyhead 9e96b89856 [cron] Bump distribution date (2024-11-14) 2024-11-14 06:08:46 +00:00
InsanityAutomation 92efc33ace 🐛 G34 fail safely (#27516) 2024-11-13 22:10:07 -06:00
thinkyhead 81bad7b124 [cron] Bump distribution date (2024-11-13) 2024-11-13 00:27:04 +00:00
Scott Lahteine 1df97254cb 🔨 Fix path handling for generic variant (#27528) 2024-11-12 17:44:34 -06:00
Keith Bennett aa80cb0620 🔧 Direct Stepping sanity checks (#27522) 2024-11-12 17:17:49 -06:00
Andrew 4b6109f4e7 🩹 Fix E3V2 types, other warnings (#27507) 2024-11-12 16:54:06 -06:00
ellensp 70c3060769 🚸 Fix menu homing feedrate display (#27518) 2024-11-12 16:22:42 -06:00
ellensp 472f1ece2a 🩹 Fix G61 with no extruders (#27521) 2024-11-12 15:22:50 -06:00
Scott Lahteine f6c58c59c3 🔧 *_ENABLE_ON is LOW/HIGH 2024-11-12 14:47:30 -06:00
Vovodroid e6099fd83f 🚸 Set hybrid edit range to 999 (#27473)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-11-12 14:43:36 -06:00
thinkyhead 13af4e1ef1 [cron] Bump distribution date (2024-11-04) 2024-11-04 00:28:52 +00:00
Scott Lahteine 4869a3ffd9 🧑‍💻 Fix pinsformat.py pin pattern recognition 2024-11-03 16:38:21 -06:00
fmuntean c2d0008d2a M820 Report temporary M810-M819 macros (#27458)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-11-03 16:06:47 -06:00
Scott Lahteine 68ae15e2df 🔧 Extra axis serial RX pins 2024-11-03 16:06:47 -06:00
Scott Lahteine 91e4811534 🔧 Automatic Trinamic RX pins 2024-11-03 16:06:42 -06:00
ellensp d2fab914cd 🐛 Fix Thermocouple flags, allow bed only (#27504) 2024-11-03 14:27:21 -06:00
weldo 846ec6c66b 🩹 Update Ender-3 V3 SE pins (#27495)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-11-03 14:19:06 -06:00
Scott Lahteine d876b5ee3c RP2040 HAL with BTT SKR Pico (#24042) 2024-11-03 14:15:10 -06:00
Scott Lahteine 98ae2ad60a 🔧 Config @ section adjustments 2024-11-03 13:50:00 -06:00
thinkyhead a261a5b9a6 [cron] Bump distribution date (2024-11-03) 2024-11-03 00:30:00 +00:00
Scott Lahteine a7fcb495e4 🔧 Longer LK prefer Onboard SD 2024-11-02 19:12:02 -05:00
Scott Lahteine ea554a0609 🔧 More Quick Sensorless Homing warning 2024-11-02 18:54:27 -05:00
Scott Lahteine 08717d3f60 🔨 Simplify generic variants, update DFU tool (#27502) 2024-11-02 18:42:20 -05:00
thinkyhead 7b104a108f [cron] Bump distribution date (2024-10-30) 2024-10-30 00:27:31 +00:00
Scott Lahteine 9133a2f0f5 🧑‍💻 Ignores for Aider AI 2024-10-29 11:36:41 -05:00
Andrew dff2104c96 🎨 Planner cosmetics (#27497) 2024-10-29 10:38:50 -05:00
thinkyhead 163ca2783f [cron] Bump distribution date (2024-10-29) 2024-10-29 00:28:05 +00:00
ellensp 16f28e747b 🐛 Fix SHAPING_MENU X frequency edit (#27499) 2024-10-28 11:20:01 -05:00
Scott Lahteine 3b7aadb359 🚸 Restore Object Cancel info on Power-Loss Recovery (#27501)
* 🎨 Shorten feature includes
* 🚸 Save Canceled Objects with Power Loss data
2024-10-28 11:17:40 -05:00
thinkyhead 9e8d561549 [cron] Bump distribution date (2024-10-28) 2024-10-28 00:29:09 +00:00
Scott Lahteine b4a3e29fb6 🔨 Pins Debugging fix and cleanup (#27494)
* 🧑‍💻 Ignore Aider additions
* 🔨 Pins Debugging fix and cleanup
* 🔧 Auto-assign UART Rx based on Tx
2024-10-27 14:56:27 -05:00
thinkyhead d2bda128ab [cron] Bump distribution date (2024-10-21) 2024-10-21 00:28:30 +00:00
Scott Lahteine f8bbabfa31 🧑‍💻 Update log_machine_info 2024-10-20 14:02:15 -05:00
Scott Lahteine fc769ef023 🎨 Arduino IDE pins comments, generate version 2024-10-20 13:38:20 -05:00
Andrew 9192ae5213 🚸 EDITABLE_HOMING_FEEDRATE for ProUI (#27469) 2024-10-19 23:30:05 -05:00
Scott Lahteine 4c0e612376 📝 Config end block comments 2024-10-19 22:52:07 -05:00
ellensp b9f7d721ed 🔧 Better BABYSTEP_MULTIPLICATOR_Z sanity-checks (#27471) 2024-10-19 22:42:51 -05:00
schnurly b43d6ed5d3 🚸 MKS UI long filename WiFi upload (#27482) 2024-10-19 21:36:30 -05:00
thinkyhead e824e16a41 [cron] Bump distribution date (2024-10-20) 2024-10-20 00:30:02 +00:00
narno2202 0b72b8d819 🩹 Fix FT Motion LPC176x build (#27474) 2024-10-19 15:41:52 -05:00
Giuliano Zaro 37eb8bb1d5 🌐 Update Italian translation (#27476) 2024-10-19 15:26:48 -05:00
Keith Bennett d2ff2adabd 📌 Pin Ubuntu Runner to 22.04 (#27484) 2024-10-19 15:15:25 -05:00
InsanityAutomation f31cc84c2b 🐛 Fix LCD SPI on DUE (#27480) 2024-10-19 15:12:28 -05:00
thinkyhead 8beec5eaa5 [cron] Bump distribution date (2024-10-19) 2024-10-19 12:09:28 +00:00
Scott Lahteine 4e41ff32e1 🔨 Python config helpers (#27483) 2024-10-19 04:55:04 -05:00
thinkyhead cf137cb73a [cron] Bump distribution date (2024-10-17) 2024-10-17 00:27:08 +00:00
Scott Lahteine d5cc11d996 🧑‍💻 Fix Zed LSP setting 2024-10-16 16:23:57 -05:00
thinkyhead d62a631467 [cron] Bump distribution date (2024-10-14) 2024-10-14 12:10:36 +00:00
Scott Lahteine d6c3f45bda 🚸 LED menu tweaks 2024-10-14 02:03:41 -05:00
Scott Lahteine 81760d6818 🚸 EEPROM reset messages 2024-10-14 02:03:41 -05:00
Scott Lahteine 282f90c1b3 🚸 Ignore first click on asleep LCD 2024-10-14 02:03:41 -05:00
Scott Lahteine 5de9fc556f 🚸 Strings MSG_ZPROBE_[XYZ[OFFSET 2024-10-14 02:03:41 -05:00
Scott Lahteine 3482e9632c 🎨 Outdent, adjust comments 2024-10-14 02:03:41 -05:00
thinkyhead a6493e0cc8 [cron] Bump distribution date (2024-10-12) 2024-10-12 00:26:11 +00:00
Scott Lahteine a08a7b3459 📝 Clarify STRING_CONFIG_H_AUTHOR 2024-10-11 14:27:01 -05:00
Scott Lahteine bd4936330b 🧑‍💻 Language import adjustments 2024-10-11 13:47:28 -05:00
Scott Lahteine 4bb33a0cb9 🔨 Update legacy Makefile 2024-10-11 13:44:51 -05:00
thinkyhead 83e38b3625 [cron] Bump distribution date (2024-10-11) 2024-10-11 06:08:29 +00:00
Scott Lahteine 5b7bb3ea64 📝 Star History 2024-10-10 22:17:12 -05:00
thinkyhead f0b115a999 [cron] Bump distribution date (2024-10-09) 2024-10-09 00:26:50 +00:00
Vovodroid cebed347f5 🔧 Fix LIN_ADVANCE + Extra Axes sanity check (#27110) 2024-10-07 23:32:09 -05:00
Scott Lahteine a66b22c4f1 ♻️ BTT_SKR_3 => BTT_SKR_V3_0
Reverting 3a6bd6920e
2024-10-07 21:09:00 -05:00
thinkyhead fadaa2db09 [cron] Bump distribution date (2024-10-08) 2024-10-08 00:26:43 +00:00
Andrew f8954ca79b 📝 Fix comment missing ')' (#27325) 2024-10-07 13:00:29 -05:00
Scott Lahteine 4a3f69ad6d 🐛 Keep DMA2_Channel1 for STM32F1xx
Followup to #27385
2024-10-07 12:51:32 -05:00
Scott Lahteine 4bf13bea42 🎨 Apply some #ifndef 2024-10-06 20:06:35 -05:00
Scott Lahteine 3a6bd6920e ♻️ BTT_SKR_V3_0 => BTT_SKR_3 2024-10-06 20:06:35 -05:00
thinkyhead 70ef7978b4 [cron] Bump distribution date (2024-10-07) 2024-10-07 00:28:26 +00:00
pbmgit 37bc552f3b PELTIER_BED (#27334)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-10-06 11:14:53 -05:00
thinkyhead e310f20279 [cron] Bump distribution date (2024-10-06) 2024-10-06 00:29:36 +00:00
Scott Lahteine 4708635f4f 🔧 Fix Z3_USE_ENDSTOP check 2024-10-05 15:51:48 -05:00
Scott Lahteine f5d5b0a881 EDITABLE_HOMING_FEEDRATE / M210 (#27456) 2024-10-04 20:41:47 -05:00
thinkyhead 30f5dd339d [cron] Bump distribution date (2024-10-05) 2024-10-05 00:38:56 +00:00
Scott Lahteine 556d716919 Rename @ strings _A => _N 2024-10-04 18:53:15 -05:00
thinkyhead 76afd5afc1 [cron] Bump distribution date (2024-10-04) 2024-10-04 00:48:19 +00:00
rondlh 5c3bc2194a CONTROLLER_FAN_BED_HEATING (#27409) 2024-10-03 19:24:59 -05:00
Scott Lahteine 763cd7c5f2 🔧 Sort out MMU2 / MMU3 (#27455)
Followup to #26635
2024-10-03 19:21:50 -05:00
narno2202 11046b23a9 🔧 FT Motion Linear Advance K factor nnnn.nn (#27416)
Lost part of #26785
2024-10-03 18:32:05 -05:00
Keith Bennett 36b72926f3 BigTreeTech SKRat V1.0 (STM32G0B1VE) (#27361) 2024-10-03 13:44:14 -05:00
Scott Lahteine b35e16b1d8 Remove extra config restore 2024-10-03 13:41:49 -05:00
ellensp 767c87810b 🚸 GCODE_CASE_INSENSITIVE for Emergency Parser (#27449) 2024-10-03 13:19:42 -05:00
thinkyhead 52b6c45451 [cron] Bump distribution date (2024-10-03) 2024-10-03 18:07:32 +00:00
ellensp df5d08aec0 🔧 Retain LCD_LANGUAGE for TFT_COLOR_UI (#27454) 2024-10-03 12:16:53 -05:00
thinkyhead 8c61606691 [cron] Bump distribution date (2024-09-29) 2024-09-29 00:30:05 +00:00
David Fries e70bd3c785 🚸 G28 / G30 return for failed probe deploy (#25652)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-09-28 12:21:37 -05:00
thinkyhead 83cc983276 [cron] Bump distribution date (2024-09-28) 2024-09-28 06:07:33 +00:00
saddfox bbb8275d66 Sovol SV06 Plus Touchscreen (#25864)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-09-27 23:49:28 -05:00
Scott Lahteine 2afc2f268a 🧑‍💻 Remove CREALITY_RTS refs 2024-09-27 21:47:15 -05:00
Scott Lahteine aa44542f76 🔨 Suppress variant build warnings 2024-09-27 20:08:18 -05:00
thinkyhead 248648708f [cron] Bump distribution date (2024-09-25) 2024-09-25 06:08:29 +00:00
Scott Lahteine e2c0150fa8 🔨 Use env[PLATFORM]
Followup to f2d585ac7f
2024-09-24 20:31:41 -05:00
Scott Lahteine 4ef5372151 🔨 Update platform for MKS Tinybee and others (#27433)
* 🔨 Update ESP32 env for MKS Tinybee
* 🔨 Updated LPC common env
* 🔨 Other env improvements

Co-Authored-By: Martin Turski <turningtides@outlook.de>
2024-09-24 20:31:16 -05:00
Scott Lahteine a923771611 🩹 Fix missing _lcd_toggle_bed_leveling (#27439) 2024-09-23 23:52:14 -05:00
Scott Lahteine 74ffa0cc3e 🧑‍💻 More compatible opt helpers 2024-09-23 19:50:07 -05:00
Scott Lahteine f2d585ac7f 🔨 Skip bad compilers 2024-09-23 19:48:31 -05:00
thinkyhead 80cfdb182c [cron] Bump distribution date (2024-09-24) 2024-09-24 00:38:01 +00:00
ellensp 39463268fb ✏️ Assisted Tramming threads followup (#27437)
Followup to 45b9680c57
2024-09-23 19:16:56 -05:00
thinkyhead a7b3989bca [cron] Bump distribution date (2024-09-22) 2024-09-22 00:29:23 +00:00
Scott Lahteine 829212d76a 🎨 MMU2 const types 2024-09-21 17:24:15 -05:00
thinkyhead 0de4a70203 [cron] Bump distribution date (2024-09-19) 2024-09-19 00:25:59 +00:00
Scott Lahteine febfb3218e 🧑‍💻 Make sha256sum for archived binary 2024-09-18 10:39:19 -05:00
thinkyhead 4da46c5dd2 [cron] Bump distribution date (2024-09-18) 2024-09-18 00:25:46 +00:00
Scott Lahteine 353ede8208 🧑‍💻 Fix mftest using disabled MOTHERBOARD 2024-09-17 11:53:32 -05:00
thinkyhead 09de5e76a7 [cron] Bump distribution date (2024-09-17) 2024-09-17 00:21:48 +00:00
Scott Lahteine 73b6ba8fe3 🧑‍💻 More compatible Build Scripts
Followup to d36d9cb506
2024-09-16 17:45:55 -05:00
thinkyhead 72b09fe4cb [cron] Bump distribution date (2024-09-15) 2024-09-15 00:29:15 +00:00
Scott Lahteine e5ad13a8e2 📝 README shorten links, logo credit 2024-09-14 18:38:53 -05:00
thinkyhead b122e46adb [cron] Bump distribution date (2024-09-13) 2024-09-13 00:25:28 +00:00
ellensp 1a5866f5c6 🩹 Fix E3V2 non-TJC font size (#27375) 2024-09-12 17:29:46 -05:00
Scott Lahteine c7e62b33d1 🚸 Probe / Level Menu (#27393)
* 🎨 Housekeeping
* 🚸 Tweak UBL menu
* 🚸 Babystep Probe specific titles
* 🚸 Probe / Level Menu
2024-09-12 17:27:14 -05:00
thinkyhead 1916d4e27f [cron] Bump distribution date (2024-09-10) 2024-09-10 12:10:15 +00:00
Chris ce55a7bd9b 🩹 HC32: pin package versions (#27289) 2024-09-10 04:15:59 -05:00
InsanityAutomation 540120f863 🚸 G425 - Compute primary axes (Y..X) before others (#27382) 2024-09-10 03:16:28 -05:00
InsanityAutomation b99a26d6ab 🐛 Fix Dual Servo Toolchange Z Creep (#27381) 2024-09-10 03:07:44 -05:00
Scott Lahteine 6528109176 CI check boards.h, pins.h (#27415) 2024-09-10 01:11:26 -05:00
thinkyhead b94a0d036c [cron] Bump distribution date (2024-09-09) 2024-09-09 06:08:58 +00:00
David 7634ffe8e5 🚸 Fix alert level after Stow Z-Probe (#27404) 2024-09-08 22:29:35 -05:00
thinkyhead 8bae8bbf7a [cron] Bump distribution date (2024-09-08) 2024-09-08 12:08:37 +00:00
Scott Lahteine 5ce013f414 mfconfig => Configurations repo 2024-09-08 02:35:13 -05:00
Scott Lahteine da4a374b49 🎨 LCD pins cleanup - Sept 8 2024-09-08 01:01:59 -05:00
thinkyhead 81b13456b1 [cron] Bump distribution date (2024-09-07) 2024-09-07 06:07:08 +00:00
Scott Lahteine ee35fb07b0 🔨 Put Tronxy CXY products in build folder (#27353) 2024-09-06 21:31:16 -05:00
Scott Lahteine 99c991755a 🔧 No "base" needed for minimal config (2)
Followup to 90e5826256
2024-09-06 20:40:40 -05:00
thinkyhead a96ae85d88 [cron] Bump distribution date (2024-09-06) 2024-09-06 00:25:23 +00:00
Scott Lahteine 45b9680c57 🔧 Tramming screw threads 2024-09-05 15:21:07 -05:00
Scott Lahteine 83cbed8527 🔧 Config adjustments 2024-09-05 15:21:07 -05:00
Scott Lahteine d36d9cb506 🔧 Use string manglers in scripts 2024-09-05 15:12:24 -05:00
thinkyhead 9e6981ea60 [cron] Bump distribution date (2024-09-05) 2024-09-05 18:06:40 +00:00
Scott Lahteine 2c6f8a30f3 🚸 Fix extra Z raises (#27395) 2024-09-05 12:07:17 -05:00
konradmb 17a5a1f97d 🐛 Fix STM32 SDIO/FSMC DMA overlap (#27385)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-09-05 12:06:59 -05:00
thinkyhead a0815deb9a [cron] Bump distribution date (2024-09-04) 2024-09-04 00:25:26 +00:00
marbocub 76a7ab6893 🩹 Fix FT_MOTION_MENU lambda (#27401) 2024-09-03 14:38:04 -05:00
Scott Lahteine 7cd56a57f9 🎨 Misc. code format (2) 2024-09-03 14:01:30 -05:00
Scott Lahteine 56e2b60e6d 🧑‍💻 Quieter AUTO_REPORT_SD_STATUS option (#27391) 2024-09-03 01:08:49 -05:00
Scott Lahteine 8c15a093fd 🩹 Fix some kinematic conditions (2) 2024-09-02 20:19:31 -05:00
Scott Lahteine 7901eb97ad ️ G30 optimize and comment 2024-09-02 20:07:51 -05:00
Scott Lahteine 7aaba66d4d 🩹 Fix some kinematic conditions 2024-09-02 19:46:29 -05:00
Scott Lahteine 5f0b9d429f 🎨 Misc. code format 2024-09-02 19:46:29 -05:00
thinkyhead d34b62eafa [cron] Bump distribution date (2024-09-03) 2024-09-03 00:24:58 +00:00
DerAndere 3743980192 🔧 Assert zero Z homing clearance for some (#27370) 2024-09-02 18:48:00 -05:00
Scott Lahteine 41d53a15f2 🪠 Granular sub-options (2)
Followup to #27373
2024-09-02 16:02:03 -05:00
Scott Lahteine f234fbf87f 🧑‍💻 Refactor PROGMEM strings (#27390) 2024-09-02 04:28:50 -05:00
Scott Lahteine 5c728d1fb1 🧑‍💻 CardReader::isStillPrinting (#27392) 2024-09-02 01:34:48 -05:00
Scott Lahteine 162ea81894 🧑‍💻 Includes in Conditionals (for code dimming) (#27387) 2024-09-02 00:38:13 -05:00
thinkyhead 97b9fe83ee [cron] Bump distribution date (2024-09-02) 2024-09-02 00:26:20 +00:00
Scott Lahteine 9953230550 🧑‍💻 Build examples --output option (#27389) 2024-09-01 16:34:35 -05:00
Scott Lahteine 80bd10025b 🚸 More TFT Color UI fixes (#27388) 2024-09-01 14:02:03 -05:00
thinkyhead 0876bcd027 [cron] Bump distribution date (2024-08-31) 2024-08-31 00:24:54 +00:00
Scott Lahteine 3d7ac162fb 🧑‍💻 image2bin --transparency flag 2024-08-30 13:06:19 -05:00
Scott Lahteine 68a2459808 🚸 Fix / improve Marlin UI and Color UI 2024-08-29 21:52:14 -05:00
Scott Lahteine 21fddc1cc8 🧑‍💻 Update image2bin with "transparency" color 2024-08-29 21:41:14 -05:00
Scott Lahteine 528a1ad3e0 🧑‍💻 Move Uncrustify config 2024-08-29 21:38:57 -05:00
thinkyhead dabe374983 [cron] Bump distribution date (2024-08-30) 2024-08-30 00:25:03 +00:00
Scott Lahteine 8ac0f14796 🪠 More granular sub-options undef (#27373) 2024-08-28 20:41:12 -05:00
thinkyhead 934fc52d06 [cron] Bump distribution date (2024-08-29) 2024-08-29 00:25:00 +00:00
Scott Lahteine cf46d1880c 🚸 Purge PLR on power-off (2) 2024-08-28 15:46:53 -05:00
thinkyhead 4f159a94cd [cron] Bump distribution date (2024-08-28) 2024-08-28 06:08:14 +00:00
Scott Lahteine b53e14c7f8 🧑‍💻 Guard queue advance_r 2024-08-28 00:42:25 -05:00
Scott Lahteine 94e9f26544 🚸 Purge PLR on power-off 2024-08-28 00:42:25 -05:00
thinkyhead 9e87af70b7 [cron] Bump distribution date (2024-08-27) 2024-08-27 00:24:38 +00:00
Scott Lahteine fe56f5d3a6 🧑‍💻 Improve build_example 2024-08-26 16:11:47 -05:00
Scott Lahteine 90e5826256 🔧 No "base" needed for minimal config 2024-08-26 16:11:13 -05:00
Scott Lahteine bb73c335a5 🩹 Fix Ender-3 S1 Plus build 2024-08-26 16:11:13 -05:00
Scott Lahteine 4c1f76567c 🧑‍💻 build_all_examples --base --archive 2024-08-26 10:50:13 -05:00
Scott Lahteine d193c814d3 🩹 Fix misc warnings 2024-08-26 10:50:13 -05:00
narno2202 2cb252da4a 🩹 Fix FT_MOTION compile (#27367) 2024-08-25 23:20:11 -05:00
thinkyhead 9a04c32f7f [cron] Bump distribution date (2024-08-26) 2024-08-26 00:24:58 +00:00
Scott Lahteine 3b8e9fdd25 🔧 Reduce / update base configs 2024-08-25 00:16:04 -05:00
Scott Lahteine e0b045da49 🧑‍💻 Enhance build example scripts 2024-08-24 20:03:12 -05:00
thinkyhead 4220491a23 [cron] Bump distribution date (2024-08-25) 2024-08-25 00:26:53 +00:00
narno2202 3abe1fcf20 🔧🚸 FT_MOTION adjustments (#27359)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-08-23 23:58:31 -05:00
marbocub 02ed020f3f 🩹 Fix shaping init (#27365) 2024-08-23 23:45:46 -05:00
Scott Lahteine 934ac24ad8 🐛 FT Motion time-based endstop (#27349)
Co-authored-by: ulendoalex <111143418+ulendoalex@users.noreply.github.com>
2024-08-23 23:42:02 -05:00
Scott Lahteine e2d8b2fc26 🚸 Prefer probe XY feedrate for "blocking move"
Reverting part of 89b0143b
2024-08-23 23:32:14 -05:00
thinkyhead 3e8483d389 [cron] Bump distribution date (2024-08-24) 2024-08-24 00:23:23 +00:00
Erkan Ozgur Yilmaz a9c529f004 Prusa MMU3 (#26635)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-08-23 18:33:13 -05:00
Keith Bennett a664587219 🩹 Fix Sensorless Homing Current Warning (#27366) 2024-08-23 17:25:09 -05:00
thinkyhead 1619838592 [cron] Bump distribution date (2024-08-23) 2024-08-23 00:24:05 +00:00
Lubomir Rintel 98a33d37c7 🩹 Fix MINITRONICS v1 pins (#27150) 2024-08-22 11:01:42 -05:00
thinkyhead 12a2e5ae1b [cron] Bump distribution date (2024-08-22) 2024-08-22 00:24:06 +00:00
Scott Lahteine 9b472a02e9 PROBE_TARE_MENU 2024-08-21 18:36:49 -05:00
Scott Lahteine c84bea7110 🚸 LED Default may toggle On 2024-08-21 18:36:49 -05:00
ellensp 20f71fafa7 🧑‍💻 Use sim env for BOARD_SIMULATED in mftest (#27299) 2024-08-21 18:33:58 -05:00
ellensp 056e5a430e 🔧 Azteeg X3 Pro doesn't need DIGIPOTS_I2C_SDA_* (#27337) 2024-08-21 18:25:25 -05:00
Scott Lahteine 21a604407d 🚸 Move solo Case Light menu up 2024-08-21 17:46:27 -05:00
thinkyhead deb076b9cd [cron] Bump distribution date (2024-08-21) 2024-08-21 00:23:53 +00:00
Scott Lahteine b8e2ad9d8f 👷 resume_print params for timeout, filament load
Co-Authored-By: Erkan Ozgur Yilmaz <1786804+eoyilmaz@users.noreply.github.com>
2024-08-20 16:38:10 -05:00
Scott Lahteine 0cd9643957 🎨 Misc. cleanup (from MMU3 PR)
Co-Authored-By: Erkan Ozgur Yilmaz <1786804+eoyilmaz@users.noreply.github.com>
2024-08-20 16:38:10 -05:00
thinkyhead 8c78315f71 [cron] Bump distribution date (2024-08-20) 2024-08-20 00:24:02 +00:00
Scott Lahteine 35dad3fdfe 📝 BIQU MicroProbe followup 2024-08-19 15:00:15 -05:00
Scott Lahteine bebf5dc6ab GENERIC_BACK_MENU_ITEM 2024-08-19 14:50:26 -05:00
Scott Lahteine 2fd1c48e1a 👷 Prefer has_blocks_queued over movesplanned 2024-08-19 14:50:23 -05:00
thinkyhead 301727defc [cron] Bump distribution date (2024-08-18) 2024-08-18 00:26:18 +00:00
Scott Lahteine 1afd53a933 🔨 Suppress some Maple warnings 2024-08-17 18:02:23 -05:00
narno2202 381aeb94c6 🩹 Fix FT Motion toggle in active job (#27335)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-08-17 13:02:05 -05:00
thinkyhead 4a36520820 [cron] Bump distribution date (2024-08-17) 2024-08-17 00:23:13 +00:00
Scott Lahteine 430eedf5c0 👷 Optional IJKUVW endstops 2024-08-16 14:35:29 -05:00
Scott Lahteine 793a851d10 👷 !ELAPSED => PENDING 2024-08-16 14:34:05 -05:00
Scott Lahteine 2d609487ac 👷 FT Motion refactor, minor fix 2024-08-16 14:33:38 -05:00
Scott Lahteine 295f50379f 👷 Add UC elements to axis types 2024-08-16 14:31:51 -05:00
Scott Lahteine ecfff5099a 🎨 Misc. format, cleanup 2024-08-16 00:18:33 -05:00
Scott Lahteine 986344640f 🔧 Minimal configuration with Config.h (#27338) 2024-08-15 23:08:26 -05:00
thinkyhead 69f69606e6 [cron] Bump distribution date (2024-08-16) 2024-08-16 00:23:58 +00:00
sargonphin 2aa2e5487a ️ Improve Homing / Probing Current (#26714)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-08-15 18:30:55 -05:00
John Robertson 23d9020a65 M3 / M4 O for laser/spindle (#26883) 2024-08-15 16:09:41 -05:00
Scott Lahteine 43d9d1ce1b 🩹 Config-related preparations (2) 2024-08-15 15:37:30 -05:00
thinkyhead ed7f3b21c0 [cron] Bump distribution date (2024-08-13) 2024-08-13 00:33:32 +00:00
Scott Lahteine b062a3b226 🎨 FT Motion, axis cleanup 2024-08-12 17:48:41 -05:00
Scott Lahteine 89b0143b09 🔧 Config-related preparations 2024-08-11 20:35:23 -05:00
Scott Lahteine 0790a9d5df 🔧 Fix some LCD probing margins 2024-08-11 20:35:23 -05:00
Scott Lahteine e05ac66561 🔧 Fix extra endstop auto-assignment 2024-08-11 20:35:23 -05:00
Scott Lahteine 3b33f7ec03 🔨 Build script improvements 2024-08-11 20:35:23 -05:00
Scott Lahteine b94c75bcda 🎨 ProUI / MKS UI code cleanup 2024-08-11 20:35:23 -05:00
Scott Lahteine 8dc8906d78 🎨 Conditional probe.h 2024-08-11 20:35:23 -05:00
Keith Bennett ab684dc484 📝 New Discord link (#27330) 2024-08-11 20:02:00 -05:00
Scott Lahteine 37fb26b557 🩹 Fix W axis blocking move
Fixes #27332

Co-Authored-By: thebjtfellow <110046297+thebjtfellow@users.noreply.github.com>
Co-Authored-By: DerAndere <26200979+DerAndere1@users.noreply.github.com>
2024-08-11 20:00:54 -05:00
thinkyhead 7397e5a41d [cron] Bump distribution date (2024-08-12) 2024-08-12 00:25:11 +00:00
Keith Bennett 4a9d380117 🩹 Fix MKS Gen-L V1 PWM pins (#26974)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-08-11 15:45:37 -05:00
thinkyhead 0ec1a54309 [cron] Bump distribution date (2024-08-07) 2024-08-07 00:24:00 +00:00
Bkahl ab6e68c312 🎨 Improve LulzBot FTDI Eve Touch UI (#27275)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-08-06 14:52:17 -05:00
thinkyhead c509603530 [cron] Bump distribution date (2024-08-06) 2024-08-06 00:23:52 +00:00
narno2202 e5ce65c32b 🔧 BIQU MicroProbe + FT_MOTION sanity-check (#27302) 2024-08-05 17:54:18 -05:00
tombrazier 851257c44b 🐛 Fix MPC differential tuning (#27274) 2024-08-05 17:44:15 -05:00
thinkyhead 1662e953fc [cron] Bump distribution date (2024-07-30) 2024-07-30 00:23:59 +00:00
Scott Lahteine dde89795c9 🔨 Rename "BTT" things, MCU-based SKR 2 (#27319)
Co-authored-by: Keith Bennett <13375512+thisiskeithb@users.noreply.github.com>
2024-07-29 13:25:17 -05:00
thinkyhead 6e69ff93ef [cron] Bump distribution date (2024-07-29) 2024-07-29 18:06:59 +00:00
Keith Bennett 01b7d6c413 ️ Hold BTT renaming for later (#27307)
This reverts #27301
2024-07-29 11:25:31 -05:00
Andrew 58398832a1 📝 Tweak G26 O description (#27310)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-29 10:59:12 -05:00
dmitrygribenchuk 29469a0615 🎨 Python style tweaks (#27312) 2024-07-29 10:41:50 -05:00
Andrew b4dd20c0eb 🔨 Use Adafruit NeoPixel 1.12.3 (#27314) 2024-07-29 10:39:21 -05:00
thinkyhead eab13752dd [cron] Bump distribution date (2024-07-27) 2024-07-27 00:23:08 +00:00
Scott Lahteine ad60cdd030 🚸 G42 P as flag (not bool) 2024-07-26 02:40:35 -05:00
Evan Felix 78e111a4d0 🚸 Implement G60 / G61 to spec (#27281)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-26 00:13:52 -05:00
thinkyhead 5558729562 [cron] Bump distribution date (2024-07-26) 2024-07-26 00:23:28 +00:00
Scott Lahteine 2d32f7c377 👷 Smarter Flags<N> templates (#27309) 2024-07-25 15:36:20 -05:00
thinkyhead bcbdac6f6c [cron] Bump distribution date (2024-07-25) 2024-07-25 00:23:35 +00:00
Scott Lahteine acc8bf1c79 👷 Use char in binary send 2024-07-24 03:04:29 -05:00
Scott Lahteine 4f107e9fee 🔨 Suggest gcc14 for macOS Sim 2024-07-24 02:25:56 -05:00
Scott Lahteine 7844f3fa4f 🔨 Use -g2 for macOS Sim build to fix warnings 2024-07-24 01:02:31 -05:00
Keith Bennett 2f3af438ee 🔨 Rename BTT SKR V2.0 PIO envs (#27301) 2024-07-23 21:19:18 -05:00
thinkyhead 4483aa5b45 [cron] Bump distribution date (2024-07-24) 2024-07-24 00:24:31 +00:00
Scott Lahteine 20e6b6315e 📝 Config section reorganization 2024-07-23 17:59:14 -05:00
ellensp ca4248bdd5 🚸 Optional thermistors in Info Menu (#27303) 2024-07-23 16:47:22 -05:00
Scott Lahteine 4a5d8ba87e 👷 Local URL checking script (#26975) 2024-07-23 15:41:29 -05:00
Scott Lahteine 7a5d849857 🔨 No CONFIG_EXAMPLES_DIR in config signature 2024-07-23 15:18:06 -05:00
thinkyhead 95c23e55a4 [cron] Bump distribution date (2024-07-23) 2024-07-23 00:23:49 +00:00
Andrew 94ce0d24d6 👷 Add optimal stepper.set_e_position() (#27293)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-22 15:33:37 -05:00
Scott Lahteine cdea1b8460 👷 ATOMIC_SECTION macros 2024-07-22 14:54:17 -05:00
thinkyhead cc122bec82 [cron] Bump distribution date (2024-07-22) 2024-07-22 06:07:44 +00:00
Keith Bennett 6afaf0034c 🔧 Assert EDGE_STEPPING with TMC drivers (#27292)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-21 20:53:51 -05:00
thinkyhead 7f0d7e760b [cron] Bump distribution date (2024-07-20) 2024-07-20 12:07:55 +00:00
Keith Bennett 69004322f6 👷 Add Simulator CI test (#27288) 2024-07-20 01:47:23 -05:00
thinkyhead 7441094a41 [cron] Bump distribution date (2024-07-19) 2024-07-19 00:24:14 +00:00
Chris 29a5006df9 🧑‍💻 Update HC32 CRITICAL_SECTION macros (#27283)
Fixes #27282
2024-07-17 21:03:35 -05:00
thinkyhead 1aca038daf [cron] Bump distribution date (2024-07-18) 2024-07-18 00:23:29 +00:00
ellensp ce92eb46ec 🔧 Prevent LCD_PINS_EN false pin conflict (#27284) 2024-07-17 18:07:06 -05:00
ellensp c852e9c6a1 🔨 Fix preflight checks order (#27285)
Followup to #27249
2024-07-17 18:01:10 -05:00
ellensp 2b8db0c2e2 🎨 fix endif comment (#27286) 2024-07-17 17:58:55 -05:00
Scott Lahteine 74f297c871 🚸 FT Motion tune menu (#27279)
Co-authored-by: narno2202 <130909513+narno2202@users.noreply.github.com>
2024-07-17 12:05:53 -05:00
thinkyhead 76411392b7 [cron] Bump distribution date (2024-07-17) 2024-07-17 00:23:52 +00:00
Keith Bennett 74c81117c3 🔨 MarlinSimUI updates (#27276) 2024-07-16 14:31:42 -05:00
thinkyhead 6f04d8dc77 [cron] Bump distribution date (2024-07-16) 2024-07-16 00:23:45 +00:00
Scott Lahteine ade05c045e 🚸 Revert FT Motion tune menu 2024-07-15 15:28:03 -05:00
ellensp 5140726c70 🩹 Fix _MAX type warning (#27272) 2024-07-15 14:01:32 -05:00
Scott Lahteine 5334a8f0ed 🚸 Fix UI behavior for G29 with retry (#27146) 2024-07-15 13:59:19 -05:00
Mihai ee99eed3bf 🚸 Improved menu responsiveness with MarlinUI + U8Glib. (#26555)
Co-authored-by: Jason Smith <jason.inet@gmail.com>
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-15 13:57:25 -05:00
narno2202 9a5f1d2f51 🚸 FT Motion: Linear Advance adjustments (#26785)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-15 13:30:42 -05:00
narno2202 170df9040b 🚸 FT_MOTION Menu available in situ (#26670) 2024-07-15 13:27:10 -05:00
narno2202 f0bc4274f8 🧑‍💻 FT Motion: Individual axis shaping, new buffer management (#26848)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-15 13:13:00 -05:00
thinkyhead 20a704b154 [cron] Bump distribution date (2024-07-15) 2024-07-15 00:24:44 +00:00
ellensp 30a70c480c XTLW boards (#27260) 2024-07-14 12:57:17 -05:00
thinkyhead 1d5e9c7dee [cron] Bump distribution date (2024-07-14) 2024-07-14 06:08:19 +00:00
Scott Lahteine b8ab2d4987 🩹 Fix PINS_EXIST usage 2024-07-13 23:39:27 -05:00
ellensp ce796cec97 🧑‍💻 Fix pins debug / FastIO issues (#27261)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-13 23:33:11 -05:00
thinkyhead ad4de747ad [cron] Bump distribution date (2024-07-13) 2024-07-13 18:05:54 +00:00
Keith Bennett 95c1b7fb31 🔧 USART6 for STM32, expand port range (#27262) 2024-07-13 12:18:47 -05:00
ellensp 29b742cfc4 🔧 Fix MKS Base default 1.4 RGB pins (#27263) 2024-07-13 11:55:40 -05:00
tombrazier 57bda2ff3b 🐛 Fix NUM_ENDSTOP_STATES with Z_MIN_PROBE = Z_MIN (#27190)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-13 11:50:25 -05:00
John Robertson 228179e09b 🩹 Clock-based planner trapezoidal nominal_rate (#26881) 2024-07-13 11:47:46 -05:00
thinkyhead c961f3ab2b [cron] Bump distribution date (2024-07-12) 2024-07-12 00:23:21 +00:00
Scott Lahteine 3469cb9d24 🔧 Fallback STRING_CONFIG_H_AUTHOR 2024-07-11 16:27:52 -05:00
thinkyhead 6c09b83f30 [cron] Bump distribution date (2024-07-11) 2024-07-11 00:23:57 +00:00
ellensp 17a1363f4d 🐛 Fix ERR_EEPROM_NOPROM result (#27255)
Followup to #27199
2024-07-09 21:15:34 -05:00
thinkyhead 115350317c [cron] Bump distribution date (2024-07-10) 2024-07-10 00:23:49 +00:00
Justin Nesselrotte 44c2682168 RS485 support with G-code M485 (#25680)
Co-authored-by: Stephen Hawes <sphawes@gmail.com>
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-09 17:00:14 -05:00
ellensp 8b81aae870 Update preflight-checks.py for windows 2024-07-09 18:55:36 +12:00
thinkyhead 72a2699b10 [cron] Bump distribution date (2024-07-09) 2024-07-09 00:23:05 +00:00
Keith Bennett b7c07f1329 🚸 Fix G33 display precision (3 digits) (#27186) 2024-07-08 19:13:21 -05:00
Vovodroid 2b9a62093a 🚸 Edit IS frequency while moving (#27248) 2024-07-08 19:03:20 -05:00
ellensp 3385b4c280 🔨 Auto-replace BOTH / EITHER in configs (#27249)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-08 18:46:03 -05:00
thinkyhead 7c1f82cd96 [cron] Bump distribution date (2024-07-08) 2024-07-08 18:06:51 +00:00
Roxy-3D 9ebfdc4a86 Update README.md with hotlink to all supported boards 2024-07-08 10:35:41 -05:00
thinkyhead 586313c2fb [cron] Bump distribution date (2024-07-07) 2024-07-07 00:25:40 +00:00
David Buezas 571783fc04 🚸 SD card wake on insert, status screen on remove (#27197)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-06 17:41:02 -05:00
Scott Lahteine 4af5229cee 🧑‍💻 Conditional HAS_LED_POWEROFF_TIMEOUT 2024-07-05 20:08:07 -05:00
thinkyhead e0dcc610da [cron] Bump distribution date (2024-07-06) 2024-07-06 00:22:12 +00:00
Scott Lahteine 4aff10785e 🧑‍💻 Use "enum class" 2024-07-05 18:48:41 -05:00
thinkyhead d0e110d666 [cron] Bump distribution date (2024-07-05) 2024-07-05 06:08:13 +00:00
Vovodroid 10ffb9cb68 FAN_KICKSTART_LINEAR (#27072) 2024-07-04 21:22:16 -05:00
Keith Bennett b303bb1e56 🔧 English as default on MKS H43 (#27218) 2024-07-04 20:57:21 -05:00
Keith Bennett e6a61b182f 🐛 Fix E3S1PRO DGUS builds (#27211)
Partially reverts #26261
2024-07-04 20:37:43 -05:00
Keith Bennett 785b1da021 🐛 Fix YHCB2004 builds (#27210)
Co-authored-by: ellensp <530024+ellensp@users.noreply.github.com>
2024-07-04 20:36:17 -05:00
tombrazier a4d20031ec 🐛 Fix backlash intial direction (#27208)
Fix regression from #25791
2024-07-04 20:33:45 -05:00
tombrazier 3c60145792 🩹 Fix "calibration" endstop report (#27207)
Followup to #27204
2024-07-04 20:31:25 -05:00
Keith Bennett f2940adcf1 🔥 Drop BTT Manta XFER environments (#27240)
USB is connected to SoC (CM4/CB1/CB2), not MCU
2024-07-04 19:50:34 -05:00
Keith Bennett b5b9cc0b79 🔥 Drop BOARD_BIGTREE_SKR_V1_2 "renamed" reference (#27230) 2024-07-04 19:48:48 -05:00
ellensp 1d1eb97567 🚸 Update Zonestar OLEDs to SPI (#27220)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-07-04 19:43:17 -05:00
thinkyhead 0103cffcd0 [cron] Bump distribution date (2024-07-02) 2024-07-02 00:23:05 +00:00
Mihai 6fed66dd42 🩹️ Fix judder, optimize planner (#27035) 2024-07-01 13:56:06 -05:00
thinkyhead c81416438d [cron] Bump distribution date (2024-06-30) 2024-06-30 00:25:29 +00:00
Scott Lahteine c95825a0ff 🔧 Simplify sensitive pins (#27219) 2024-06-29 15:50:35 -05:00
David Buezas b6284c9f01 🚸 Skip REINIT_NOISY_LCD for I2C OLED (#27222) 2024-06-29 15:43:08 -05:00
thinkyhead f84a97f51c [cron] Bump distribution date (2024-06-29) 2024-06-29 00:22:24 +00:00
Scott Lahteine 563296fc8b 🩹 LCD_CONTRAST => LCD_CONTRAST_INIT 2024-06-28 12:52:36 -05:00
thinkyhead 13290e798b [cron] Bump distribution date (2024-06-28) 2024-06-28 00:22:46 +00:00
thisiskeithb 96e3dfed46 🩹 Fix/Add Malyan M300 E0_AUTO_FAN_PIN 2024-06-27 19:00:20 -05:00
David Buezas cb6fd130ba ️ Load/init (most) settings after showing boot-screen (#27199)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
Co-authored-by: Peter Ellens <ellensp@users.noreply.github.com>
2024-06-27 18:37:35 -05:00
Scott Lahteine 11f90de873 🩹 Set color 1 on DOGM clear
Followup to `clear_for_drawing`
2024-06-27 18:35:00 -05:00
Keith Bennett 9240ec89d0 Add fail-fast: true default strategy to build test CI (#27215) 2024-06-27 11:50:26 -05:00
thinkyhead 8cf2a41f81 [cron] Bump distribution date (2024-06-27) 2024-06-27 00:22:45 +00:00
Scott Lahteine 1f9fc665ec 🚸 MarlinUI:: clear_for_drawing 2024-06-26 18:27:05 -05:00
Keith Bennett bf1995140a 🔨 TMC2100 is STANDALONE (#27209) 2024-06-26 16:26:42 -05:00
David Buezas 7b21cd5d72 🩹 Don't reinit i2c LCDs (#27194)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-06-26 16:04:58 -05:00
thinkyhead 37fc32d972 [cron] Bump distribution date (2024-06-26) 2024-06-26 06:07:26 +00:00
Ben 9a6d4b5e56 🚸 PLR: Add FR and Flow (#27201)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-06-25 22:34:33 -05:00
thinkyhead 1e0719dac5 [cron] Bump distribution date (2024-06-25) 2024-06-25 00:22:37 +00:00
Jonathan Brazier f2248f79d3 ️ Implement CALIBRATION_GCODE as endstop (#27204) 2024-06-24 14:52:49 -05:00
thinkyhead 60d843b540 [cron] Bump distribution date (2024-06-22) 2024-06-22 06:07:24 +00:00
Keith Bennett 6d7d281559 🔧 Warning for ZV Shaping on CoreQZ (#27200) 2024-06-21 19:38:11 -05:00
thinkyhead b3d462b890 [cron] Bump distribution date (2024-06-20) 2024-06-20 18:07:46 +00:00
Scott Lahteine a7444021c6 🔨 Fatal error for wrong GCC on macOS Native Sim 2024-06-20 12:53:58 -05:00
thinkyhead a93acbd35c [cron] Bump distribution date (2024-06-17) 2024-06-17 00:24:05 +00:00
Vovodroid d978123289 🔧 Nonlinear Extrusion optional Adaptive Smoothing (#27175) 2024-06-16 16:21:57 -05:00
Keith Bennett ee8dada752 ♻️ DISABLE_ENCODER => NO_BACK_MENU_ITEM (#27180) 2024-06-16 16:10:12 -05:00
ellensp 7bc6261d2a 🐛 Mount media early for POWER_LOSS_RECOVERY (#27177) 2024-06-15 20:14:46 -05:00
thinkyhead 013c3bcd82 [cron] Bump distribution date (2024-06-16) 2024-06-16 00:31:38 +00:00
Scott Lahteine 2fc86ad836 🐛 Fix homing when FT Motion exists (#27179) 2024-06-15 19:11:19 -05:00
Mihai 082dc24865 🧑‍💻 Adjust pulse_phase_isr code guards (#27112) 2024-06-15 18:01:36 -05:00
Mihai d7b6acc03d ️ Optimize LPC176x set_pwm_duty (#27178) 2024-06-15 17:55:45 -05:00
thinkyhead a1dc2856de [cron] Bump distribution date (2024-06-15) 2024-06-15 00:22:26 +00:00
Andrew 959be66cc2 🔨 Build scripts cleanup (#27157)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-06-14 16:01:34 -05:00
thinkyhead ae2843940f [cron] Bump distribution date (2024-06-14) 2024-06-14 06:07:52 +00:00
Mihai 611ceedc1d 🐛 Fix step oversampling with NONLINEAR_EXTRUSION (#27171)
Followup to #27113
2024-06-13 23:05:05 -05:00
thinkyhead 38298076d6 [cron] Bump distribution date (2024-06-13) 2024-06-13 18:06:44 +00:00
Nicolas Graziano 1f0b8d6cd8 🚸 AnyCubic Vyper LCD improvements (#27158)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-06-13 11:50:16 -05:00
thinkyhead e0d683baed [cron] Bump distribution date (2024-06-12) 2024-06-12 00:22:43 +00:00
Nicolas Graziano f4f75b6b12 🔨 Rename AnyCubic Vyper binary (#27167)
The vyper board need a file name which begin with 'main_board_'
2024-06-11 14:31:57 -05:00
thinkyhead fb6dc90a85 [cron] Bump distribution date (2024-06-11) 2024-06-11 00:22:36 +00:00
Bob Kuhn b99391c810 🚸🐛 Anycubic Vyper fixes (1) (#26261) 2024-06-10 14:20:03 -05:00
Vovodroid d9fc4f3a99 🚸 Nonlinear Extrusion polynomial Av^2+Bv+C (#27162) 2024-06-10 13:42:28 -05:00
Scott Lahteine daeffbc944 🚸 Prefer friendly Power Off over Auto-unalive 2024-06-10 12:51:21 -05:00
Scott Lahteine 87dde46fb0 🔧 Assume RAMPS_CREALITY is not CR2020 2024-06-10 12:51:21 -05:00
thinkyhead d96c6f867d [cron] Bump distribution date (2024-06-10) 2024-06-10 06:07:31 +00:00
Scott Lahteine 1f2e6d5434 📝 "Boards Manager" 2024-06-09 17:38:55 -05:00
thinkyhead 232b989d50 [cron] Bump distribution date (2024-06-09) 2024-06-09 00:25:46 +00:00
TheRaf974 d38261c908 🔧 Overridable SUICIDE_PIN for RAMPS_CREALITY (#27143) 2024-06-08 16:45:51 -05:00
Ryan P 3075bc3b7b 🚸🐛 SW SPI Mode 3 for U8G on STM32 (#27111) 2024-06-08 16:03:21 -05:00
Scott Lahteine 842d0b1c9f 🎨 Misc. SPI cleanup 2024-06-08 15:55:36 -05:00
Scott Lahteine 042b238dd8 🧑‍💻 USE_SOFTWARE_SPI => SDFAT_USE_SOFTWARE_SPI 2024-06-08 15:55:36 -05:00
Scott Lahteine c30904b631 🧑‍💻 U8G_SPI_USE_MODE_3 for *_MINI_12864 2024-06-08 15:55:36 -05:00
Mihai 225a71f4cd ️ Optimize LPC176x pin toggle (#27149) 2024-06-08 13:33:08 -05:00
ellensp 1d29a56344 🔧 Fix Z_MULTI_ENDSTOPS pin post-process (#27137) 2024-06-08 13:27:13 -05:00
ellensp 320e00267d ✏️ Fix comma typo (#27138) 2024-06-07 20:38:44 -05:00
thinkyhead 9869629b67 [cron] Bump distribution date (2024-06-08) 2024-06-08 00:23:12 +00:00
Scott Lahteine 3da78e85bf 📝 Remove dead video links 2024-06-07 17:25:42 -05:00
thinkyhead 11a4314261 [cron] Bump distribution date (2024-06-06) 2024-06-06 06:07:15 +00:00
Mihai 65c19f82b9 🔧 Minimum Stepper Pulse in Nanoseconds (#27113) 2024-06-05 21:26:09 -05:00
thinkyhead 0169cde8a4 [cron] Bump distribution date (2024-06-03) 2024-06-03 00:23:09 +00:00
InsanityAutomation ab0173b7e6 🚸 ExtUI: Shaping, Probing limits (#26754) 2024-06-02 14:45:19 -05:00
thinkyhead 95f81d2565 [cron] Bump distribution date (2024-05-29) 2024-05-29 00:26:13 +00:00
Scott Lahteine 9c922f0eab 🧑‍💻 Fix test STM32F103RC_btt_USB 2024-05-28 19:05:03 -05:00
Scott Lahteine 35a03d66e5 🔨 Update SAMD51 build deps 2024-05-28 18:49:39 -05:00
Mihai a4a0887fa7 🐛 Fix NONE, ALL, EVAL macro collision (#27132) 2024-05-28 18:22:39 -05:00
thinkyhead e7c9cf3e1d [cron] Bump distribution date (2024-05-27) 2024-05-27 00:22:53 +00:00
ellensp 6710616a09 🩹 Longer3D LK has ONBOARD_SDIO (#27129) 2024-05-26 12:09:18 -05:00
Scott Lahteine 2064c83c66 🚸 Fix SD nav after "one click print" (2) 2024-05-26 12:04:14 -05:00
thinkyhead 2e97ad1f4b [cron] Bump distribution date (2024-05-26) 2024-05-26 12:07:31 +00:00
Scott Lahteine 4f85f88ae3 🚸 Fix SD nav after "one click print" 2024-05-26 02:18:37 -05:00
InsanityAutomation fd622e9b01 Update settings.cpp 2024-03-11 16:39:46 -04:00
InsanityAutomation d2373b847a ExtUI calls, gcode edit, edit menus etc 2024-03-11 16:35:33 -04:00
InsanityAutomation b10f7181e0 Update settings.cpp 2024-03-11 15:50:37 -04:00
InsanityAutomation 5455499945 Preheat chamber on temp menu preheat 2024-03-11 15:46:53 -04:00
InsanityAutomation 17feb1640e add chamber type to preheat struct 2024-03-11 15:41:48 -04:00
InsanityAutomation fed71986c8 Reapply Chamber Preheat 2024-03-11 15:33:31 -04:00
1246 changed files with 54085 additions and 72927 deletions
+21
View File
@@ -0,0 +1,21 @@
# Build artifacts
buildroot/
*.o
*.a
*.so
*.dylib
*.dll
*.exe
# Web assets
*.min.js
*.min.css
# Generated files
__pycache__/
*.pyc
.DS_Store
# IDE files
.vscode/
.idea/
+1 -1
View File
@@ -7,7 +7,7 @@ contact_links:
url: https://www.facebook.com/groups/1049718498464482
about: Please ask and answer questions here.
- name: 🕹 Marlin on Discord
url: https://discord.gg/n5NJ59y
url: https://discord.com/servers/marlin-firmware-461605380783472640
about: Join the Discord server for support and discussion.
- name: 🔗 Marlin Discussion Forum
url: https://reprap.org/forum/list.php?415
+1 -1
View File
@@ -43,7 +43,7 @@ We have a Message Board and a Facebook group where our knowledgable user communi
If chat is more your speed, you can join the MarlinFirmware Discord server:
* Use the link https://discord.gg/n5NJ59y to join up as a General User.
* Use the link https://discord.com/servers/marlin-firmware-461605380783472640 to join up as a General User.
* Even though our Discord is pretty active, it may take a while for community members to respond &mdash; please be patient!
* Use the `#general` channel for general questions or discussion about Marlin.
* Other channels exist for certain topics or are limited to Patrons. Check the channel list.
+1 -1
View File
@@ -14,7 +14,7 @@ jobs:
autolabel:
name: Auto Label
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
steps:
- name: Auto Label for [BUG]
uses: actions/github-script@v7
+1 -1
View File
@@ -14,7 +14,7 @@ jobs:
name: Bump Distribution Date
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
steps:
+1 -1
View File
@@ -18,7 +18,7 @@ jobs:
name: PR Bad Target
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
steps:
- uses: superbrothers/close-pull-request@v3
+18 -5
View File
@@ -34,14 +34,19 @@ jobs:
name: Build Test
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
strategy:
fail-fast: true
matrix:
test-platform:
# RP2040
- SKR_Pico
# Native
- linux_native
- simulator_linux_release
# AVR
- mega2560
@@ -104,11 +109,11 @@ jobs:
# STM32F4
- ARMED
- BIGTREE_BTT002
- BIGTREE_GTR_V1_0
- BIGTREE_SKR_PRO
- BTT_BTT002
- BTT_GTR_V1_0
- BTT_SKR_PRO
- FLYF407ZG
- FYSETC_S6
- STM32F446VE_fysetc
- LERDGEK
- LERDGEX
- mks_robin_pro2
@@ -181,6 +186,14 @@ jobs:
pio upgrade --dev
pio pkg update --global
- name: Install Simulator dependencies
run: |
sudo apt-get update
sudo apt-get install build-essential
sudo apt-get install libsdl2-dev
sudo apt-get install libsdl2-net-dev
sudo apt-get install libglm-dev
- name: Run ${{ matrix.test-platform }} Tests
run: |
make tests-single-ci TEST_TARGET=${{ matrix.test-platform }}
+1 -1
View File
@@ -36,7 +36,7 @@ jobs:
# pulls them into additional branches.
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
steps:
- name: Check out the PR
+48
View File
@@ -0,0 +1,48 @@
#
# ci-validate-boards.yml
# Validate boards.h to make sure it's all set up correctly
#
name: CI - Validate boards.h
# We can do the on: section as two items, one for pull requests and one for pushes...
on:
pull_request:
branches:
- bugfix-2.1.x
paths:
- 'Marlin/src/core/boards.h'
push:
branches:
- bugfix-2.1.x
paths:
- 'Marlin/src/core/boards.h'
jobs:
validate_pins_files:
name: Validate boards.h
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-22.04
steps:
- name: Check out the PR
uses: actions/checkout@v4
- name: Cache pip
uses: actions/cache@v4
with:
path: ~/.cache/pip
key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
restore-keys: |
${{ runner.os }}-pip-
- name: Select Python 3.9
uses: actions/setup-python@v5
with:
python-version: '3.9'
architecture: 'x64'
- name: Validate core/boards.h
run: |
make validate-boards -j
+1 -1
View File
@@ -26,7 +26,7 @@ jobs:
name: Validate Pins Files
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
steps:
- name: Check out the PR
+1 -1
View File
@@ -13,7 +13,7 @@ on:
jobs:
remove_label:
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
strategy:
matrix:
+1 -1
View File
@@ -14,7 +14,7 @@ jobs:
name: Close Stale Issues
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
steps:
- uses: actions/stale@v9
+1 -1
View File
@@ -14,7 +14,7 @@ jobs:
name: Lock Closed Issues
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
steps:
- uses: dessant/lock-threads@v5
+1 -1
View File
@@ -14,7 +14,7 @@ jobs:
name: Unlock Reopened
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
runs-on: ubuntu-22.04
steps:
- uses: OSDKDev/unlock-issues@v1.1
+4
View File
@@ -125,6 +125,7 @@ vc-fileutils.settings
# Visual Studio Code
.vscode/*
!.vscode/extensions.json
*.code-workspace
# Simulation files
imgui.ini
@@ -168,3 +169,6 @@ __pycache__
tags
*.logs
*.bak
.aider*
!.aiderignore
.env
+16
View File
@@ -0,0 +1,16 @@
/**
* Marlin-specific settings for Zed
*
* For a full list of overridable settings, and general information on folder-specific settings,
* see the documentation: https://zed.dev/docs/configuring-zed#settings-files
*/
{
"languages": {
"C": {
"enable_language_server": false
},
"C++": {
"enable_language_server": false
}
}
}
+10 -1
View File
@@ -6,9 +6,10 @@ UNIT_TEST_CONFIG ?= default
help:
@echo "Tasks for local development:"
@echo "make marlin : Build marlin for the configured board"
@echo "make marlin : Build Marlin for the configured board"
@echo "make format-pins -j : Reformat all pins files (-j for parallel execution)"
@echo "make validate-pins -j : Validate all pins files, fails if any require reformatting"
@echo "make validate-boards -j : Validate boards.h and pins.h for standards compliance"
@echo "make tests-single-ci : Run a single test from inside the CI"
@echo "make tests-single-local : Run a single test locally"
@echo "make tests-single-local-docker : Run a single test locally, using docker"
@@ -102,3 +103,11 @@ format-pins: $(PINS)
validate-pins: format-pins
@echo "Validating pins files"
@git diff --exit-code || (git status && echo "\nError: Pins files are not formatted correctly. Run \"make format-pins\" to fix.\n" && exit 1)
BOARDS_FILE := Marlin/src/core/boards.h
.PHONY: validate-boards
validate-boards:
@echo "Validating boards.h file"
@python $(SCRIPTS_DIR)/validate_boards.py $(BOARDS_FILE) || (echo "\nError: boards.h file is not valid. Please check and correct it.\n" && exit 1)
+310 -222
View File
File diff suppressed because it is too large Load Diff
+369 -228
View File
File diff suppressed because it is too large Load Diff
+109 -78
View File
@@ -187,6 +187,17 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1033)
# RAMPS Plus 3DYMY (Power outputs: Spindle, Controller Fan)
else ifeq ($(HARDWARE_MOTHERBOARD),1034)
# RAMPS 1.6+ (Power outputs: Hotend, Fan, Bed)
else ifeq ($(HARDWARE_MOTHERBOARD),1035)
# RAMPS 1.6+ (Power outputs: Hotend0, Hotend1, Bed)
else ifeq ($(HARDWARE_MOTHERBOARD),1036)
# RAMPS 1.6+ (Power outputs: Hotend, Fan0, Fan1)
else ifeq ($(HARDWARE_MOTHERBOARD),1037)
# RAMPS 1.6+ (Power outputs: Hotend0, Hotend1, Fan)
else ifeq ($(HARDWARE_MOTHERBOARD),1038)
# RAMPS 1.6+ (Power outputs: Spindle, Controller Fan)
else ifeq ($(HARDWARE_MOTHERBOARD),1039)
#
# RAMPS Derivatives - ATmega1280, ATmega2560
#
@@ -221,108 +232,113 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1112)
else ifeq ($(HARDWARE_MOTHERBOARD),1113)
# BigTreeTech or BIQU KFB2.0
else ifeq ($(HARDWARE_MOTHERBOARD),1114)
# zrib V2.0 (Chinese RAMPS replica)
# Zonestar zrib V2.0 (Chinese RAMPS replica)
else ifeq ($(HARDWARE_MOTHERBOARD),1115)
# zrib V5.2 (Chinese RAMPS replica)
# Zonestar zrib V5.2 (Chinese RAMPS replica)
else ifeq ($(HARDWARE_MOTHERBOARD),1116)
# Felix 2.0+ Electronics Board (RAMPS like)
# Zonestar zrib V5.3 (Chinese RAMPS replica)
else ifeq ($(HARDWARE_MOTHERBOARD),1117)
# Invent-A-Part RigidBoard
# Felix 2.0+ Electronics Board (RAMPS like)
else ifeq ($(HARDWARE_MOTHERBOARD),1118)
# Invent-A-Part RigidBoard V2
# Invent-A-Part RigidBoard
else ifeq ($(HARDWARE_MOTHERBOARD),1119)
# Sainsmart 2-in-1 board
# Invent-A-Part RigidBoard V2
else ifeq ($(HARDWARE_MOTHERBOARD),1120)
# Ultimaker
# Sainsmart 2-in-1 board
else ifeq ($(HARDWARE_MOTHERBOARD),1121)
# Ultimaker (Older electronics. Pre 1.5.4. This is rare)
# Ultimaker
else ifeq ($(HARDWARE_MOTHERBOARD),1122)
# Ultimaker (Older electronics. Pre 1.5.4. This is rare)
else ifeq ($(HARDWARE_MOTHERBOARD),1123)
MCU ?= atmega1280
PROG_MCU ?= m1280
# Azteeg X3
else ifeq ($(HARDWARE_MOTHERBOARD),1123)
# Azteeg X3 Pro
else ifeq ($(HARDWARE_MOTHERBOARD),1124)
# Ultimainboard 2.x (Uses TEMP_SENSOR 20)
# Azteeg X3 Pro
else ifeq ($(HARDWARE_MOTHERBOARD),1125)
# Rumba
# Ultimainboard 2.x (Uses TEMP_SENSOR 20)
else ifeq ($(HARDWARE_MOTHERBOARD),1126)
# Raise3D N series Rumba derivative
# Rumba
else ifeq ($(HARDWARE_MOTHERBOARD),1127)
# Rapide Lite 200 (v1, low-cost RUMBA clone with drv)
# Raise3D N series Rumba derivative
else ifeq ($(HARDWARE_MOTHERBOARD),1128)
# Formbot T-Rex 2 Plus
# Rapide Lite 200 (v1, low-cost RUMBA clone with drv)
else ifeq ($(HARDWARE_MOTHERBOARD),1129)
# Formbot T-Rex 3
# Formbot T-Rex 2 Plus
else ifeq ($(HARDWARE_MOTHERBOARD),1130)
# Formbot Raptor
# Formbot T-Rex 3
else ifeq ($(HARDWARE_MOTHERBOARD),1131)
# Formbot Raptor 2
# Formbot Raptor
else ifeq ($(HARDWARE_MOTHERBOARD),1132)
# bq ZUM Mega 3D
# Formbot Raptor 2
else ifeq ($(HARDWARE_MOTHERBOARD),1133)
# MakeBoard Mini v2.1.2 by MicroMake
# bq ZUM Mega 3D
else ifeq ($(HARDWARE_MOTHERBOARD),1134)
# TriGorilla Anycubic version 1.3-based on RAMPS EFB
# MakeBoard Mini v2.1.2 by MicroMake
else ifeq ($(HARDWARE_MOTHERBOARD),1135)
# ... Ver 1.4
# TriGorilla Anycubic version 1.3-based on RAMPS EFB
else ifeq ($(HARDWARE_MOTHERBOARD),1136)
# ... Rev 1.1 (new servo pin order)
# ... Ver 1.4
else ifeq ($(HARDWARE_MOTHERBOARD),1137)
# Creality: Ender-4, CR-8
# ... Rev 1.1 (new servo pin order)
else ifeq ($(HARDWARE_MOTHERBOARD),1138)
# Creality: CR10S, CR20, CR-X
# Creality: Ender-4, CR-8
else ifeq ($(HARDWARE_MOTHERBOARD),1139)
# Dagoma F5
# Creality: CR10S, CR20, CR-X
else ifeq ($(HARDWARE_MOTHERBOARD),1140)
# FYSETC F6 1.3
# Dagoma F5
else ifeq ($(HARDWARE_MOTHERBOARD),1141)
# FYSETC F6 1.4
# Dagoma D6 (as found in the Dagoma DiscoUltimate V2 TMC)
else ifeq ($(HARDWARE_MOTHERBOARD),1142)
# Wanhao Duplicator i3 Plus
# FYSETC F6 1.3
else ifeq ($(HARDWARE_MOTHERBOARD),1143)
# VORON Design
# FYSETC F6 1.4
else ifeq ($(HARDWARE_MOTHERBOARD),1144)
# Tronxy TRONXY-V3-1.0
# Wanhao Duplicator i3 Plus
else ifeq ($(HARDWARE_MOTHERBOARD),1145)
# Z-Bolt X Series
# VORON Design
else ifeq ($(HARDWARE_MOTHERBOARD),1146)
# TT OSCAR
# Tronxy TRONXY-V3-1.0
else ifeq ($(HARDWARE_MOTHERBOARD),1147)
# Overlord/Overlord Pro
# Z-Bolt X Series
else ifeq ($(HARDWARE_MOTHERBOARD),1148)
# ADIMLab Gantry v1
# TT OSCAR
else ifeq ($(HARDWARE_MOTHERBOARD),1149)
# ADIMLab Gantry v2
else ifeq ($(HARDWARE_MOTHERBOARD),1150)
# BIQU Tango V1
else ifeq ($(HARDWARE_MOTHERBOARD),1151)
else ifeq ($(HARDWARE_MOTHERBOARD),1150)
# MKS GEN L V2
else ifeq ($(HARDWARE_MOTHERBOARD),1152)
else ifeq ($(HARDWARE_MOTHERBOARD),1151)
# MKS GEN L V2.1
else ifeq ($(HARDWARE_MOTHERBOARD),1153)
else ifeq ($(HARDWARE_MOTHERBOARD),1152)
# Copymaster 3D
else ifeq ($(HARDWARE_MOTHERBOARD),1154)
else ifeq ($(HARDWARE_MOTHERBOARD),1153)
# Ortur 4
else ifeq ($(HARDWARE_MOTHERBOARD),1155)
else ifeq ($(HARDWARE_MOTHERBOARD),1154)
# Tenlog D3 Hero IDEX printer
else ifeq ($(HARDWARE_MOTHERBOARD),1155)
# Tenlog D3, D5, D6 IDEX Printer
else ifeq ($(HARDWARE_MOTHERBOARD),1156)
# Tenlog D3,5,6 Pro IDEX printers
else ifeq ($(HARDWARE_MOTHERBOARD),1157)
# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Fan, Bed)
else ifeq ($(HARDWARE_MOTHERBOARD),1158)
else ifeq ($(HARDWARE_MOTHERBOARD),1157)
# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Hotend2, Bed)
else ifeq ($(HARDWARE_MOTHERBOARD),1159)
else ifeq ($(HARDWARE_MOTHERBOARD),1158)
# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend, Fan0, Fan1, Bed)
else ifeq ($(HARDWARE_MOTHERBOARD),1160)
else ifeq ($(HARDWARE_MOTHERBOARD),1159)
# Longer LK1 PRO / Alfawise U20 Pro (PRO version)
else ifeq ($(HARDWARE_MOTHERBOARD),1161)
else ifeq ($(HARDWARE_MOTHERBOARD),1160)
# Longer LKx PRO / Alfawise Uxx Pro (PRO version)
else ifeq ($(HARDWARE_MOTHERBOARD),1162)
# Zonestar zrib V5.3 (Chinese RAMPS replica)
else ifeq ($(HARDWARE_MOTHERBOARD),1163)
else ifeq ($(HARDWARE_MOTHERBOARD),1161)
# Pxmalion Core I3
else ifeq ($(HARDWARE_MOTHERBOARD),1162)
# Panowin Cutlass (as found in the Panowin F1)
else ifeq ($(HARDWARE_MOTHERBOARD),1163)
# Kodama Bardo V1.x (as found in the Kodama Trinus)
else ifeq ($(HARDWARE_MOTHERBOARD),1164)
# XTLW MFF V1.0
else ifeq ($(HARDWARE_MOTHERBOARD),1165)
# XTLW MFF V2.0
else ifeq ($(HARDWARE_MOTHERBOARD),1166)
#
# RAMBo and derivatives
@@ -340,7 +356,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1203)
else ifeq ($(HARDWARE_MOTHERBOARD),1204)
# abee Scoovo X9H
else ifeq ($(HARDWARE_MOTHERBOARD),1205)
# Rambo ThinkerV2
# ThinkerV2
else ifeq ($(HARDWARE_MOTHERBOARD),1206)
#
@@ -383,30 +399,40 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1315)
else ifeq ($(HARDWARE_MOTHERBOARD),1316)
# Geeetech GT2560 Rev B for A10(M/T/D)
else ifeq ($(HARDWARE_MOTHERBOARD),1317)
# Geeetech GT2560 Rev B for A10(M/T/D)
else ifeq ($(HARDWARE_MOTHERBOARD),1318)
# Geeetech GT2560 Rev B for Mecreator2
else ifeq ($(HARDWARE_MOTHERBOARD),1318)
# Geeetech GT2560 Rev B for A20(M/T/D)
else ifeq ($(HARDWARE_MOTHERBOARD),1319)
# Geeetech GT2560 Rev B for A20(M/T/D)
# Geeetech GT2560 Rev B for A10(M/T/D)
else ifeq ($(HARDWARE_MOTHERBOARD),1320)
# Einstart retrofit
else ifeq ($(HARDWARE_MOTHERBOARD),1321)
# Wanhao 0ne+ i3 Mini
else ifeq ($(HARDWARE_MOTHERBOARD),1322)
# Leapfrog Xeed 2015
else ifeq ($(HARDWARE_MOTHERBOARD),1323)
# PICA Shield (original version)
else ifeq ($(HARDWARE_MOTHERBOARD),1324)
# PICA Shield (rev C or later)
else ifeq ($(HARDWARE_MOTHERBOARD),1325)
# Intamsys 4.0 (Funmat HT)
else ifeq ($(HARDWARE_MOTHERBOARD),1326)
# Malyan M180 Mainboard Version 2 (no display function, direct G-code only)
else ifeq ($(HARDWARE_MOTHERBOARD),1327)
# Geeetech GT2560 Rev B for A20(M/T/D)
else ifeq ($(HARDWARE_MOTHERBOARD),1321)
# Einstart retrofit
else ifeq ($(HARDWARE_MOTHERBOARD),1322)
# Wanhao 0ne+ i3 Mini
else ifeq ($(HARDWARE_MOTHERBOARD),1323)
# Overlord/Overlord Pro
else ifeq ($(HARDWARE_MOTHERBOARD),1324)
# ADIMLab Gantry v1
else ifeq ($(HARDWARE_MOTHERBOARD),1325)
# ADIMLab Gantry v2
else ifeq ($(HARDWARE_MOTHERBOARD),1326)
# Leapfrog Xeed 2015
else ifeq ($(HARDWARE_MOTHERBOARD),1327)
# PICA Shield (original version)
else ifeq ($(HARDWARE_MOTHERBOARD),1328)
# Mega controller & Protoneer CNC Shield V3.00
# PICA Shield (rev C or later)
else ifeq ($(HARDWARE_MOTHERBOARD),1329)
# Intamsys 4.0 (Funmat HT)
else ifeq ($(HARDWARE_MOTHERBOARD),1330)
# Malyan M180 Mainboard Version 2 (no display function, direct G-code only)
else ifeq ($(HARDWARE_MOTHERBOARD),1331)
# Mega controller & Protoneer CNC Shield V3.00
else ifeq ($(HARDWARE_MOTHERBOARD),1332)
# WEEDO 62A board (TINA2, Monoprice Cadet, etc.)
else ifeq ($(HARDWARE_MOTHERBOARD),1333)
# Geeetech GT2560 V4.1B for A10(M/T/D)
else ifeq ($(HARDWARE_MOTHERBOARD),1334)
#
# ATmega1281, ATmega2561
@@ -440,7 +466,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1502)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega644p
PROG_MCU ?= m644p
# Melzi V2.0
# Melzi V2
else ifeq ($(HARDWARE_MOTHERBOARD),1503)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
@@ -450,36 +476,41 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1504)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
PROG_MCU ?= m1284p
# Melzi Creality3D board (for CR-10 etc)
# Melzi Creality3D (for CR-10 etc)
else ifeq ($(HARDWARE_MOTHERBOARD),1505)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
PROG_MCU ?= m1284p
# Melzi Malyan M150 board
# Melzi Creality3D (for Ender-2)
else ifeq ($(HARDWARE_MOTHERBOARD),1506)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
PROG_MCU ?= m1284p
# Tronxy X5S
# Melzi Malyan M150
else ifeq ($(HARDWARE_MOTHERBOARD),1507)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
PROG_MCU ?= m1284p
# STB V1.1
# Tronxy X5S
else ifeq ($(HARDWARE_MOTHERBOARD),1508)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
PROG_MCU ?= m1284p
# Azteeg X1
# STB V1.1
else ifeq ($(HARDWARE_MOTHERBOARD),1509)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
PROG_MCU ?= m1284p
# Anet 1.0 (Melzi clone)
# Azteeg X1
else ifeq ($(HARDWARE_MOTHERBOARD),1510)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
PROG_MCU ?= m1284p
# Anet 1.0 (Melzi clone)
else ifeq ($(HARDWARE_MOTHERBOARD),1511)
HARDWARE_VARIANT ?= Sanguino
MCU ?= atmega1284p
PROG_MCU ?= m1284p
# ZoneStar ZMIB V2
else ifeq ($(HARDWARE_MOTHERBOARD),1511)
HARDWARE_VARIANT ?= Sanguino
@@ -995,7 +1026,7 @@ extcoff: $(TARGET).elf
$(NM) -n $< > $@
# Link: create ELF output file from library.
LDFLAGS+= -Wl,-V
$(BUILD_DIR)/$(TARGET).elf: $(OBJ) Configuration.h
$(Pecho) " CXX $@"
$P $(CXX) $(LD_PREFIX) $(ALL_CXXFLAGS) -o $@ -L. $(OBJ) $(LDFLAGS) $(LD_SUFFIX)
+10 -3
View File
@@ -41,7 +41,14 @@
* here we define this default string as the date where the latest release
* version was tagged.
*/
//#define STRING_DISTRIBUTION_DATE "2024-05-24"
//#define STRING_DISTRIBUTION_DATE "2025-03-18"
/**
* The protocol for communication to the host. Protocol indicates communication
* standards such as the use of ASCII, "echo:" and "error:" line prefixes, etc.
* (Other behaviors are given by the firmware version and capabilities report.)
*/
//#define PROTOCOL_VERSION "1.0"
/**
* Defines a generic printer name to be output to the LCD after booting Marlin.
@@ -68,8 +75,8 @@
//#define WEBSITE_URL "marlinfw.org"
/**
* Set the vendor info the serial USB interface, if changable
* Currently only supported by DUE platform
* Set the vendor info the serial USB interface, if changeable.
* Currently only supported by DUE platform.
*/
//#define USB_DEVICE_VENDOR_ID 0x0000
//#define USB_DEVICE_PRODUCT_ID 0x0000
+40 -43
View File
@@ -62,6 +62,11 @@ motherboard = BOARD_RAMPS_14_EFB
serial_port = 0
baudrate = 250000
string_config_h_author = "(default from config.ini)"
capabilities_report = on
extended_capabilities_report = on
use_watchdog = on
thermal_protection_hotends = on
thermal_protection_hysteresis = 4
@@ -77,9 +82,7 @@ temp_sensor_0 = 1
temp_hysteresis = 3
heater_0_mintemp = 5
heater_0_maxtemp = 275
preheat_1_temp_hotend = 180
bang_max = 255
pidtemp = on
pid_k1 = 0.95
pid_max = 255
@@ -89,6 +92,14 @@ default_kp = 22.20
default_ki = 1.08
default_kd = 114.00
temp_sensor_bed = 1
bed_mintemp = 5
bed_maxtemp = 150
thermal_protection_bed = on
thermal_protection_bed_hysteresis = 2
thermal_protection_bed_period = 20
x_driver_type = A4988
y_driver_type = A4988
z_driver_type = A4988
@@ -121,10 +132,10 @@ default_max_acceleration = { 3000, 3000, 100, 10000 }
homing_feedrate_mm_m = { (50*60), (50*60), (4*60) }
homing_bump_divisor = { 2, 2, 4 }
x_enable_on = 0
y_enable_on = 0
z_enable_on = 0
e_enable_on = 0
x_enable_on = LOW
y_enable_on = LOW
z_enable_on = LOW
e_enable_on = LOW
invert_x_dir = false
invert_y_dir = true
@@ -136,11 +147,6 @@ step_state_x = HIGH
step_state_y = HIGH
step_state_z = HIGH
disable_x = off
disable_y = off
disable_z = off
disable_e = off
proportional_font_ratio = 1.0
default_nominal_filament_dia = 1.75
@@ -153,18 +159,13 @@ default_retract_acceleration = 3000
default_minimumfeedrate = 0.0
default_mintravelfeedrate = 0.0
minimum_planner_speed = 0.05
min_steps_per_segment = 6
default_minsegmenttime = 20000
[config:basic]
bed_overshoot = 10
busy_while_heating = on
default_ejerk = 5.0
default_keepalive_interval = 2
default_leveling_fade_height = 0.0
disable_other_extruders = on
display_charset_hd44780 = JAPANESE
eeprom_boot_silent = on
eeprom_chitchat = on
endstoppullups = on
@@ -173,10 +174,8 @@ extrude_mintemp = 170
host_keepalive_feature = on
hotend_overshoot = 15
jd_handle_small_segments = on
lcd_info_screen_style = 0
lcd_language = en
max_bed_power = 255
mesh_inset = 0
min_software_endstops = on
max_software_endstops = on
min_software_endstop_x = on
@@ -185,50 +184,48 @@ min_software_endstop_z = on
max_software_endstop_x = on
max_software_endstop_y = on
max_software_endstop_z = on
preheat_1_fan_speed = 0
preheat_1_label = "PLA"
preheat_1_temp_hotend = 180
preheat_1_temp_bed = 70
preheat_1_fan_speed = 0
preheat_2_label = "ABS"
preheat_2_temp_hotend = 240
preheat_2_temp_bed = 110
preheat_2_fan_speed = 0
prevent_cold_extrusion = on
prevent_lengthy_extrude = on
printjob_timer_autostart = on
probing_margin = 10
show_bootscreen = on
soft_pwm_scale = 0
string_config_h_author = "(none, default config)"
temp_bed_hysteresis = 3
temp_bed_residency_time = 10
temp_bed_window = 1
temp_residency_time = 10
temp_window = 1
validate_homing_endstops = on
xy_probe_feedrate = (133*60)
z_clearance_between_probes = 5
z_clearance_deploy_probe = 10
z_clearance_multi_probe = 5
editable_steps_per_unit = on
[config:advanced]
arc_support = on
auto_report_temperatures = on
autotemp = on
autotemp_min = 210
autotemp_max = 250
autotemp_factor = 0.1f
autotemp_oldweight = 0.98
bed_check_interval = 5000
default_stepper_timeout_sec = 120
default_volumetric_extruder_limit = 0.00
disable_idle_x = on
disable_idle_y = on
disable_idle_z = on
disable_idle_e = on
e0_auto_fan_pin = -1
encoder_100x_steps_per_sec = 80
encoder_10x_steps_per_sec = 30
encoder_rate_multiplier = on
extended_capabilities_report = on
extruder_auto_fan_speed = 255
extruder_auto_fan_temperature = 50
fanmux0_pin = -1
fanmux1_pin = -1
fanmux2_pin = -1
faster_gcode_parser = on
debug_flags_gcode = on
homing_bump_mm = { 5, 5, 2 }
max_arc_segment_mm = 1.0
min_arc_segment_mm = 0.1
@@ -237,11 +234,11 @@ n_arc_correction = 25
serial_overrun_protection = on
slowdown = on
slowdown_divisor = 2
temp_sensor_bed = 0
thermal_protection_bed_hysteresis = 2
thermocouple_max_errors = 15
tx_buffer_size = 0
bed_check_interval = 5000
watch_bed_temp_increase = 2
watch_bed_temp_period = 60
watch_temp_increase = 2
watch_temp_period = 20
watch_temp_period = 40
+6 -6
View File
@@ -129,11 +129,11 @@ typedef Servo hal_servo_t;
#endif
#endif
#ifdef MMU2_SERIAL_PORT
#if !WITHIN(MMU2_SERIAL_PORT, 0, 3)
#error "MMU2_SERIAL_PORT must be from 0 to 3"
#ifdef MMU_SERIAL_PORT
#if !WITHIN(MMU_SERIAL_PORT, 0, 3)
#error "MMU_SERIAL_PORT must be from 0 to 3"
#endif
#define MMU2_SERIAL mmuSerial
#define MMU_SERIAL mmuSerial
#endif
#ifdef LCD_SERIAL_PORT
@@ -141,7 +141,7 @@ typedef Servo hal_servo_t;
#error "LCD_SERIAL_PORT must be from 0 to 3."
#endif
#define LCD_SERIAL lcdSerial
#if HAS_DGUS_LCD
#if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
#define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
#endif
#endif
@@ -159,7 +159,7 @@ typedef Servo hal_servo_t;
#define GET_PIN_MAP_INDEX(pin) pin
#define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
#define HAL_SENSITIVE_PINS 0, 1,
#define HAL_SENSITIVE_PINS 0, 1
#ifdef __AVR_AT90USB1286__
#define JTAG_DISABLE() do{ MCUCR = 0x80; MCUCR = 0x80; }while(0)
+8 -8
View File
@@ -601,20 +601,20 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
#endif // SERIAL_PORT_3
#ifdef MMU2_SERIAL_PORT
#ifdef MMU_SERIAL_PORT
ISR(SERIAL_REGNAME(USART, MMU2_SERIAL_PORT, _RX_vect)) {
MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::store_rxd_char();
ISR(SERIAL_REGNAME(USART, MMU_SERIAL_PORT, _RX_vect)) {
MarlinSerial<MMU2SerialCfg<MMU_SERIAL_PORT>>::store_rxd_char();
}
ISR(SERIAL_REGNAME(USART, MMU2_SERIAL_PORT, _UDRE_vect)) {
MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::_tx_udr_empty_irq();
ISR(SERIAL_REGNAME(USART, MMU_SERIAL_PORT, _UDRE_vect)) {
MarlinSerial<MMU2SerialCfg<MMU_SERIAL_PORT>>::_tx_udr_empty_irq();
}
template class MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> >;
template class MarlinSerial< MMU2SerialCfg<MMU_SERIAL_PORT> >;
MSerialMMU2 mmuSerial(MSerialMMU2::HasEmergencyParser);
#endif // MMU2_SERIAL_PORT
#endif // MMU_SERIAL_PORT
#ifdef LCD_SERIAL_PORT
@@ -629,7 +629,7 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
template class MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> >;
MSerialLCD lcdSerial(MSerialLCD::HasEmergencyParser);
#if HAS_DGUS_LCD
#if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
template<typename Cfg>
typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::get_tx_buffer_free() {
const ring_buffer_pos_t t = tx_buffer.tail, // next byte to send.
+3 -3
View File
@@ -205,7 +205,7 @@
static ring_buffer_pos_t available();
static void write(const uint8_t c);
static void flushTX();
#if HAS_DGUS_LCD
#if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
static ring_buffer_pos_t get_tx_buffer_free();
#endif
@@ -246,7 +246,7 @@
#endif // !USBCON
#ifdef MMU2_SERIAL_PORT
#ifdef MMU_SERIAL_PORT
template <uint8_t serial>
struct MMU2SerialCfg {
static constexpr int PORT = serial;
@@ -260,7 +260,7 @@
static constexpr bool RX_OVERRUNS = false;
};
typedef Serial1Class< MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> > > MSerialMMU2;
typedef Serial1Class< MarlinSerial< MMU2SerialCfg<MMU_SERIAL_PORT> > > MSerialMMU2;
extern MSerialMMU2 mmuSerial;
#endif
+8
View File
@@ -345,6 +345,14 @@ void setup_endstop_interrupts() {
pciSetup(Z_MIN_PROBE_PIN);
#endif
#endif
#if USE_CALIBRATION
#if (digitalPinToInterrupt(CALIBRATION_PIN) != NOT_AN_INTERRUPT)
_ATTACH(CALIBRATION_PIN);
#else
static_assert(digitalPinHasPCICR(CALIBRATION_PIN), "CALIBRATION_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(CALIBRATION_PIN);
#endif
#endif
// If we arrive here without raising an assertion, each pin has either an EXT-interrupt or a PCI.
}
+1 -1
View File
@@ -150,7 +150,7 @@ void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
else {
if (p == 32 || p == 128) continue; // Skip TIMER2 specific prescalers when not TIMER2
const uint16_t rft = (F_CPU) / (p * f_desired);
DEBUG_ECHOLNPGM("(Not Timer 2) F_CPU=" STRINGIFY(F_CPU), " prescaler=", p, " f_desired=", f_desired);
DEBUG_ECHOLNPGM("(Not Timer 2) F_CPU=", STRINGIFY(F_CPU), " prescaler=", p, " f_desired=", f_desired);
res_fast_temp = rft - 1;
res_pc_temp = rft / 2;
}
-3
View File
@@ -28,9 +28,6 @@
* Port : E0 E1 E4 E5 G5 E3 H3 H4 H5 H6 B4 B5 B6 B7 J1 J0 H1 H0 D3 D2 D1 D0 A0 A1 A2 A3 A4 A5 A6 A7 C7 C6 C5 C4 C3 C2 C1 C0 D7 G2 G1 G0 L7 L6 L5 L4 L3 L2 L1 L0 B3 B2 B1 B0 F0 F1 F2 F3 F4 F5 F6 F7 K0 K1 K2 K3 K4 K5 K6 K7 | E2 E6 E7 xx xx H2 H7 G3 G4 xx xx xx xx xx D4 D5 D6 xx xx J2 J3 J4 J5 J6 J7 xx xx xx xx xx
* Logical Pin : 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 78 79 80 xx xx 84 85 71 70 xx xx xx xx xx 81 82 83 xx xx 72 73 75 76 77 74 xx xx xx xx xx
* Analog Input : 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
*
* Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
* AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
*/
#include "../fastio.h"
-3
View File
@@ -26,9 +26,6 @@
*
* Logical Pin: 38 39 40 41 42 43 44 45 16 10 11 12 06 07 08 09 30 31 32 33 34 35 36 37 17 18 19 20 21 22 23 24 00 01 13 05 02 03 14 15 46 47 48 49 50 51 52 53 25 26 27 28 29 04
* Port: A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7 G0 G1 G2 G3 G4 G5
*
* Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
* AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
*/
#include "../fastio.h"
-3
View File
@@ -26,9 +26,6 @@
*
* Logical Pin: 08 09 10 11 12 13 14 15 16 17 18 19 20 21 00 01 02 03 04 05 06 07
* Port: B0 B1 B2 B3 B4 B5 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7
*
* Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
* AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
*/
#include "../fastio.h"
-3
View File
@@ -26,9 +26,6 @@
*
* Logical Pin: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
* Port: B0 B1 B2 B3 B4 B5 B6 B7 D0 D1 D2 D3 D4 D5 D6 D7 C0 C1 C2 C3 C4 C5 C6 C7 A7 A6 A5 A4 A3 A2 A1 A0
*
* Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
* AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
*/
/** ATMega644
+1 -4
View File
@@ -26,10 +26,7 @@
*
* Logical Pin: 28 29 30 31 32 33 34 35 20 21 22 23 24 25 26 27 10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07 08 09(46*47)36 37 18 19 38 39 40 41 42 43 44 45
* Port: A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7
* The logical pins 46 and 47 are not supported by Teensyduino, but are supported below as E2 and E3
*
* Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
* AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
* Logical pins 46-47 aren't supported by Teensyduino, but are supported below as E2 and E3
*/
#include "../fastio.h"
+45 -29
View File
@@ -22,7 +22,23 @@
#pragma once
/**
* PWM print routines for Atmel 8 bit AVR CPUs
* Pins Debugging for Atmel 8 bit AVR CPUs
*
* - NUMBER_PINS_TOTAL
* - MULTI_NAME_PAD
* - getPinByIndex(index)
* - printPinNameByIndex(index)
* - getPinIsDigitalByIndex(index)
* - digitalPinToAnalogIndex(pin)
* - getValidPinMode(pin)
* - isValidPin(pin)
* - isAnalogPin(pin)
* - digitalRead_mod(pin)
* - pwm_status(pin)
* - printPinPWM(pin)
* - printPinPort(pin)
* - printPinNumber(pin)
* - printPinAnalog(pin)
*/
#include "../../inc/MarlinConfig.h"
@@ -39,44 +55,44 @@
#include "pinsDebug_Teensyduino.h"
// Can't use the "digitalPinToPort" function from the Teensyduino type IDEs
// portModeRegister takes a different argument
#define digitalPinToTimer_DEBUG(p) digitalPinToTimer(p)
#define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
#define digitalPinToPort_DEBUG(p) digitalPinToPort(p)
#define GET_PINMODE(pin) (*portModeRegister(pin) & digitalPinToBitMask_DEBUG(pin))
#define digitalPinToTimer_DEBUG(P) digitalPinToTimer(P)
#define digitalPinToBitMask_DEBUG(P) digitalPinToBitMask(P)
#define digitalPinToPort_DEBUG(P) digitalPinToPort(P)
#define getValidPinMode(P) (*portModeRegister(P) & digitalPinToBitMask_DEBUG(P))
#elif AVR_ATmega2560_FAMILY_PLUS_70 // So we can access/display all the pins on boards using more than 70
#include "pinsDebug_plus_70.h"
#define digitalPinToTimer_DEBUG(p) digitalPinToTimer_plus_70(p)
#define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask_plus_70(p)
#define digitalPinToPort_DEBUG(p) digitalPinToPort_plus_70(p)
bool GET_PINMODE(int8_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
#define digitalPinToTimer_DEBUG(P) digitalPinToTimer_plus_70(P)
#define digitalPinToBitMask_DEBUG(P) digitalPinToBitMask_plus_70(P)
#define digitalPinToPort_DEBUG(P) digitalPinToPort_plus_70(P)
bool getValidPinMode(pin_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
#else
#define digitalPinToTimer_DEBUG(p) digitalPinToTimer(p)
#define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
#define digitalPinToPort_DEBUG(p) digitalPinToPort(p)
bool GET_PINMODE(int8_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
#define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].pin)
#define digitalPinToTimer_DEBUG(P) digitalPinToTimer(P)
#define digitalPinToBitMask_DEBUG(P) digitalPinToBitMask(P)
#define digitalPinToPort_DEBUG(P) digitalPinToPort(P)
bool getValidPinMode(pin_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
#define getPinByIndex(x) pgm_read_byte(&pin_array[x].pin)
#endif
#define VALID_PIN(pin) (pin >= 0 && pin < NUM_DIGITAL_PINS ? 1 : 0)
#define isValidPin(P) (P >= 0 && P < NUMBER_PINS_TOTAL)
#if AVR_ATmega1284_FAMILY
#define IS_ANALOG(P) WITHIN(P, analogInputToDigitalPin(7), analogInputToDigitalPin(0))
#define DIGITAL_PIN_TO_ANALOG_PIN(P) int(IS_ANALOG(P) ? (P) - analogInputToDigitalPin(7) : -1)
#define isAnalogPin(P) WITHIN(P, analogInputToDigitalPin(7), analogInputToDigitalPin(0))
#define digitalPinToAnalogIndex(P) int(isAnalogPin(P) ? (P) - analogInputToDigitalPin(7) : -1)
#else
#define _ANALOG1(P) WITHIN(P, analogInputToDigitalPin(0), analogInputToDigitalPin(7))
#define _ANALOG2(P) WITHIN(P, analogInputToDigitalPin(8), analogInputToDigitalPin(15))
#define IS_ANALOG(P) (_ANALOG1(P) || _ANALOG2(P))
#define DIGITAL_PIN_TO_ANALOG_PIN(P) int(_ANALOG1(P) ? (P) - analogInputToDigitalPin(0) : _ANALOG2(P) ? (P) - analogInputToDigitalPin(8) + 8 : -1)
#define isAnalogPin(P) (_ANALOG1(P) || _ANALOG2(P))
#define digitalPinToAnalogIndex(P) int(_ANALOG1(P) ? (P) - analogInputToDigitalPin(0) : _ANALOG2(P) ? (P) - analogInputToDigitalPin(8) + 8 : -1)
#endif
#define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].pin)
#define getPinByIndex(x) pgm_read_byte(&pin_array[x].pin)
#define MULTI_NAME_PAD 26 // space needed to be pretty if not first name assigned to a pin
void PRINT_ARRAY_NAME(uint8_t x) {
PGM_P const name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[x].name);
void printPinNameByIndex(const uint8_t index) {
PGM_P const name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[index].name);
for (uint8_t y = 0; y < MAX_NAME_LENGTH; ++y) {
char temp_char = pgm_read_byte(name_mem_pointer + y);
if (temp_char != 0)
@@ -88,7 +104,7 @@ void PRINT_ARRAY_NAME(uint8_t x) {
}
}
#define GET_ARRAY_IS_DIGITAL(x) pgm_read_byte(&pin_array[x].is_digital)
#define getPinIsDigitalByIndex(x) pgm_read_byte(&pin_array[x].is_digital)
#if defined(__AVR_ATmega1284P__) // 1284 IDE extensions set this to the number of
#undef NUM_DIGITAL_PINS // digital only pins while all other CPUs have it
@@ -109,7 +125,7 @@ void PRINT_ARRAY_NAME(uint8_t x) {
* Print a pin's PWM status.
* Return true if it's currently a PWM pin.
*/
bool pwm_status(uint8_t pin) {
bool pwm_status(const uint8_t pin) {
char buffer[20]; // for the sprintf statements
switch (digitalPinToTimer_DEBUG(pin)) {
@@ -276,7 +292,7 @@ void timer_prefix(uint8_t T, char L, uint8_t N) { // T - timer L - pwm N -
if (TEST(*TMSK, TOIE)) err_prob_interrupt();
}
void pwm_details(uint8_t pin) {
void printPinPWM(const uint8_t pin) {
switch (digitalPinToTimer_DEBUG(pin)) {
#if ABTEST(0)
@@ -347,7 +363,7 @@ void pwm_details(uint8_t pin) {
#else
UNUSED(print_is_also_tied);
#endif
} // pwm_details
} // printPinPWM
#ifndef digitalRead_mod // Use Teensyduino's version of digitalRead - it doesn't disable the PWMs
int digitalRead_mod(const pin_t pin) { // same as digitalRead except the PWM stop section has been removed
@@ -356,7 +372,7 @@ void pwm_details(uint8_t pin) {
}
#endif
void print_port(const pin_t pin) { // print port number
void printPinPort(const pin_t pin) { // print port number
#ifdef digitalPinToPort_DEBUG
uint8_t x;
SERIAL_ECHOPGM(" Port: ");
@@ -386,7 +402,7 @@ void print_port(const pin_t pin) { // print port number
#endif
}
#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d) "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%3d "), P); SERIAL_ECHO(buffer); }while(0)
#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d) "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
#undef ABTEST
+1 -1
View File
@@ -102,7 +102,7 @@ const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
// digitalPinToBitMask(pin) is OK
#define digitalRead_mod(p) extDigitalRead(p) // Teensyduino's version of digitalRead doesn't
#define digitalRead_mod(P) extDigitalRead(P) // Teensyduino's version of digitalRead doesn't
// disable the PWMs so we can use it as is
// portModeRegister(pin) is OK
+24 -26
View File
@@ -23,43 +23,41 @@
/**
* Define SPI Pins: SCK, MISO, MOSI, SS
* Platform pins have parentheses, e.g., "(53)", so we cannot use them.
*/
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__)
#define AVR_SCK_PIN 13
#define AVR_MISO_PIN 12
#define AVR_MOSI_PIN 11
#define AVR_SS_PIN 10
#define _PIN_SPI_SCK 13
#define _PIN_SPI_MISO 12
#define _PIN_SPI_MOSI 11
#define _PIN_SPI_SS 10
#elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__)
#define AVR_SCK_PIN 7
#define AVR_MISO_PIN 6
#define AVR_MOSI_PIN 5
#define AVR_SS_PIN 4
#define _PIN_SPI_SCK 7
#define _PIN_SPI_MISO 6
#define _PIN_SPI_MOSI 5
#define _PIN_SPI_SS 4
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define AVR_SCK_PIN 52
#define AVR_MISO_PIN 50
#define AVR_MOSI_PIN 51
#define AVR_SS_PIN 53
#define _PIN_SPI_SCK 52
#define _PIN_SPI_MISO 50
#define _PIN_SPI_MOSI 51
#define _PIN_SPI_SS 53
#elif defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__)
#define AVR_SCK_PIN 21
#define AVR_MISO_PIN 23
#define AVR_MOSI_PIN 22
#define AVR_SS_PIN 20
#define _PIN_SPI_SCK 21
#define _PIN_SPI_MISO 23
#define _PIN_SPI_MOSI 22
#define _PIN_SPI_SS 20
#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
#define AVR_SCK_PIN 10
#define AVR_MISO_PIN 12
#define AVR_MOSI_PIN 11
#define AVR_SS_PIN 16
#define _PIN_SPI_SCK 10
#define _PIN_SPI_MISO 12
#define _PIN_SPI_MOSI 11
#define _PIN_SPI_SS 16
#endif
#ifndef SD_SCK_PIN
#define SD_SCK_PIN AVR_SCK_PIN
#define SD_SCK_PIN _PIN_SPI_SCK
#endif
#ifndef SD_MISO_PIN
#define SD_MISO_PIN AVR_MISO_PIN
#define SD_MISO_PIN _PIN_SPI_MISO
#endif
#ifndef SD_MOSI_PIN
#define SD_MOSI_PIN AVR_MOSI_PIN
#endif
#ifndef SD_SS_PIN
#define SD_SS_PIN AVR_SS_PIN
#define SD_MOSI_PIN _PIN_SPI_MOSI
#endif
@@ -120,7 +120,7 @@ void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
U8G_ATOMIC_END();
}
#if ENABLED(FYSETC_MINI_12864)
#if U8G_SPI_USE_MODE_3
#define SPISEND_SW_AVR u8g_spiSend_sw_AVR_mode_3
#else
#define SPISEND_SW_AVR u8g_spiSend_sw_AVR_mode_0
@@ -143,9 +143,9 @@ uint8_t u8g_com_HAL_AVR_sw_sp_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
break;
case U8G_COM_MSG_CHIP_SELECT:
#if ENABLED(FYSETC_MINI_12864) // LCD SPI is running mode 3 while SD card is running mode 0
if (arg_val) { // SCK idle state needs to be set to the proper idle state before
// the next chip select goes active
#if U8G_SPI_USE_MODE_3 // LCD SPI is running mode 3 while SD card is running mode 0
if (arg_val) { // SCK idle state needs to be set to the proper idle state before
// the next chip select goes active
u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, 1); // Set SCK to mode 3 idle state before CS goes active
u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
}
+1 -1
View File
@@ -48,7 +48,7 @@ uint16_t MarlinHAL::adc_result;
void MarlinHAL::init() {
#if HAS_MEDIA
OUT_WRITE(SDSS, HIGH); // Try to set SDSS inactive before any other SPI users start up
OUT_WRITE(SD_SS_PIN, HIGH); // Try to set SDSS inactive before any other SPI users start up
#endif
usb_task_init(); // Initialize the USB stack
TERN_(POSTMORTEM_DEBUGGING, install_min_serial()); // Install the min serial handler
+4 -62
View File
@@ -35,67 +35,9 @@
#include <stdint.h>
#include "../../core/serial_hook.h"
// ------------------------
// Serial ports
// ------------------------
typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
typedef ForwardSerial1Class< decltype(Serial1) > DefaultSerial2;
typedef ForwardSerial1Class< decltype(Serial2) > DefaultSerial3;
typedef ForwardSerial1Class< decltype(Serial3) > DefaultSerial4;
extern DefaultSerial1 MSerial0;
extern DefaultSerial2 MSerial1;
extern DefaultSerial3 MSerial2;
extern DefaultSerial4 MSerial3;
#define _MSERIAL(X) MSerial##X
#define MSERIAL(X) _MSERIAL(X)
#if SERIAL_PORT == -1 || ENABLED(EMERGENCY_PARSER)
#define MYSERIAL1 customizedSerial1
#elif WITHIN(SERIAL_PORT, 0, 3)
#define MYSERIAL1 MSERIAL(SERIAL_PORT)
#else
#error "The required SERIAL_PORT must be from 0 to 3, or -1 for USB Serial."
#endif
#ifdef SERIAL_PORT_2
#if SERIAL_PORT_2 == -1 || ENABLED(EMERGENCY_PARSER)
#define MYSERIAL2 customizedSerial2
#elif WITHIN(SERIAL_PORT_2, 0, 3)
#define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
#else
#error "SERIAL_PORT_2 must be from 0 to 3, or -1 for USB Serial."
#endif
#endif
#ifdef SERIAL_PORT_3
#if SERIAL_PORT_3 == -1 || ENABLED(EMERGENCY_PARSER)
#define MYSERIAL3 customizedSerial3
#elif WITHIN(SERIAL_PORT_3, 0, 3)
#define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
#else
#error "SERIAL_PORT_3 must be from 0 to 3, or -1 for USB Serial."
#endif
#endif
#ifdef MMU2_SERIAL_PORT
#if WITHIN(MMU2_SERIAL_PORT, 0, 3)
#define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
#else
#error "MMU2_SERIAL_PORT must be from 0 to 3."
#endif
#endif
#ifdef LCD_SERIAL_PORT
#if WITHIN(LCD_SERIAL_PORT, 0, 3)
#define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
#else
#error "LCD_SERIAL_PORT must be from 0 to 3."
#endif
#endif
//
// Serial Ports
//
#include "MarlinSerial.h"
#include "MarlinSerialUSB.h"
@@ -127,7 +69,7 @@ typedef Servo hal_servo_t;
#define HAL_ADC_RESOLUTION 10
#ifndef analogInputToDigitalPin
#define analogInputToDigitalPin(p) ((p < 12U) ? (p) + 54U : -1)
#define analogInputToDigitalPin(p) pin_t((p < 12U) ? (p) + 54U : -1)
#endif
//
+3 -4
View File
@@ -600,9 +600,8 @@
OUT_WRITE(SPI_EEPROM1_CS_PIN, HIGH);
OUT_WRITE(SPI_EEPROM2_CS_PIN, HIGH);
OUT_WRITE(SPI_FLASH_CS_PIN, HIGH);
WRITE(SD_SS_PIN, HIGH);
OUT_WRITE(SDSS, LOW);
OUT_WRITE(SD_SS_PIN, HIGH);
WRITE(SD_SS_PIN, LOW);
PIO_Configure(
g_APinDescription[SPI_PIN].pPort,
@@ -767,7 +766,7 @@
// Disable PIO on A26 and A27
REG_PIOA_PDR = 0x0C000000;
OUT_WRITE(SDSS, HIGH);
OUT_WRITE(SD_SS_PIN, HIGH);
// Reset SPI0 (from sam lib)
SPI0->SPI_CR = SPI_CR_SPIDIS;
+15
View File
@@ -33,6 +33,21 @@
#include "../../core/types.h"
#include "../../core/serial_hook.h"
typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
typedef ForwardSerial1Class< decltype(Serial1) > DefaultSerial2;
typedef ForwardSerial1Class< decltype(Serial2) > DefaultSerial3;
typedef ForwardSerial1Class< decltype(Serial3) > DefaultSerial4;
extern DefaultSerial1 MSerial0;
extern DefaultSerial2 MSerial1;
extern DefaultSerial3 MSerial2;
extern DefaultSerial4 MSerial3;
#define SERIAL_INDEX_MIN 0
#define SERIAL_INDEX_MAX 3
#define EP_SERIAL_PORT(N) customizedSerial##N
#define USB_SERIAL_PORT(N) customizedSerial##N
#include "../shared/serial_ports.h"
// Define constants and variables for buffering incoming serial data. We're
// using a ring buffer (I think), in which rx_buffer_head is the index of the
// location to which to write the next incoming character and rx_buffer_tail
+1 -1
View File
@@ -50,7 +50,7 @@
static Flags<_Nbr_16timers> DisablePending; // ISR should disable the timer at the next timer reset
// ------------------------
/// Interrupt handler for the TC0 channel 1.
// Interrupt handler for the TC0 channel 1.
// ------------------------
void Servo_Handler(const timer16_Sequence_t, Tc*, const uint8_t);
+1 -1
View File
@@ -291,7 +291,7 @@ static bool ee_PageWrite(uint16_t page, const void *data) {
uint32_t *p1 = (uint32_t*)addrflash;
uint32_t *p2 = (uint32_t*)data;
int count = 0;
for (i =0; i<PageSize >> 2; i++) {
for (i = 0; i < PageSize >> 2; i++) {
if (p1[i] != p2[i]) {
uint32_t delta = p1[i] ^ p2[i];
while (delta) {
+1
View File
@@ -64,6 +64,7 @@ void setup_endstop_interrupts() {
TERN_(USE_Z4_MAX, _ATTACH(Z4_MAX_PIN));
TERN_(USE_Z4_MIN, _ATTACH(Z4_MIN_PIN));
TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
TERN_(USE_I_MAX, _ATTACH(I_MAX_PIN));
TERN_(USE_I_MIN, _ATTACH(I_MIN_PIN));
TERN_(USE_J_MAX, _ATTACH(J_MAX_PIN));
+6 -7
View File
@@ -68,16 +68,15 @@
* Usually the hardware SPI pins are only available to the LCD. This makes the DUE hard SPI used at the same time
* as the TMC2130 soft SPI the most common setup.
*/
#define _IS_HW_SPI(P) (defined(TMC_SPI_##P) && (TMC_SPI_##P == SD_MOSI_PIN || TMC_SPI_##P == SD_MISO_PIN || TMC_SPI_##P == SD_SCK_PIN))
#if HAS_MEDIA && HAS_DRIVER(TMC2130)
#if ENABLED(TMC_USE_SW_SPI)
#if DISABLED(SOFTWARE_SPI) && (_IS_HW_SPI(MOSI) || _IS_HW_SPI(MISO) || _IS_HW_SPI(SCK))
#error "DUE hardware SPI is required but is incompatible with TMC2130 software SPI. Either disable TMC_USE_SW_SPI or use separate pins for the two SPIs."
#endif
#elif ENABLED(SOFTWARE_SPI)
#define _IS_HW_SPI(P) (defined(TMC_SPI_##P) && (TMC_SPI_##P == SD_MOSI_PIN || TMC_SPI_##P == SD_MISO_PIN || TMC_SPI_##P == SD_SCK_PIN))
#if DISABLED(SOFTWARE_SPI) && ENABLED(TMC_USE_SW_SPI) && (_IS_HW_SPI(MOSI) || _IS_HW_SPI(MISO) || _IS_HW_SPI(SCK))
#error "DUE hardware SPI is required but is incompatible with TMC2130 software SPI. Either disable TMC_USE_SW_SPI or use separate pins for the two SPIs."
#endif
#if ENABLED(SOFTWARE_SPI) && DISABLED(TMC_USE_SW_SPI)
#error "DUE software SPI is required but is incompatible with TMC2130 hardware SPI. Enable TMC_USE_SW_SPI to fix."
#endif
#undef _IS_HW_SPI
#endif
#if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_FREQUENCY
+32 -19
View File
@@ -19,13 +19,26 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* Support routines for Due
*/
/**
* Translation of routines & variables used by pinsDebug.h
* Pins Debugging for DUE
*
* - NUMBER_PINS_TOTAL
* - MULTI_NAME_PAD
* - getPinByIndex(index)
* - printPinNameByIndex(index)
* - getPinIsDigitalByIndex(index)
* - digitalPinToAnalogIndex(pin)
* - getValidPinMode(pin)
* - isValidPin(pin)
* - isAnalogPin(pin)
* - digitalRead_mod(pin)
* - pwm_status(pin)
* - printPinPWM(pin)
* - printPinPort(pin)
* - printPinNumber(pin)
* - printPinAnalog(pin)
*/
#include "../shared/Marduino.h"
@@ -63,20 +76,20 @@
#define NUMBER_PINS_TOTAL PINS_COUNT
#define digitalRead_mod(p) extDigitalRead(p) // AVR digitalRead disabled PWM before it read the pin
#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%02d"), p); SERIAL_ECHO(buffer); }while(0)
#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d) "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
#define GET_ARRAY_PIN(p) pin_array[p].pin
#define GET_ARRAY_IS_DIGITAL(p) pin_array[p].is_digital
#define VALID_PIN(pin) (pin >= 0 && pin < int8_t(NUMBER_PINS_TOTAL))
#define DIGITAL_PIN_TO_ANALOG_PIN(p) int(p - analogInputToDigitalPin(0))
#define IS_ANALOG(P) WITHIN(P, char(analogInputToDigitalPin(0)), char(analogInputToDigitalPin(NUM_ANALOG_INPUTS - 1)))
#define pwm_status(pin) (((g_pinStatus[pin] & 0xF) == PIN_STATUS_PWM) && \
((g_APinDescription[pin].ulPinAttribute & PIN_ATTR_PWM) == PIN_ATTR_PWM))
#define digitalRead_mod(P) extDigitalRead(P) // AVR digitalRead disabled PWM before it read the pin
#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%02d"), P); SERIAL_ECHO(buffer); }while(0)
#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d) "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
#define getPinByIndex(x) pin_array[x].pin
#define getPinIsDigitalByIndex(x) pin_array[x].is_digital
#define isValidPin(P) (P >= 0 && P < pin_t(NUMBER_PINS_TOTAL))
#define digitalPinToAnalogIndex(P) int(P - analogInputToDigitalPin(0))
#define isAnalogPin(P) WITHIN(P, pin_t(analogInputToDigitalPin(0)), pin_t(analogInputToDigitalPin(NUM_ANALOG_INPUTS - 1)))
#define pwm_status(P) (((g_pinStatus[P] & 0xF) == PIN_STATUS_PWM) && \
((g_APinDescription[P].ulPinAttribute & PIN_ATTR_PWM) == PIN_ATTR_PWM))
#define MULTI_NAME_PAD 14 // space needed to be pretty if not first name assigned to a pin
bool GET_PINMODE(int8_t pin) { // 1: output, 0: input
bool getValidPinMode(const pin_t pin) { // 1: output, 0: input
volatile Pio* port = g_APinDescription[pin].pPort;
uint32_t mask = g_APinDescription[pin].ulPin;
uint8_t pin_status = g_pinStatus[pin] & 0xF;
@@ -85,14 +98,14 @@ bool GET_PINMODE(int8_t pin) { // 1: output, 0: input
|| pwm_status(pin));
}
void pwm_details(int32_t pin) {
void printPinPWM(const int32_t pin) {
if (pwm_status(pin)) {
uint32_t chan = g_APinDescription[pin].ulPWMChannel;
SERIAL_ECHOPGM("PWM = ", PWM_INTERFACE->PWM_CH_NUM[chan].PWM_CDTY);
}
}
void print_port(const pin_t) {}
void printPinPort(const pin_t) {}
/**
* DUE Board pin | PORT | Label
+32 -35
View File
@@ -24,41 +24,38 @@
/**
* Define SPI Pins: SCK, MISO, MOSI, SS
*
* Available chip select pins for HW SPI are 4 10 52 77
* Available chip select pins for HW SPI are 4 10 52 77 87
*/
#if SDSS == 4 || SDSS == 10 || SDSS == 52 || SDSS == 77 || SDSS == 87
#if SDSS == 4
#define SPI_PIN 87
#define SPI_CHAN 1
#elif SDSS == 10
#define SPI_PIN 77
#define SPI_CHAN 0
#elif SDSS == 52
#define SPI_PIN 86
#define SPI_CHAN 2
#elif SDSS == 77
#define SPI_PIN 77
#define SPI_CHAN 0
#else
#define SPI_PIN 87
#define SPI_CHAN 1
#endif
#define SD_SCK_PIN 76
#define SD_MISO_PIN 74
#define SD_MOSI_PIN 75
#else
// defaults
#define SOFTWARE_SPI
#ifndef SD_SCK_PIN
#define SD_SCK_PIN 52
#endif
#ifndef SD_MISO_PIN
#define SD_MISO_PIN 50
#endif
#ifndef SD_MOSI_PIN
#define SD_MOSI_PIN 51
#endif
#if SD_SS_PIN == 4 || SD_SS_PIN == 10 || SD_SS_PIN == 52 || SD_SS_PIN == 77 || SD_SS_PIN == 87
#define SD_SCK_PIN 76
#define SD_MISO_PIN 74
#define SD_MOSI_PIN 75
#endif
/* A.28, A.29, B.21, C.26, C.29 */
#define SD_SS_PIN SDSS
#if SD_SS_PIN == 4
#define SPI_PIN 87
#define SPI_CHAN 1
#elif SD_SS_PIN == 10
#define SPI_PIN 77
#define SPI_CHAN 0
#elif SD_SS_PIN == 52
#define SPI_PIN 86
#define SPI_CHAN 2
#elif SD_SS_PIN == 77
#define SPI_PIN 77
#define SPI_CHAN 0
#elif SD_SS_PIN == 87
#define SPI_PIN 87
#define SPI_CHAN 1
#else
#define SOFTWARE_SPI
#ifndef SD_SCK_PIN
#define SD_SCK_PIN 52
#endif
#ifndef SD_MISO_PIN
#define SD_MISO_PIN 50
#endif
#ifndef SD_MOSI_PIN
#define SD_MOSI_PIN 51
#endif
#endif
@@ -66,7 +66,7 @@
#include <U8glib-HAL.h>
#if ENABLED(FYSETC_MINI_12864)
#if U8G_SPI_USE_MODE_3
#define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_3
#else
#define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_0
@@ -96,15 +96,15 @@ uint8_t u8g_com_HAL_DUE_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
break;
case U8G_COM_MSG_CHIP_SELECT:
#if ENABLED(FYSETC_MINI_12864) // LCD SPI is running mode 3 while SD card is running mode 0
if (arg_val) { // SCK idle state needs to be set to the proper idle state before
// the next chip select goes active
u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 1); //set SCK to mode 3 idle state before CS goes active
#if U8G_SPI_USE_MODE_3 // LCD SPI is running mode 3 while SD card is running mode 0
if (arg_val) { // SCK idle state needs to be set to the proper idle state before
// the next chip select goes active
u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 1); // Set SCK to mode 3 idle state before CS goes active
u8g_SetPILevel_DUE(u8g, U8G_PI_CS, LOW);
}
else {
u8g_SetPILevel_DUE(u8g, U8G_PI_CS, HIGH);
u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0); //set SCK to mode 0 idle state after CS goes inactive
u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0); // Set SCK to mode 0 idle state after CS goes inactive
}
#else
u8g_SetPILevel_DUE(u8g, U8G_PI_CS, !arg_val);
+1 -1
View File
@@ -11,7 +11,7 @@ if pioutil.is_pio_build():
if current_OS == 'Windows':
Import("env")
env = pioutil.env
# Use bossac.exe on Windows
env.Replace(
+5 -5
View File
@@ -19,7 +19,7 @@ void sd_mmc_spi_mem_init() {
}
inline bool media_ready() {
return IS_SD_INSERTED() && !IS_SD_PRINTING() && !IS_SD_FILE_OPEN() && card.isMounted();
return IS_SD_MOUNTED() && IS_SD_INSERTED() && !IS_SD_FILE_OPEN() && !IS_SD_PRINTING();
}
bool sd_mmc_spi_unload(bool) { return true; }
@@ -32,14 +32,14 @@ Ctrl_status sd_mmc_spi_test_unit_ready() {
#ifdef DISABLE_DUE_SD_MMC
return CTRL_NO_PRESENT;
#endif
if (!media_ready()) return CTRL_NO_PRESENT;
if (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
return CTRL_GOOD;
}
// NOTE: This function is defined as returning the address of the last block
// in the card, which is cardSize() - 1
Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
if (!media_ready()) return CTRL_NO_PRESENT;
if (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
*nb_sector = card.diskIODriver()->cardSize() - 1;
return CTRL_GOOD;
}
@@ -61,7 +61,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
#ifdef DISABLE_DUE_SD_MMC
return CTRL_NO_PRESENT;
#endif
if (!media_ready()) return CTRL_NO_PRESENT;
if (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
#ifdef DEBUG_MMC
{
@@ -100,7 +100,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
#ifdef DISABLE_DUE_SD_MMC
return CTRL_NO_PRESENT;
#endif
if (!media_ready()) return CTRL_NO_PRESENT;
if (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
#ifdef DEBUG_MMC
{
+9 -8
View File
@@ -209,16 +209,17 @@ int MarlinHAL::freeMemory() { return ESP.getFreeHeap(); }
// ADC
// ------------------------
#define ADC1_CHANNEL(pin) ADC1_GPIO ## pin ## _CHANNEL
// https://docs.espressif.com/projects/esp-idf/en/release-v4.4/esp32/api-reference/peripherals/adc.html
adc1_channel_t get_channel(int pin) {
switch (pin) {
case 39: return ADC1_CHANNEL(39);
case 36: return ADC1_CHANNEL(36);
case 35: return ADC1_CHANNEL(35);
case 34: return ADC1_CHANNEL(34);
case 33: return ADC1_CHANNEL(33);
case 32: return ADC1_CHANNEL(32);
case 39: return ADC1_CHANNEL_3;
case 36: return ADC1_CHANNEL_0;
case 35: return ADC1_CHANNEL_7;
case 34: return ADC1_CHANNEL_6;
case 33: return ADC1_CHANNEL_5;
case 32: return ADC1_CHANNEL_4;
case 37: return ADC1_CHANNEL_1;
case 38: return ADC1_CHANNEL_2;
}
return ADC1_CHANNEL_MAX;
}
@@ -59,6 +59,7 @@ void setup_endstop_interrupts() {
TERN_(USE_Z4_MAX, _ATTACH(Z4_MAX_PIN));
TERN_(USE_Z4_MIN, _ATTACH(Z4_MIN_PIN));
TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
TERN_(USE_I_MAX, _ATTACH(I_MAX_PIN));
TERN_(USE_I_MIN, _ATTACH(I_MIN_PIN));
TERN_(USE_J_MAX, _ATTACH(J_MAX_PIN));
+7
View File
@@ -37,6 +37,10 @@
// Set pin as output
#define _SET_OUTPUT(IO) pinMode(IO, OUTPUT)
// TODO: Store set modes in an array and use those to get the mode
#define _IS_OUTPUT(IO) true
#define _IS_INPUT(IO) true
// Set pin as input with pullup mode
#define _PULLUP(IO, v) pinMode(IO, v ? INPUT_PULLUP : INPUT)
@@ -70,6 +74,9 @@
// Set pin as output and init
#define OUT_WRITE(IO,V) do{ _SET_OUTPUT(IO); WRITE(IO,V); }while(0)
#define IS_OUTPUT(IO) _IS_OUTPUT(IO)
#define IS_INPUT(IO) _IS_INPUT(IO)
// digitalRead/Write wrappers
#define extDigitalRead(IO) digitalRead(IO)
#define extDigitalWrite(IO,V) digitalWrite(IO,V)
+1 -1
View File
@@ -152,7 +152,7 @@ void stepperTask(void *parameter) {
xQueueReceive(dma.queue, &dma.current, portMAX_DELAY);
dma.rw_pos = 0;
const bool using_ftMotion = TERN0(FT_MOTION, ftMotion.cfg.mode);
const bool using_ftMotion = TERN0(FT_MOTION, ftMotion.cfg.active);
while (dma.rw_pos < DMA_SAMPLE_COUNT) {
+5 -1
View File
@@ -22,11 +22,15 @@
#ifdef ARDUINO_ARCH_ESP32
#include <WiFi.h>
#undef ENABLED
#undef DISABLED
#include "../../inc/MarlinConfigPre.h"
#if ALL(WIFISUPPORT, OTASUPPORT)
#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
+71
View File
@@ -0,0 +1,71 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2024 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#error "PINS_DEBUGGING is not yet supported for ESP32!"
/**
* Pins Debugging for ESP32
*
* - NUMBER_PINS_TOTAL
* - MULTI_NAME_PAD
* - getPinByIndex(index)
* - printPinNameByIndex(index)
* - getPinIsDigitalByIndex(index)
* - digitalPinToAnalogIndex(pin)
* - getValidPinMode(pin)
* - isValidPin(pin)
* - isAnalogPin(pin)
* - digitalRead_mod(pin)
* - pwm_status(pin)
* - printPinPWM(pin)
* - printPinPort(pin)
* - printPinNumber(pin)
* - printPinAnalog(pin)
*/
#define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
#define MULTI_NAME_PAD 16 // space needed to be pretty if not first name assigned to a pin
#define digitalRead_mod(P) extDigitalRead(P)
#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%02d"), P); SERIAL_ECHO(buffer); }while(0)
#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d) "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
#define getPinByIndex(x) pin_array[x].pin
#define getPinIsDigitalByIndex(x) pin_array[x].is_digital
#define isValidPin(P) (P >= 0 && P < pin_t(NUMBER_PINS_TOTAL))
#define digitalPinToAnalogIndex(P) int(P - analogInputToDigitalPin(0))
#define isAnalogPin(P) WITHIN(P, pin_t(analogInputToDigitalPin(0)), pin_t(analogInputToDigitalPin(NUM_ANALOG_INPUTS - 1)))
bool pwm_status(const pin_t) { return false; }
void printPinPort(const pin_t) {}
static bool getValidPinMode(const pin_t pin) {
return isValidPin(pin) && !IS_INPUT(pin);
}
void printPinPWM(const int32_t pin) {
if (pwm_status(pin)) {
//uint32_t chan = g_APinDescription[pin].ulPWMChannel TODO when fast pwm is operative;
//SERIAL_ECHOPGM("PWM = ", duty);
}
}
+13 -4
View File
@@ -21,7 +21,16 @@
*/
#pragma once
#define SD_SS_PIN SDSS
#define SD_SCK_PIN 18
#define SD_MISO_PIN 19
#define SD_MOSI_PIN 23
#define PIN_SPI_SCK 18
#define PIN_SPI_MISO 19
#define PIN_SPI_MOSI 23
#ifndef SD_SCK_PIN
#define SD_SCK_PIN PIN_SPI_SCK
#endif
#ifndef SD_MISO_PIN
#define SD_MISO_PIN PIN_SPI_MISO
#endif
#ifndef SD_MOSI_PIN
#define SD_MOSI_PIN PIN_SPI_MOSI
#endif
+1 -1
View File
@@ -90,7 +90,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
config.counter_en = TIMER_PAUSE;
config.alarm_en = TIMER_ALARM_EN;
config.intr_type = TIMER_INTR_LEVEL;
config.auto_reload = true;
config.auto_reload = TIMER_AUTORELOAD_EN;
// Select and initialize the timer
timer_init(timer.group, timer.idx, &config);
+1 -2
View File
@@ -53,12 +53,11 @@ typedef uint64_t hal_timer_t;
#if ENABLED(I2S_STEPPER_STREAM)
#define STEPPER_TIMER_PRESCALE 1
#define STEPPER_TIMER_RATE 250000 // 250khz, 4µs pulses of i2s word clock
#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs // wrong would be 0.25
#else
#define STEPPER_TIMER_PRESCALE 40
#define STEPPER_TIMER_RATE ((HAL_TIMER_RATE) / (STEPPER_TIMER_PRESCALE)) // frequency of stepper timer, 2MHz
#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
#endif
#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
#define STEP_TIMER_MIN_INTERVAL 8 // minimum time in µs between stepper interrupts
+2 -1
View File
@@ -21,11 +21,12 @@
*/
#ifdef ARDUINO_ARCH_ESP32
#include "../../core/serial.h"
#include "../../inc/MarlinConfigPre.h"
#if ENABLED(WIFISUPPORT)
#include "../../core/serial.h"
#include <WiFi.h>
#include <ESPmDNS.h>
#include <ESPAsyncWebServer.h>
+11 -65
View File
@@ -30,69 +30,18 @@
#include "../../inc/MarlinConfig.h"
#include "../../core/macros.h"
#include "../shared/Marduino.h"
#include "../shared/math_32bit.h"
#include "../shared/HAL_SPI.h"
#include "fastio.h"
#include "timers.h"
#include "MarlinSerial.h"
#include <stdint.h>
//
// Serial Ports
//
#define _MSERIAL(X) MSerial##X
#define MSERIAL(X) _MSERIAL(X)
#define NUM_UARTS 4
#if SERIAL_PORT == -1
#error "USB Serial is not supported on HC32F460"
#elif WITHIN(SERIAL_PORT, 1, NUM_UARTS)
#define MYSERIAL1 MSERIAL(SERIAL_PORT)
#else
#define MYSERIAL1 MSERIAL(1) // Dummy port
static_assert(false, "SERIAL_PORT must be from 1 to " STRINGIFY(NUM_UARTS) ".")
#endif
#ifdef SERIAL_PORT_2
#if SERIAL_PORT_2 == -1
#error "USB Serial is not supported on HC32F460"
#elif WITHIN(SERIAL_PORT_2, 1, NUM_UARTS)
#define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
#else
#define MYSERIAL2 MSERIAL(1) // Dummy port
static_assert(false, "SERIAL_PORT_2 must be from 1 to " STRINGIFY(NUM_UARTS) ".")
#endif
#endif
#ifdef SERIAL_PORT_3
#if SERIAL_PORT_3 == -1
#error "USB Serial is not supported on HC32F460"
#elif WITHIN(SERIAL_PORT_3, 1, NUM_UARTS)
#define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
#else
#define MYSERIAL3 MSERIAL(1) // Dummy port
static_assert(false, "SERIAL_PORT_3 must be from 1 to " STRINGIFY(NUM_UARTS) ".")
#endif
#endif
#ifdef LCD_SERIAL_PORT
#if LCD_SERIAL_PORT == -1
#error "USB Serial is not supported on HC32F460"
#elif WITHIN(LCD_SERIAL_PORT, 1, NUM_UARTS)
#define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
#else
#define LCD_SERIAL MSERIAL(1) // Dummy port
static_assert(false, "LCD_SERIAL_PORT must be from 1 to " STRINGIFY(NUM_UARTS) ".")
#endif
#if HAS_DGUS_LCD
#define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
#endif
#endif
#include "MarlinSerial.h"
//
// Emergency Parser
@@ -114,22 +63,19 @@
// Misc. Functions
//
#ifndef analogInputToDigitalPin
#define analogInputToDigitalPin(p) (p)
#define analogInputToDigitalPin(p) pin_t(p)
#endif
#define CRITICAL_SECTION_START \
uint32_t primask = __get_PRIMASK(); \
(void)__iCliRetVal()
#define CRITICAL_SECTION_START() \
const bool irqon = !__get_PRIMASK(); \
__disable_irq(); \
__DSB();
#define CRITICAL_SECTION_END() \
__DSB(); \
if (irqon) __enable_irq();
#define CRITICAL_SECTION_END \
if (!primask) \
(void)__iSeiRetVal()
// Disable interrupts
#define cli() noInterrupts()
// Enable interrupts
#define sei() interrupts()
#define cli() __disable_irq()
#define sei() __enable_irq()
// bss_end alias
#define __bss_end __bss_end__
+8
View File
@@ -24,6 +24,14 @@
#include "../../core/serial_hook.h"
#include <drivers/usart/Usart.h>
#define SERIAL_INDEX_MIN 1
#define SERIAL_INDEX_MAX 4
#include "../shared/serial_ports.h"
#if defined(LCD_SERIAL_PORT) && ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
#define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
#endif
// Optionally set uart IRQ priority to reduce overflow errors
//#define UART_RX_IRQ_PRIO 1
//#define UART_TX_IRQ_PRIO 1
+1 -1
View File
@@ -11,7 +11,7 @@ The HC32F460 HAL is designed to be generic enough for any HC32F460-based board.
- Examine the board's main processor. (Refer the naming key in `hc32.ini`.)
- Extend the `HC32F460C_common` base env for 256K, or `HC32F460E_common` for 512K.
3. Determine your board's application start address (see [below](#finding-the-application-start-address))
4. Set `board_build.ld_args.flash_start` to the app start address once you've found it. If your board doesn't use a bootloader, you may be able to use the "ICSP" header or DFU. This document will be updated once we have more information about flashing without a bootloader.
4. Set `board_upload.offset_address` to the app start address once you've found it. If your board doesn't use a bootloader, you may be able to use the "ICSP" header or DFU. This document will be updated once we have more information about flashing without a bootloader.
### Finding the application start address
+4 -7
View File
@@ -8,6 +8,7 @@
#define _HC32_APP_CONFIG_H_
#include "../../inc/MarlinConfigPre.h"
#include "sysclock.h"
//
// dev mode
@@ -64,12 +65,8 @@
// redirect printf to host serial
#define REDIRECT_PRINTF_TO_SERIAL 1
// F_CPU must be known at compile time, but on HC32F460 it's not.
// Thus we assume HCLK to be 200MHz, as that's what is configured in
// 'core_hook_sysclock_init' in 'sysclock.cpp'.
// If you face issues with this assumption, please double-check with the values
// printed by 'MarlinHAL::HAL_clock_frequencies_dump'.
// see also: HAL_TIMER_RATE in timers.h
#define F_CPU 200000000 // 200MHz HCLK
// F_CPU is F_HCLK, as that's the main CPU core's clock.
// see 'sysclock.h' for more information.
#define F_CPU F_HCLK
#endif // _HC32_APP_CONFIG_H_
+3 -1
View File
@@ -101,12 +101,14 @@ void setup_endstop_interrupts() {
SETUP(Z_MIN_PROBE);
SETUP(CALIBRATION);
#undef SETUP
}
// Ensure 1 - 10 IRQs are registered
// Disable some endstops if you encounter this error
#define ENDSTOPS_INTERRUPTS_COUNT COUNT_ENABLED(USE_X_MAX, USE_X_MIN, USE_X2_MAX, USE_X2_MIN, USE_Y_MAX, USE_Y_MIN, USE_Y2_MAX, USE_Y2_MIN, USE_Z_MAX, USE_Z_MIN, USE_Z2_MAX, USE_Z2_MIN, USE_Z3_MAX, USE_Z3_MIN, USE_Z4_MAX, USE_Z4_MIN, USE_Z_MIN_PROBE)
#define ENDSTOPS_INTERRUPTS_COUNT COUNT_ENABLED(USE_X_MAX, USE_X_MIN, USE_X2_MAX, USE_X2_MIN, USE_Y_MAX, USE_Y_MIN, USE_Y2_MAX, USE_Y2_MIN, USE_Z_MAX, USE_Z_MIN, USE_Z2_MAX, USE_Z2_MIN, USE_Z3_MAX, USE_Z3_MIN, USE_Z4_MAX, USE_Z4_MIN, USE_Z_MIN_PROBE, USE_CALIBRATION)
#if ENDSTOPS_INTERRUPTS_COUNT > 10
#error "Too many endstop interrupts! HC32F460 only supports 10 endstop interrupts."
#elif ENDSTOPS_INTERRUPTS_COUNT == 0
+4 -2
View File
@@ -94,8 +94,10 @@
#error "SERIAL_DMA requires USART_RX_DMA_SUPPORT to be enabled in the arduino core."
#endif
// USART_RX_DMA_SUPPORT does not implement core_hook_usart_rx_irq, which is required for the emergency parser
#if ENABLED(EMERGENCY_PARSER)
// Before arduino core version 1.2.0, USART_RX_DMA_SUPPORT did not implement
// core_hook_usart_rx_irq, which is required for the emergency parser.
// With 1.2.0, this was fixed (see https://github.com/shadow578/framework-arduino-hc32f46x/pull/25).
#if ENABLED(EMERGENCY_PARSER) && ARDUINO_CORE_VERSION_INT < GET_VERSION_INT(1, 2, 0)
#error "EMERGENCY_PARSER is not supported with SERIAL_DMA. Please disable either SERIAL_DMA or EMERGENCY_PARSER."
#endif
+39 -33
View File
@@ -18,41 +18,47 @@
*/
#pragma once
/**
* Pins Debugging for HC32
*
* - NUMBER_PINS_TOTAL
* - MULTI_NAME_PAD
* - getPinByIndex(index)
* - printPinNameByIndex(index)
* - getPinIsDigitalByIndex(index)
* - digitalPinToAnalogIndex(pin)
* - getValidPinMode(pin)
* - isValidPin(pin)
* - isAnalogPin(pin)
* - digitalRead_mod(pin)
* - pwm_status(pin)
* - printPinPWM(pin)
* - printPinPort(pin)
* - printPinNumber(pin)
* - printPinAnalog(pin)
*/
#include "../../inc/MarlinConfig.h"
#include "fastio.h"
#include <drivers/timera/timera_pwm.h>
//
// Translation of routines & variables used by pinsDebug.h
//
#ifndef BOARD_NR_GPIO_PINS
#error "Expected BOARD_NR_GPIO_PINS not found."
#endif
#define NUM_DIGITAL_PINS BOARD_NR_GPIO_PINS
#define NUMBER_PINS_TOTAL BOARD_NR_GPIO_PINS
#define VALID_PIN(pin) IS_GPIO_PIN(pin)
#define isValidPin(P) IS_GPIO_PIN(P)
// Note: pin_array is defined in `Marlin/src/pins/pinsDebug.h`, and since this file is included
// after it, it is available in this file as well.
#define GET_ARRAY_PIN(p) pin_t(pin_array[p].pin)
#define digitalRead_mod(p) extDigitalRead(p)
#define PRINT_PIN(p) \
do { \
sprintf_P(buffer, PSTR("%3hd "), int16_t(p)); \
SERIAL_ECHO(buffer); \
} while (0)
#define PRINT_PIN_ANALOG(p) \
do { \
sprintf_P(buffer, PSTR(" (A%2d) "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); \
SERIAL_ECHO(buffer); \
} while (0)
#define PRINT_PORT(p) print_port(p)
#define PRINT_ARRAY_NAME(x) \
do { \
sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); \
SERIAL_ECHO(buffer); \
} while (0)
#define getPinByIndex(x) pin_t(pin_array[x].pin)
#define digitalRead_mod(P) extDigitalRead(P)
#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%3hd "), int16_t(P)); SERIAL_ECHO(buffer); }while(0)
#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d) "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
#define MULTI_NAME_PAD 21 // Space needed to be pretty if not first name assigned to a pin
@@ -71,14 +77,14 @@
#define M43_NEVER_TOUCH(Q) (IS_HOST_USART_PIN(Q) || IS_OSC_PIN(Q))
#endif
static pin_t DIGITAL_PIN_TO_ANALOG_PIN(pin_t pin) {
if (!VALID_PIN(pin)) return -1;
int8_t digitalPinToAnalogIndex(const pin_t pin) {
if (!isValidPin(pin)) return -1;
const int8_t adc_channel = int8_t(PIN_MAP[pin].adc_info.channel);
return pin_t(adc_channel);
}
static bool IS_ANALOG(pin_t pin) {
if (!VALID_PIN(pin)) return false;
bool isAnalogPin(pin_t pin) {
if (!isValidPin(pin)) return false;
if (PIN_MAP[pin].adc_info.channel != ADC_PIN_INVALID)
return _GET_MODE(pin) == INPUT_ANALOG && !M43_NEVER_TOUCH(pin);
@@ -86,13 +92,13 @@ static bool IS_ANALOG(pin_t pin) {
return false;
}
static bool GET_PINMODE(const pin_t pin) {
return VALID_PIN(pin) && !IS_INPUT(pin);
bool getValidPinMode(const pin_t pin) {
return isValidPin(pin) && !IS_INPUT(pin);
}
static bool GET_ARRAY_IS_DIGITAL(const int16_t array_pin) {
const pin_t pin = GET_ARRAY_PIN(array_pin);
return (!IS_ANALOG(pin));
bool getPinIsDigitalByIndex(const int16_t index) {
const pin_t pin = getPinByIndex(index);
return (!isAnalogPin(pin));
}
/**
@@ -117,7 +123,7 @@ bool pwm_status(const pin_t pin) {
return timera_is_unit_initialized(unit) && timera_is_channel_active(unit, channel) && getPinMode(pin) == OUTPUT_PWM;
}
void pwm_details(const pin_t pin) {
void printPinPWM(const pin_t pin) {
// Get timer assignment for pin
timera_config_t *unit;
en_timera_channel_t channel;
@@ -161,7 +167,7 @@ void pwm_details(const pin_t pin) {
}
}
void print_port(pin_t pin) {
void printPinPort(pin_t pin) {
const char port = 'A' + char(pin >> 4); // Pin div 16
const int16_t gbit = PIN_MAP[pin].bit_pos;
char buffer[8];
+169 -66
View File
@@ -26,64 +26,144 @@
#ifdef ARDUINO_ARCH_HC32
// Get BOARD_XTAL_FREQUENCY from configuration / pins
#include "../../inc/MarlinConfig.h"
#include "sysclock.h"
#include <core_hooks.h>
#include <drivers/sysclock/sysclock_util.h>
/***
* @brief Automatically calculate M, N, P values for the MPLL to reach a target frequency.
* @param input_frequency The input frequency.
* @param target_frequency The target frequency.
* @return The MPLL configuration structure. Q and R are not set.
*
* @note
* Simplified MPLL block diagram, with intermediary clocks (1) = VCO_in, (2) = VCO_out:
*
* INPUT -> [/ M] -(1)-> [* N] -(2)-|-> [/ P] -> MPLL-P
*/
constexpr stc_clk_mpll_cfg_t get_mpll_config(double input_frequency, double target_frequency) {
// PLL input clock divider: M in [1, 24]
for (uint32_t M = 1; M <= 24; M++) {
double f_vco_in = input_frequency / M;
// 1 <= VCO_in <= 25 MHz
if (f_vco_in < 1e6 || f_vco_in > 25e6) continue;
// VCO multiplier: N in [20, 480]
for (uint32_t N = 20; N <= 480; N++) {
double f_vco_out = f_vco_in * N;
// 240 <= VCO_out <= 480 MHz
if (f_vco_out < 240e6 || f_vco_out > 480e6) continue;
// Output "P" divider: P in [2, 16]
for (uint32_t P = 2; P <= 16; P++) {
double f_calculated_out = f_vco_out / P;
if (f_calculated_out == target_frequency) {
// Found a match, return it
return {
.PllpDiv = P,
.PllqDiv = P, // Don't care for Q and R
.PllrDiv = P, // "
.plln = N,
.pllmDiv = M
};
}
}
}
}
// If no valid M, N, P found, return invalid config
return { 0, 0, 0, 0, 0 };
}
/**
* @brief Get the division factor required to get the target frequency from the input frequency.
* @tparam input_freq The input frequency.
* @tparam target_freq The target frequency.
* @return The division factor.
*/
template <uint32_t input_freq, uint32_t target_freq>
constexpr en_clk_sysclk_div_factor_t get_division_factor() {
// Calculate the divider to get the target frequency
constexpr float fdivider = static_cast<float>(input_freq) / static_cast<float>(target_freq);
constexpr int divider = static_cast<int>(fdivider);
// divider must be an integer
static_assert(fdivider == divider, "Target frequency not achievable, divider must be an integer");
// divider must be between 1 and 64 (enum range), and must be a power of 2
static_assert(divider >= 1 && divider <= 64, "Invalid divider, out of range");
static_assert((divider & (divider - 1)) == 0, "Invalid divider, not a power of 2");
// return the divider
switch (divider) {
case 1: return ClkSysclkDiv1;
case 2: return ClkSysclkDiv2;
case 4: return ClkSysclkDiv4;
case 8: return ClkSysclkDiv8;
case 16: return ClkSysclkDiv16;
case 32: return ClkSysclkDiv32;
case 64: return ClkSysclkDiv64;
}
}
/**
* @brief Validate the runtime clocks match the expected values.
*/
void validate_system_clocks() {
#define CLOCK_ASSERT(expected, actual) \
if (expected != actual) { \
SERIAL_ECHOPGM( \
"Clock Mismatch for " #expected ": " \
"expected ", expected, \
", got ", actual \
); \
CORE_ASSERT_FAIL("Clock Mismatch: " #expected); \
}
update_system_clock_frequencies();
CLOCK_ASSERT(F_SYSTEM_CLOCK, SYSTEM_CLOCK_FREQUENCIES.system);
CLOCK_ASSERT(F_HCLK, SYSTEM_CLOCK_FREQUENCIES.hclk);
CLOCK_ASSERT(F_EXCLK, SYSTEM_CLOCK_FREQUENCIES.exclk);
CLOCK_ASSERT(F_PCLK0, SYSTEM_CLOCK_FREQUENCIES.pclk0);
CLOCK_ASSERT(F_PCLK1, SYSTEM_CLOCK_FREQUENCIES.pclk1);
CLOCK_ASSERT(F_PCLK2, SYSTEM_CLOCK_FREQUENCIES.pclk2);
CLOCK_ASSERT(F_PCLK3, SYSTEM_CLOCK_FREQUENCIES.pclk3);
CLOCK_ASSERT(F_PCLK4, SYSTEM_CLOCK_FREQUENCIES.pclk4);
}
/**
* @brief Configure HC32 system clocks.
*
* This function is called by the Arduino core early in the startup process, before setup() is called.
* It is used to configure the system clocks to the desired state.
*
* See https://github.com/MarlinFirmware/Marlin/pull/27099 for more information.
*/
void core_hook_sysclock_init() {
// Set wait cycles, as we are about to switch to 200 MHz HCLK
sysclock_configure_flash_wait_cycles();
sysclock_configure_sram_wait_cycles();
// Configure MPLLp to 200 MHz output, with different settings depending on XTAL availability
#if BOARD_XTAL_FREQUENCY == 8000000 // 8 MHz XTAL
// - M = 1 => 8 MHz / 1 = 8 MHz
// - N = 50 => 8 MHz * 50 = 400 MHz
// - P = 2 => 400 MHz / 2 = 200 MHz (sysclk)
// - Q,R = 4 => 400 MHz / 4 = 100 MHz (dont care)
stc_clk_mpll_cfg_t pllConf = {
.PllpDiv = 2u, // P
.PllqDiv = 4u, // Q
.PllrDiv = 4u, // R
.plln = 50u, // N
.pllmDiv = 1u, // M
};
sysclock_configure_xtal();
sysclock_configure_mpll(ClkPllSrcXTAL, &pllConf);
// Select MPLL input frequency based on clock availability
#if BOARD_XTAL_FREQUENCY == 8000000 || BOARD_XTAL_FREQUENCY == 16000000 // 8 MHz or 16 MHz XTAL
constexpr uint32_t mpll_input_clock = BOARD_XTAL_FREQUENCY;
#elif BOARD_XTAL_FREQUENCY == 16000000 // 16 MHz XTAL
// - M = 1 => 16 MHz / 1 = 16 MHz
// - N = 50 => 16 MHz * 25 = 400 MHz
// - P = 2 => 400 MHz / 2 = 200 MHz (sysclk)
// - Q,R = 4 => 400 MHz / 4 = 100 MHz (dont care)
stc_clk_mpll_cfg_t pllConf = {
.PllpDiv = 2u, // P
.PllqDiv = 4u, // Q
.PllrDiv = 4u, // R
.plln = 50u, // N
.pllmDiv = 1u, // M
};
sysclock_configure_xtal();
sysclock_configure_mpll(ClkPllSrcXTAL, &pllConf);
#warning "HC32F460 with 16 MHz XTAL has not been tested."
#if BOARD_XTAL_FREQUENCY == 16000000
#warning "HC32F460 with 16 MHz XTAL has not been tested."
#endif
#else // HRC (16 MHz)
// - M = 1 => 16 MHz / 1 = 16 MHz
// - N = 25 => 16 MHz * 25 = 400 MHz
// - P = 2 => 400 MHz / 2 = 200 MHz (sysclk)
// - Q,R = 4 => 400 MHz / 4 = 100 MHz (dont care)
stc_clk_mpll_cfg_t pllConf = {
.PllpDiv = 2u, // P
.PllqDiv = 4u, // Q
.PllrDiv = 4u, // R
.plln = 25u, // N
.pllmDiv = 1u, // M
};
constexpr uint32_t mpll_input_clock = 16000000;
sysclock_configure_hrc();
sysclock_configure_mpll(ClkPllSrcHRC, &pllConf);
// HRC could have been configured by ICG to 20 MHz
// TODO: handle gracefully if HRC is not 16 MHz
@@ -91,29 +171,56 @@ void core_hook_sysclock_init() {
panic("HRC is not 16 MHz");
}
#ifdef BOARD_XTAL_FREQUENCY
#if defined(BOARD_XTAL_FREQUENCY)
#warning "No valid XTAL frequency defined, falling back to HRC."
#endif
#endif
// sysclk is now configured according to F_CPU (i.e., 200MHz PLL output)
constexpr uint32_t sysclock = F_CPU;
// Automagically calculate MPLL configuration
constexpr stc_clk_mpll_cfg_t pllConf = get_mpll_config(mpll_input_clock, F_SYSTEM_CLOCK);
static_assert(pllConf.pllmDiv != 0 && pllConf.plln != 0 && pllConf.PllpDiv != 0, "MPLL auto-configuration failed");
sysclock_configure_mpll(ClkPllSrcXTAL, &pllConf);
// Setup clock divisors for sysclk = 200 MHz
// Note: PCLK1 is used for step+temp timers, and need to be kept at 50 MHz (until there is a better solution)
// Setup clock divisors
constexpr stc_clk_sysclk_cfg_t sysClkConf = {
.enHclkDiv = ClkSysclkDiv1, // HCLK = 200 MHz (CPU)
.enExclkDiv = ClkSysclkDiv2, // EXCLK = 100 MHz (SDIO)
.enPclk0Div = ClkSysclkDiv2, // PCLK0 = 100 MHz (Timer6 (not used))
.enPclk1Div = ClkSysclkDiv4, // PCLK1 = 50 MHz (USART, SPI, I2S, Timer0 (step+temp), TimerA (Servo))
.enPclk2Div = ClkSysclkDiv8, // PCLK2 = 25 MHz (ADC)
.enPclk3Div = ClkSysclkDiv8, // PCLK3 = 25 MHz (I2C, WDT)
.enPclk4Div = ClkSysclkDiv2, // PCLK4 = 100 MHz (ADC ctl)
.enHclkDiv = get_division_factor<F_SYSTEM_CLOCK, F_HCLK>(),
.enExclkDiv = get_division_factor<F_SYSTEM_CLOCK, F_EXCLK>(),
.enPclk0Div = get_division_factor<F_SYSTEM_CLOCK, F_PCLK0>(),
.enPclk1Div = get_division_factor<F_SYSTEM_CLOCK, F_PCLK1>(),
.enPclk2Div = get_division_factor<F_SYSTEM_CLOCK, F_PCLK2>(),
.enPclk3Div = get_division_factor<F_SYSTEM_CLOCK, F_PCLK3>(),
.enPclk4Div = get_division_factor<F_SYSTEM_CLOCK, F_PCLK4>(),
};
sysclock_set_clock_dividers(&sysClkConf);
// Set power mode, before switch
power_mode_update_pre(F_SYSTEM_CLOCK);
// Switch to MPLL-P as system clock source
CLK_SetSysClkSource(CLKSysSrcMPLL);
// Set power mode, after switch
power_mode_update_post(F_SYSTEM_CLOCK);
// Verify clocks match expected values (at runtime)
#if ENABLED(MARLIN_DEV_MODE) || ENABLED(ALWAYS_VALIDATE_CLOCKS)
validate_system_clocks();
#endif
// Verify clock configuration (at compile time)
#if ARDUINO_CORE_VERSION_INT >= GET_VERSION_INT(1, 2, 0)
assert_mpll_config_valid<
mpll_input_clock,
pllConf.pllmDiv,
pllConf.plln,
pllConf.PllpDiv,
pllConf.PllqDiv,
pllConf.PllrDiv
>();
assert_system_clocks_valid<
sysclock,
F_SYSTEM_CLOCK,
sysClkConf.enHclkDiv,
sysClkConf.enPclk0Div,
sysClkConf.enPclk1Div,
@@ -122,18 +229,14 @@ void core_hook_sysclock_init() {
sysClkConf.enPclk4Div,
sysClkConf.enExclkDiv
>();
static_assert(get_mpll_output_clock(
mpll_input_clock,
pllConf.pllmDiv,
pllConf.plln,
pllConf.PllpDiv
) == F_SYSTEM_CLOCK, "actual MPLL output clock does not match F_SYSTEM_CLOCK");
#endif
sysclock_set_clock_dividers(&sysClkConf);
// Set power mode
power_mode_update_pre(sysclock);
// Switch to MPLL as sysclk source
CLK_SetSysClkSource(CLKSysSrcMPLL);
// Set power mode
power_mode_update_post(sysclock);
}
#endif // ARDUINO_ARCH_HC32
+65
View File
@@ -0,0 +1,65 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2024 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* HC32F460 system clock configuration.
*
* With the HC32 HAL, the various peripheral clocks (including the CPU clock) are derived
* from the main PLL (MPLL-P) output (referred to at F_SYSTEM_CLOCK).
*
* F_SYSTEM_CLOCK is the target frequency of the main PLL, and the PLL is automatically configured
* to achieve this frequency.
*
* The peripheral clocks are the result of integer division of F_SYSTEM_CLOCK.
* Their target frequencies are defined here, and the required division factors are calculated automatically.
* Note that the division factor must be a power of 2 between 1 and 64.
* If the target frequency is not achievable, a compile-time error will be generated.
*
* Additionally, there are interdependencies between the peripheral clocks, which are described in
* Section 4.4 "Working Clock Specifications" of the HC32F460 Reference Manual.
* With Arduino core >= 1.2.0, these interdependencies are checked at compile time.
* On earlier versions, you are on your own.
*
* For all clock frequencies, they can be checked at runtime by enabling the 'ALWAYS_VALIDATE_CLOCKS' define.
* In MARLIN_DEV_MODE, they will also be printed to the serial console by 'MarlinHAL::HAL_clock_frequencies_dump'.
*
* See https://github.com/MarlinFirmware/Marlin/pull/27099 for more information.
*/
// Target peripheral clock frequencies, must be integer divisors of F_SYSTEM_CLOCK.
// Changing the frequency here will automagically update everything else.
#define F_HCLK 200000000UL // 200 MHz; CPU
#define F_EXCLK (F_HCLK / 2) // 100 MHz; SDIO
#define F_PCLK0 (F_HCLK / 2) // 100 MHz; Timer6 (unused)
#define F_PCLK1 (F_HCLK / 4) // 50 MHz; USART, SPI, Timer0 (step + temp), TimerA (Servo)
#define F_PCLK2 (F_HCLK / 8) // 25 MHz; ADC Sampling
#define F_PCLK3 (F_HCLK / 8) // 25 MHz; I2C, WDT
#define F_PCLK4 (F_HCLK / 2) // 100 MHz; ADC Control
// MPLL-P clock target frequency. This must be >= the highest peripheral clock frequency.
// PLL config is automatically calculated based on this value.
#define F_SYSTEM_CLOCK F_HCLK
// The Peripheral clocks are only checked at runtime if this is enabled OR MARLIN_DEV_MODE is enabled.
// Compile time checks are always performed with Arduino core version >= 1.2.0.
#define ALWAYS_VALIDATE_CLOCKS 1
+7 -8
View File
@@ -20,6 +20,7 @@
#pragma once
#include <stdint.h>
#include <Timer0.h>
#include "sysclock.h"
//
// Timer Types
@@ -42,17 +43,15 @@ extern Timer0 step_timer;
* HAL_TIMER_RATE must be known at compile time since it's used to calculate
* STEPPER_TIMER_RATE, which is used in 'constexpr' calculations.
* On the HC32F460 the timer rate depends on PCLK1, which is derived from the
* system clock configured at runtime. As a workaround, we use the existing
* assumption of a 200MHz clock, defining F_CPU as 200000000, then configure PCLK1
* as F_CPU with a divider of 4 in 'sysclock.cpp::core_hook_sysclock_init'.
* system clock configured at runtime.
* Thus we use the 'F_PCLK1' constant defined in 'sysclock.h'.
*
* If you face issues with this assumption, please double-check with the values
* printed by 'MarlinHAL::HAL_clock_frequencies_dump'.
* See https://github.com/MarlinFirmware/Marlin/pull/27099 for more information.
*
* TODO: If the 'constexpr' requirement is ever lifted, use TIMER0_BASE_FREQUENCY instead
* NOTE: If the 'constexpr' requirement is ever lifted, TIMER0_BASE_FREQUENCY could
* be used instead. Tho this would probably not make any noticable difference.
*/
#define HAL_TIMER_RATE (F_CPU / 4) // i.e., 50MHz
//#define HAL_TIMER_RATE TIMER0_BASE_FREQUENCY
#define HAL_TIMER_RATE F_PCLK1
// Temperature timer
#define TEMP_TIMER_NUM (&temp_timer)
@@ -82,7 +82,7 @@ static inline uint8_t swSpiTransfer_mode_3(uint8_t b, const uint8_t spi_speed, c
}
static void u8g_sw_spi_shift_out(uint8_t val) {
#if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
#if U8G_SPI_USE_MODE_3
swSpiTransfer_mode_3(val, SPI_speed);
#else
swSpiTransfer_mode_0(val, SPI_speed);
@@ -116,15 +116,15 @@ uint8_t u8g_com_HAL_HC32_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, voi
break;
case U8G_COM_MSG_CHIP_SELECT:
#if ANY(FYSETC_MINI_12864, MKS_MINI_12864) // This LCD SPI is running mode 3 while SD card is running mode 0
if (arg_val) { // SCK idle state needs to be set to the proper idle state before
// the next chip select goes active
WRITE(DOGLCD_SCK, HIGH); // Set SCK to mode 3 idle state before CS goes active
#if U8G_SPI_USE_MODE_3 // This LCD SPI is running mode 3 while SD card is running mode 0
if (arg_val) { // SCK idle state needs to be set to the proper idle state before
// the next chip select goes active
WRITE(DOGLCD_SCK, HIGH); // Set SCK to mode 3 idle state before CS goes active
WRITE(DOGLCD_CS, LOW);
}
else {
WRITE(DOGLCD_CS, HIGH);
WRITE(DOGLCD_SCK, LOW); // Set SCK to mode 0 idle state after CS goes inactive
WRITE(DOGLCD_SCK, LOW); // Set SCK to mode 0 idle state after CS goes inactive
}
#else
WRITE(DOGLCD_CS, !arg_val);
+1 -1
View File
@@ -52,7 +52,7 @@ uint8_t MarlinHAL::active_ch = 0;
uint16_t MarlinHAL::adc_value() {
const pin_t pin = analogInputToDigitalPin(active_ch);
if (!VALID_PIN(pin)) return 0;
if (!isValidPin(pin)) return 0;
return uint16_t((Gpio::get(pin) >> 2) & 0x3FF); // return 10bit value as Marlin expects
}
+6 -6
View File
@@ -49,28 +49,28 @@ extern "C" void delay(const int msec) {
// IO functions
// As defined by Arduino INPUT(0x0), OUTPUT(0x1), INPUT_PULLUP(0x2)
void pinMode(const pin_t pin, const uint8_t mode) {
if (!VALID_PIN(pin)) return;
if (!isValidPin(pin)) return;
Gpio::setMode(pin, mode);
}
void digitalWrite(pin_t pin, uint8_t pin_status) {
if (!VALID_PIN(pin)) return;
if (!isValidPin(pin)) return;
Gpio::set(pin, pin_status);
}
bool digitalRead(pin_t pin) {
if (!VALID_PIN(pin)) return false;
if (!isValidPin(pin)) return false;
return Gpio::get(pin);
}
void analogWrite(pin_t pin, int pwm_value) { // 1 - 254: pwm_value, 0: LOW, 255: HIGH
if (!VALID_PIN(pin)) return;
if (!isValidPin(pin)) return;
Gpio::set(pin, pwm_value);
}
uint16_t analogRead(pin_t adc_pin) {
if (!VALID_PIN(DIGITAL_PIN_TO_ANALOG_PIN(adc_pin))) return 0;
return Gpio::get(DIGITAL_PIN_TO_ANALOG_PIN(adc_pin));
if (!isValidPin(digitalPinToAnalogIndex(adc_pin))) return 0;
return Gpio::get(digitalPinToAnalogIndex(adc_pin));
}
char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s) {
+8 -8
View File
@@ -37,29 +37,29 @@ constexpr uint8_t NUM_ANALOG_INPUTS = 16;
constexpr uint8_t analog_offset = NUM_DIGITAL_PINS - NUM_ANALOG_INPUTS;
// Get the digital pin for an analog index
constexpr pin_t analogInputToDigitalPin(const int8_t p) {
return (WITHIN(p, 0, NUM_ANALOG_INPUTS) ? analog_offset + p : P_NC);
constexpr pin_t analogInputToDigitalPin(const int8_t a) {
return (WITHIN(a, 0, NUM_ANALOG_INPUTS - 1) ? analog_offset + a : P_NC);
}
// Get the analog index for a digital pin
constexpr int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t p) {
return (WITHIN(p, analog_offset, NUM_DIGITAL_PINS) ? p - analog_offset : P_NC);
constexpr int8_t digitalPinToAnalogIndex(const pin_t pin) {
return (WITHIN(pin, analog_offset, NUM_DIGITAL_PINS - 1) ? pin - analog_offset : P_NC);
}
// Return the index of a pin number
constexpr int16_t GET_PIN_MAP_INDEX(const pin_t pin) { return pin; }
// Test whether the pin is valid
constexpr bool VALID_PIN(const pin_t p) { return WITHIN(p, 0, NUM_DIGITAL_PINS); }
constexpr bool isValidPin(const pin_t pin) { return WITHIN(pin, 0, NUM_DIGITAL_PINS - 1); }
// Test whether the pin is PWM
constexpr bool PWM_PIN(const pin_t p) { return false; }
constexpr bool PWM_PIN(const pin_t) { return false; }
// Test whether the pin is interruptible
constexpr bool INTERRUPT_PIN(const pin_t p) { return false; }
constexpr bool INTERRUPT_PIN(const pin_t) { return false; }
// Get the pin number at the given index
constexpr pin_t GET_PIN_MAP_PIN(const int16_t ind) { return ind; }
constexpr pin_t GET_PIN_MAP_PIN(const int16_t index) { return pin_t(index); }
// Parse a G-code word into a pin index
int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
+40 -20
View File
@@ -19,30 +19,50 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* Support routines for X86_64
*/
/**
* Translation of routines & variables used by pinsDebug.h
* Pins Debugging for Linux Native
*
* - NUMBER_PINS_TOTAL
* - MULTI_NAME_PAD
* - getPinByIndex(index)
* - printPinNameByIndex(index)
* - getPinIsDigitalByIndex(index)
* - digitalPinToAnalogIndex(pin)
* - getValidPinMode(pin)
* - isValidPin(pin)
* - isAnalogPin(pin)
* - digitalRead_mod(pin)
* - pwm_status(pin)
* - printPinPWM(pin)
* - printPinPort(pin)
* - printPinNumber(pin)
* - printPinAnalog(pin)
*/
#define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
#define IS_ANALOG(P) (DIGITAL_PIN_TO_ANALOG_PIN(P) >= 0 ? 1 : 0)
#define digitalRead_mod(p) digitalRead(p)
#define GET_ARRAY_PIN(p) pin_array[p].pin
#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d) "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
#define MULTI_NAME_PAD 16 // space needed to be pretty if not first name assigned to a pin
#define getPinByIndex(x) pin_array[x].pin
#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
// active ADC function/mode/code values for PINSEL registers
constexpr int8_t ADC_pin_mode(pin_t pin) { return -1; }
constexpr int8_t ADC_pin_mode(const pin_t) { return -1; }
int8_t get_pin_mode(const pin_t pin) { return VALID_PIN(pin) ? 0 : -1; }
// The pin and index are the same on this platform
bool getPinIsDigitalByIndex(const pin_t pin) {
return (!isAnalogPin(pin) || get_pin_mode(pin) != ADC_pin_mode(pin));
}
bool GET_PINMODE(const pin_t pin) {
#define isAnalogPin(P) (digitalPinToAnalogIndex(P) >= 0)
#define digitalRead_mod(P) digitalRead(P)
int8_t get_pin_mode(const pin_t pin) { return isValidPin(pin) ? 0 : -1; }
bool getValidPinMode(const pin_t pin) {
const int8_t pin_mode = get_pin_mode(pin);
if (pin_mode == -1 || pin_mode == ADC_pin_mode(pin)) // Invalid pin or active analog pin
return false;
@@ -50,11 +70,11 @@ bool GET_PINMODE(const pin_t pin) {
return (Gpio::getMode(pin) != 0); // Input/output state
}
bool GET_ARRAY_IS_DIGITAL(const pin_t pin) {
return (!IS_ANALOG(pin) || get_pin_mode(pin) != ADC_pin_mode(pin));
}
void pwm_details(const pin_t pin) {}
void printPinPWM(const pin_t) {}
bool pwm_status(const pin_t) { return false; }
void print_port(const pin_t) {}
void printPinPort(const pin_t) {}
#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%3d "), P); SERIAL_ECHO(buffer); }while(0)
#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d) "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
-12
View File
@@ -28,12 +28,6 @@
// spiBeginTransaction.
#endif
// Onboard SD
//#define SD_SCK_PIN P0_07
//#define SD_MISO_PIN P0_08
//#define SD_MOSI_PIN P0_09
//#define SD_SS_PIN P0_06
// External SD
#ifndef SD_SCK_PIN
#define SD_SCK_PIN 50
@@ -44,9 +38,3 @@
#ifndef SD_MOSI_PIN
#define SD_MOSI_PIN 52
#endif
#ifndef SD_SS_PIN
#define SD_SS_PIN 53
#endif
#ifndef SDSS
#define SDSS SD_SS_PIN
#endif
-2
View File
@@ -35,8 +35,6 @@
#include <CDCSerial.h>
#include <usb/mscuser.h>
DefaultSerial1 USBSerial(false, UsbSerial);
uint32_t MarlinHAL::adc_result = 0;
pin_t MarlinHAL::adc_pin = 0;
+7 -64
View File
@@ -38,72 +38,15 @@ extern "C" volatile uint32_t _millis;
#include "../shared/math_32bit.h"
#include "../shared/HAL_SPI.h"
#include "fastio.h"
#include "MarlinSerial.h"
#include <adc.h>
#include <pinmapping.h>
#include <CDCSerial.h>
// ------------------------
// Serial ports
// ------------------------
//
// Serial Ports
//
typedef ForwardSerial1Class< decltype(UsbSerial) > DefaultSerial1;
extern DefaultSerial1 USBSerial;
#define _MSERIAL(X) MSerial##X
#define MSERIAL(X) _MSERIAL(X)
#if SERIAL_PORT == -1
#define MYSERIAL1 USBSerial
#elif WITHIN(SERIAL_PORT, 0, 3)
#define MYSERIAL1 MSERIAL(SERIAL_PORT)
#else
#error "SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#ifdef SERIAL_PORT_2
#if SERIAL_PORT_2 == -1
#define MYSERIAL2 USBSerial
#elif WITHIN(SERIAL_PORT_2, 0, 3)
#define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
#else
#error "SERIAL_PORT_2 must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#endif
#ifdef SERIAL_PORT_3
#if SERIAL_PORT_3 == -1
#define MYSERIAL3 USBSerial
#elif WITHIN(SERIAL_PORT_3, 0, 3)
#define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
#else
#error "SERIAL_PORT_3 must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#endif
#ifdef MMU2_SERIAL_PORT
#if MMU2_SERIAL_PORT == -1
#define MMU2_SERIAL USBSerial
#elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
#define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
#else
#error "MMU2_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#endif
#ifdef LCD_SERIAL_PORT
#if LCD_SERIAL_PORT == -1
#define LCD_SERIAL USBSerial
#elif WITHIN(LCD_SERIAL_PORT, 0, 3)
#define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
#else
#error "LCD_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#if HAS_DGUS_LCD
#define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.available()
#endif
#endif
#include "MarlinSerial.h"
//
// Interrupts
@@ -137,12 +80,12 @@ extern DefaultSerial1 USBSerial;
//
// Test whether the pin is valid
constexpr bool VALID_PIN(const pin_t pin) {
constexpr bool isValidPin(const pin_t pin) {
return LPC176x::pin_is_valid(pin);
}
// Get the analog index for a digital pin
constexpr int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t pin) {
constexpr int8_t digitalPinToAnalogIndex(const pin_t pin) {
return (LPC176x::pin_is_valid(pin) && LPC176x::pin_has_adc(pin)) ? pin : -1;
}
@@ -159,7 +102,7 @@ constexpr pin_t GET_PIN_MAP_PIN(const int16_t index) {
// Parse a G-code word into a pin index
int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
// P0.6 thru P0.9 are for the onboard SD card
#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09,
#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09
// ------------------------
// Defines
+2
View File
@@ -25,6 +25,8 @@
#include "../../inc/MarlinConfig.h"
DefaultSerial1 USBSerial(false, UsbSerial);
#if USING_HW_SERIAL0
MarlinSerial _MSerial0(LPC_UART0);
MSerialT MSerial0(true, _MSerial0);
+13
View File
@@ -21,6 +21,7 @@
*/
#pragma once
#include <CDCSerial.h>
#include <HardwareSerial.h>
#include <WString.h>
@@ -30,6 +31,18 @@
#endif
#include "../../core/serial_hook.h"
typedef ForwardSerial1Class< decltype(UsbSerial) > DefaultSerial1;
extern DefaultSerial1 USBSerial;
#define SERIAL_INDEX_MIN 0
#define SERIAL_INDEX_MAX 3
#define USB_SERIAL_PORT(...) USBSerial
#include "../shared/serial_ports.h"
#if defined(LCD_SERIAL_PORT) && ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
#define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.available()
#endif
class MarlinSerial : public HardwareSerial<RX_BUFFER_SIZE, TX_BUFFER_SIZE> {
public:
MarlinSerial(LPC_UART_TypeDef *UARTx) : HardwareSerial<RX_BUFFER_SIZE, TX_BUFFER_SIZE>(UARTx) { }
@@ -146,6 +146,12 @@ void setup_endstop_interrupts() {
#endif
_ATTACH(Z_MIN_PROBE_PIN);
#endif
#if USE_CALIBRATION
#if !LPC1768_PIN_INTERRUPT_M(CALIBRATION_PIN)
#error "CALIBRATION_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(CALIBRATION_PIN);
#endif
#if USE_I_MAX
#if !LPC1768_PIN_INTERRUPT_M(I_MAX_PIN)
#error "I_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+4 -2
View File
@@ -26,8 +26,10 @@
void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
if (!LPC176x::pin_is_valid(pin)) return;
if (LPC176x::pwm_attach_pin(pin))
LPC176x::pwm_write_ratio(pin, invert ? 1.0f - (float)v / v_size : (float)v / v_size); // map 1-254 onto PWM range
if (LPC176x::pwm_attach_pin(pin)) {
const uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, LPC176x::pwm_get_period(pin));
LPC176x::pwm_write(pin, duty);
}
}
void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
+1 -1
View File
@@ -66,7 +66,7 @@
#define _WRITE(IO,V) WRITE_PIN(IO,V)
/// toggle a pin
#define _TOGGLE(IO) _WRITE(IO, !READ(IO))
#define _TOGGLE(IO) LPC176x::gpio_toggle(IO)
/// set pin as input
#define _SET_INPUT(IO) SET_DIR_INPUT(IO)
+3 -3
View File
@@ -121,7 +121,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
#if IS_TX1(BTN_EN2) || IS_RX1(BTN_EN1)
#error "Serial port pins (1) conflict with Encoder Buttons!"
#elif ANY_TX(1, SD_SCK_PIN, LCD_PINS_D4, DOGLCD_SCK, LCD_RESET_PIN, LCD_PINS_RS, SHIFT_CLK_PIN) \
|| ANY_RX(1, LCD_SDSS, LCD_PINS_RS, SD_MISO_PIN, DOGLCD_A0, SD_SS_PIN, LCD_SDSS, DOGLCD_CS, LCD_RESET_PIN, LCD_BACKLIGHT_PIN)
|| ANY_RX(1, LCD_SDSS_PIN, LCD_PINS_RS, SD_MISO_PIN, DOGLCD_A0, SD_SS_PIN, DOGLCD_CS, LCD_RESET_PIN, LCD_BACKLIGHT_PIN)
#error "Serial port pins (1) conflict with LCD pins!"
#endif
#endif
@@ -211,8 +211,8 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
#error "SCL0 overlaps with Encoder Button!"
#elif IS_SCL0(SD_SS_PIN)
#error "SCL0 overlaps with SD_SS_PIN!"
#elif IS_SCL0(LCD_SDSS)
#error "SCL0 overlaps with LCD_SDSS!"
#elif IS_SCL0(LCD_SDSS_PIN)
#error "SCL0 overlaps with LCD_SDSS_PIN!"
#endif
#undef PIN_IS_SDA0
#undef IS_SCL0
+28 -15
View File
@@ -19,22 +19,35 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* Support routines for LPC1768
*/
/**
* Translation of routines & variables used by pinsDebug.h
* Pins Debugging for LPC1768/9
*
* - NUMBER_PINS_TOTAL
* - MULTI_NAME_PAD
* - getPinByIndex(index)
* - printPinNameByIndex(index)
* - getPinIsDigitalByIndex(index)
* - digitalPinToAnalogIndex(pin)
* - getValidPinMode(pin)
* - isValidPin(pin)
* - isAnalogPin(pin)
* - digitalRead_mod(pin)
* - pwm_status(pin)
* - printPinPWM(pin)
* - printPinPort(pin)
* - printPinNumber(pin)
* - printPinAnalog(pin)
*/
#define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
#define IS_ANALOG(P) (DIGITAL_PIN_TO_ANALOG_PIN(P) >= 0 ? 1 : 0)
#define digitalRead_mod(p) extDigitalRead(p)
#define GET_ARRAY_PIN(p) pin_array[p].pin
#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("P%d_%02d"), LPC176x::pin_port(p), LPC176x::pin_bit(p)); SERIAL_ECHO(buffer); }while(0)
#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR("_A%d "), LPC176x::pin_get_adc_channel(pin)); SERIAL_ECHO(buffer); }while(0)
#define isAnalogPin(P) (digitalPinToAnalogIndex(P) >= 0)
#define digitalRead_mod(P) extDigitalRead(P)
#define getPinByIndex(x) pin_array[x].pin
#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("P%d_%02d"), LPC176x::pin_port(P), LPC176x::pin_bit(P)); SERIAL_ECHO(buffer); }while(0)
#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR("_A%d "), LPC176x::pin_get_adc_channel(P)); SERIAL_ECHO(buffer); }while(0)
#define MULTI_NAME_PAD 17 // space needed to be pretty if not first name assigned to a pin
// pins that will cause hang/reset/disconnect in M43 Toggle and Watch utilities
@@ -42,15 +55,15 @@
#define M43_NEVER_TOUCH(Q) ((Q) == P0_29 || (Q) == P0_30 || (Q) == P2_09) // USB pins
#endif
bool GET_PINMODE(const pin_t pin) {
bool getValidPinMode(const pin_t pin) {
if (!LPC176x::pin_is_valid(pin) || LPC176x::pin_adc_enabled(pin)) // Invalid pin or active analog pin
return false;
return LPC176x::gpio_direction(pin);
}
#define GET_ARRAY_IS_DIGITAL(x) ((bool) pin_array[x].is_digital)
#define getPinIsDigitalByIndex(x) ((bool) pin_array[x].is_digital)
void print_port(const pin_t) {}
void pwm_details(const pin_t) {}
void printPinPort(const pin_t) {}
void printPinPWM(const pin_t) {}
bool pwm_status(const pin_t) { return false; }
+6 -13
View File
@@ -28,12 +28,12 @@
// spiBeginTransaction.
#endif
/** onboard SD card */
//#define SD_SCK_PIN P0_07
//#define SD_MISO_PIN P0_08
//#define SD_MOSI_PIN P0_09
//#define SD_SS_PIN P0_06
/** external */
// Onboard SD
//#define SD_SCK_PIN P0_07
//#define SD_MISO_PIN P0_08
//#define SD_MOSI_PIN P0_09
// External SD
#ifndef SD_SCK_PIN
#define SD_SCK_PIN P0_15
#endif
@@ -43,10 +43,3 @@
#ifndef SD_MOSI_PIN
#define SD_MOSI_PIN P0_18
#endif
#ifndef SD_SS_PIN
#define SD_SS_PIN P1_23
#endif
#if !defined(SDSS) || SDSS == P_NC // gets defaulted in pins.h
#undef SDSS
#define SDSS SD_SS_PIN
#endif
@@ -132,7 +132,7 @@ uint8_t swSpiTransfer_mode_3(uint8_t b, const uint8_t spi_speed, const pin_t sck
static uint8_t SPI_speed = 0;
static void u8g_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val) {
#if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
#if U8G_SPI_USE_MODE_3
swSpiTransfer_mode_3(val, SPI_speed, clockPin, -1, dataPin);
#else
swSpiTransfer_mode_0(val, SPI_speed, clockPin, -1, dataPin);
@@ -160,15 +160,15 @@ uint8_t u8g_com_HAL_LPC1768_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
break;
case U8G_COM_MSG_CHIP_SELECT:
#if ANY(FYSETC_MINI_12864, MKS_MINI_12864) // LCD SPI is running mode 3 while SD card is running mode 0
if (arg_val) { // SCK idle state needs to be set to the proper idle state before
// the next chip select goes active
u8g_SetPILevel(u8g, U8G_PI_SCK, 1); // Set SCK to mode 3 idle state before CS goes active
#if U8G_SPI_USE_MODE_3 // LCD SPI is running mode 3 while SD card is running mode 0
if (arg_val) { // SCK idle state needs to be set to the proper idle state before
// the next chip select goes active
u8g_SetPILevel(u8g, U8G_PI_SCK, 1); // Set SCK to mode 3 idle state before CS goes active
u8g_SetPILevel(u8g, U8G_PI_CS, LOW);
}
else {
u8g_SetPILevel(u8g, U8G_PI_CS, HIGH);
u8g_SetPILevel(u8g, U8G_PI_SCK, 0); // Set SCK to mode 0 idle state after CS goes inactive
u8g_SetPILevel(u8g, U8G_PI_SCK, 0); // Set SCK to mode 0 idle state after CS goes inactive
}
#else
u8g_SetPILevel(u8g, U8G_PI_CS, !arg_val);
@@ -13,9 +13,9 @@ if pioutil.is_pio_build():
target_drive = "REARM"
import platform
current_OS = platform.system()
Import("env")
env = pioutil.env
def print_error(e):
print('\nUnable to find destination disk (%s)\n' \
@@ -37,7 +37,7 @@ if pioutil.is_pio_build():
#
# platformio.ini will accept this for a Windows upload port designation: 'upload_port = L:'
# Windows - doesn't care about the disk's name, only cares about the drive letter
import subprocess,string
import subprocess, string
from ctypes import windll
from pathlib import PureWindowsPath
-125
View File
@@ -1,125 +0,0 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#ifdef TARGET_LPC4078
#include "../../inc/MarlinConfig.h"
#include "../shared/Delay.h"
#include "../../../gcode/parser.h"
DefaultSerial1 USBSerial(false, MCDCSerial0);
uint32_t MarlinHAL::adc_result = 0;
// U8glib required functions
extern "C" {
void u8g_xMicroDelay(uint16_t val) { DELAY_US(val); }
void u8g_MicroDelay() { u8g_xMicroDelay(1); }
void u8g_10MicroDelay() { u8g_xMicroDelay(10); }
void u8g_Delay(uint16_t val) { delay(val); }
}
// return free heap space
int freeMemory() {
char stack_end;
void *heap_start = malloc(sizeof(uint32_t));
if (heap_start == 0) return 0;
uint32_t result = (uint32_t)&stack_end - (uint32_t)heap_start;
free(heap_start);
return result;
}
void MarlinHAL::reboot() { MCUCore::nvic_system_reset(); }
uint8_t MarlinHAL::get_reset_source() {
#if ENABLED(USE_WATCHDOG)
if (watchdog_timed_out()) return RST_WATCHDOG;
#endif
return RST_POWER_ON;
}
void MarlinHAL::clear_reset_source() { watchdog_clear_timeout_flag(); }
void flashFirmware(const int16_t) {
delay(500); // Give OS time to disconnect
//USB_Connect(false); // USB clear connection
delay(1000); // Give OS time to notice
hal.reboot();
}
#if ENABLED(USE_WATCHDOG)
#define WDT_TIMEOUT TERN(WATCHDOG_DURATION_8S, 8.0f, 4.0f) // 4 or 8 second timeout
void MarlinHAL::watchdog_init() {
#if ENABLED(WATCHDOG_RESET_MANUAL)
// We enable the watchdog timer, but only for the interrupt.
// Configure WDT to only trigger an interrupt
// Disable WDT interrupt (just in case, to avoid triggering it!)
NVIC_DisableIRQ(WDT_IRQn);
// We NEED memory barriers to ensure Interrupts are actually disabled!
// ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
__DSB();
__ISB();
// WDT defaults to trigger an interrupt
// Configure and enable WDT interrupt.
NVIC_ClearPendingIRQ(WDT_IRQn);
NVIC_SetPriority(WDT_IRQn, 0); // Use highest priority, so we detect all kinds of lockups
NVIC_EnableIRQ(WDT_IRQn);
#else
MCUI::watchdog_set_timeout_triggers_reset();
#endif
MCUI::watchdog_set_timeout_in_seconds(WDT_TIMEOUT);
MCUI::watchdog_enable();
}
void MarlinHAL::watchdog_refresh() {
MCUI::watchdog_feed();
#if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
static millis_t next_flash = millis();
if (ELAPSED(millis(), next_flash)) {
next_flash = millis() + 200;
TOGGLE(LED_PIN); // heartbeat indicator
}
#endif
}
// Timeout state
bool MarlinHAL::watchdog_timed_out() { return MCUI::watchdog_has_triggered(); }
void MarlinHAL::watchdog_clear_timeout_flag() { MCUI::watchdog_clear_timeout_flag(); }
#endif // USE_WATCHDOG
// For M42/M43, scan command line for pin code
// return index into pin map array if found and the pin is valid.
// return dval if not found or not a valid pin.
int16_t PARSED_PIN_INDEX(const char code, const int16_t dval) {
const uint16_t val = (uint16_t)parser.intval(code, -1), port = val / 100, pin = val % 100;
const int16_t ind = (port < ((NUM_DIGITAL_PINS) >> 5) && pin < 32) ? ((port << 5) | pin) : -2;
return ind > -1 ? ind : dval;
}
#endif // TARGET_LPC4078
-276
View File
@@ -1,276 +0,0 @@
/**
* Marlin 3D Printer Firmware
*
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
* Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* HAL_LPC1768/HAL.h
* Hardware Abstraction Layer for NXP LPC1768
*/
#define CPU_32_BIT
#include <stdint.h>
#include <stdarg.h>
#include <algorithm>
#include "../shared/Marduino.h"
#include "../shared/Delay.h"
#include "../shared/math_32bit.h"
#include "../shared/HAL_SPI.h"
#include "fastio.h"
#include "MarlinSerial.h"
#include <mcu_interface.h>
// ------------------------
// Serial ports
// ------------------------
typedef ForwardSerial1Class< decltype(MCDCSerial0) > DefaultSerial1;
extern DefaultSerial1 USBSerial;
#define _MSERIAL(X) MSerial##X
#define MSERIAL(X) _MSERIAL(X)
#if SERIAL_PORT == -1
#define MYSERIAL1 USBSerial
#elif WITHIN(SERIAL_PORT, 0, 3)
#define MYSERIAL1 MSERIAL(SERIAL_PORT)
#else
#error "SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#ifdef SERIAL_PORT_2
#if SERIAL_PORT_2 == -1
#define MYSERIAL2 USBSerial
#elif WITHIN(SERIAL_PORT_2, 0, 3)
#define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
#else
#error "SERIAL_PORT_2 must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#endif
#ifdef SERIAL_PORT_3
#if SERIAL_PORT_3 == -1
#define MYSERIAL3 USBSerial
#elif WITHIN(SERIAL_PORT_3, 0, 3)
#define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
#else
#error "SERIAL_PORT_3 must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#endif
#ifdef MMU2_SERIAL_PORT
#if MMU2_SERIAL_PORT == -1
#define MMU2_SERIAL USBSerial
#elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
#define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
#else
#error "MMU2_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#endif
#ifdef LCD_SERIAL_PORT
#if LCD_SERIAL_PORT == -1
#define LCD_SERIAL USBSerial
#elif WITHIN(LCD_SERIAL_PORT, 0, 3)
#define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
#else
#error "LCD_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
#endif
#if HAS_DGUS_LCD
#define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.available()
#endif
#endif
//
// Interrupts
//
#define CRITICAL_SECTION_START() const bool irqon = !MCUCore::primask(); MCUCore::nvic_interrupts_disable()
#define CRITICAL_SECTION_END() if (irqon) MCUCore::nvic_interrupts_enable()
#define cli() noInterrupts()
#define sei() interrupts()
//
// ADC
//
#define ADC_MEDIAN_FILTER_SIZE (23) // Higher values increase step delay (phase shift),
// (ADC_MEDIAN_FILTER_SIZE + 1) / 2 sample step delay (12 samples @ 500Hz: 24ms phase shift)
// Memory usage per ADC channel (bytes): (6 * ADC_MEDIAN_FILTER_SIZE) + 16
// 8 * ((6 * 23) + 16 ) = 1232 Bytes for 8 channels
#define ADC_LOWPASS_K_VALUE (2) // Higher values increase rise time
// Rise time sample delays for 100% signal convergence on full range step
// (1 : 13, 2 : 32, 3 : 67, 4 : 139, 5 : 281, 6 : 565, 7 : 1135, 8 : 2273)
// K = 6, 565 samples, 500Hz sample rate, 1.13s convergence on full range step
// Memory usage per ADC channel (bytes): 4 (32 Bytes for 8 channels)
#define HAL_ADC_VREF 3.3 // ADC voltage reference
#define HAL_ADC_RESOLUTION 12 // 15 bit maximum, raw temperature is stored as int16_t
#define HAL_ADC_FILTERED // Disable oversampling done in Marlin as ADC values already filtered in HAL
//
// Pin Mapping for M42, M43, M226
//
// Test whether the pin is valid
constexpr bool VALID_PIN(const pin_t pin) {
return MCUI::pin_is_valid(pin);
}
// Get the analog index for a digital pin
constexpr int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t pin) {
return (MCUI::pin_is_valid(pin) && MCUI::pin_has_adc(pin)) ? pin : -1;
}
//
// Misc. Functions
//
#ifndef analogInputToDigitalPin
#define analogInputToDigitalPin(p) (p)
#endif
// Return the index of a pin number
constexpr int16_t GET_PIN_MAP_INDEX(const pin_t pin) {
return MCUI::pin_index(pin);
}
// Get the pin number at the given index
constexpr pin_t GET_PIN_MAP_PIN(const int16_t index) {
return MCUI::pin_index(index);
}
// Parse a G-code word into a pin index
int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
// P0.6 thru P0.9 are for the onboard SD card
#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09,
// ------------------------
// Defines
// ------------------------
void flashFirmware(const int16_t);
#define HAL_CAN_SET_PWM_FREQ // This HAL supports PWM Frequency adjustment
// Default graphical display delays
#define CPU_ST7920_DELAY_1 600
#define CPU_ST7920_DELAY_2 750
#define CPU_ST7920_DELAY_3 750
// ------------------------
// Free Memory Accessor
// ------------------------
#pragma GCC diagnostic push
#if GCC_VERSION <= 50000
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
int freeMemory();
#pragma GCC diagnostic pop
// ------------------------
// MarlinHAL Class
// ------------------------
class MarlinHAL {
public:
// Earliest possible init, before setup()
MarlinHAL() {}
static void init(); // Called early in setup()
static void init_board() {} // Called less early in setup()
static void reboot(); // Restart the firmware from 0x0
// Interrupts
static bool isr_state() { return MCUCore::primask(); }
static void isr_on() { MCUCore::nvic_interrupts_enable(); }
static void isr_off() { MCUCore::nvic_interrupts_disable(); }
static void delay_ms(const int ms) { DELAY_US(ms * 1000); }
// Watchdog
static void watchdog_init() IF_DISABLED(USE_WATCHDOG, {});
static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
static bool watchdog_timed_out() IF_DISABLED(USE_WATCHDOG, { return false; });
static void watchdog_clear_timeout_flag() IF_DISABLED(USE_WATCHDOG, {});
// Tasks, called from idle()
static void idletask();
// Reset
static uint8_t get_reset_source();
static void clear_reset_source();
// Free SRAM
static int freeMemory() { return ::freeMemory(); }
//
// ADC Methods
//
using FilteredADC = MCUI::ADC<ADC_LOWPASS_K_VALUE, ADC_MEDIAN_FILTER_SIZE>;
// Called by Temperature::init once at startup
static void adc_init() {
// Turn on and initialise ADC in burst mode
MCUI::adc_hardware.init();
MCUI::adc_hardware.burst_start();
}
// Called by Temperature::init for each sensor at startup
static void adc_enable(const pin_t pin) {
FilteredADC::enable_channel(pin);
}
// Begin ADC sampling on the given pin. Called from Temperature::isr!
static uint32_t adc_result;
static void adc_start(const pin_t pin) {
adc_result = FilteredADC::read(pin) >> (16 - HAL_ADC_RESOLUTION); // returns 16bit value, reduce to required bits
}
// Is the ADC ready for reading?
static bool adc_ready() { return true; }
// The current value of the ADC register
static uint16_t adc_value() { return uint16_t(adc_result); }
/**
* Set the PWM duty cycle for the pin to the given value.
* Optionally invert the duty cycle [default = false]
* Optionally change the scale of the provided value to enable finer PWM duty control [default = 255]
*/
static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
/**
* Set the frequency of the timer corresponding to the provided pin
* All Hardware PWM pins will run at the same frequency and
* All Software PWM pins will run at the same frequency
*/
static void set_pwm_frequency(const pin_t pin, const uint16_t f_desired);
};
-354
View File
@@ -1,354 +0,0 @@
// /**
// * Marlin 3D Printer Firmware
// * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
// *
// * Based on Sprinter and grbl.
// * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see <https://www.gnu.org/licenses/>.
// *
// */
// /**
// * Software SPI functions originally from Arduino Sd2Card Library
// * Copyright (c) 2009 by William Greiman
// */
// /**
// * For TARGET_LPC4078
// */
// /**
// * Hardware SPI and Software SPI implementations are included in this file.
// * The hardware SPI runs faster and has higher throughput but is not compatible
// * with some LCD interfaces/adapters.
// *
// * Control of the slave select pin(s) is handled by the calling routines.
// *
// * Some of the LCD interfaces/adapters result in the LCD SPI and the SD card
// * SPI sharing pins. The SCK, MOSI & MISO pins can NOT be set/cleared with
// * WRITE nor digitalWrite when the hardware SPI module within the LPC17xx is
// * active. If any of these pins are shared then the software SPI must be used.
// *
// * A more sophisticated hardware SPI can be found at the following link.
// * This implementation has not been fully debugged.
// * https://github.com/MarlinFirmware/Marlin/tree/071c7a78f27078fd4aee9a3ef365fcf5e143531e
// */
#ifdef TARGET_LPC4078
#include "../../inc/MarlinConfig.h"
#include <SPI.h>
// Hardware SPI and SPIClass
#include "../shared/HAL_SPI.h"
#define LPC_SOFTWARE_SPI
// ------------------------
// Public functions
// ------------------------
#if ENABLED(LPC_SOFTWARE_SPI)
#include "SoftwareSPI.h"
// Software SPI
static uint8_t SPI_speed = SPI_FULL_SPEED;
static uint8_t spiTransfer(uint8_t b) {
return swSpiTransfer(b, SPI_speed, SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN);
}
void spiBegin() {
swSpiBegin(SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN);
}
void spiInit(uint8_t spiRate) {
SPI_speed = swSpiInit(spiRate, SD_SCK_PIN, SD_MOSI_PIN);
}
uint8_t spiRec() { return spiTransfer(0xFF); }
void spiRead(uint8_t*buf, uint16_t nbyte) {
for (int i = 0; i < nbyte; i++)
buf[i] = spiTransfer(0xFF);
}
void spiSend(uint8_t b) { (void)spiTransfer(b); }
void spiSend(const uint8_t *buf, size_t nbyte) {
for (uint16_t i = 0; i < nbyte; i++)
(void)spiTransfer(buf[i]);
}
void spiSendBlock(uint8_t token, const uint8_t *buf) {
(void)spiTransfer(token);
for (uint16_t i = 0; i < 512; i++)
(void)spiTransfer(buf[i]);
}
#else
#ifdef SD_SPI_SPEED
#define INIT_SPI_SPEED SD_SPI_SPEED
#else
#define INIT_SPI_SPEED SPI_FULL_SPEED
#endif
void spiBegin() { spiInit(INIT_SPI_SPEED); } // Set up SCK, MOSI & MISO pins for SSP0
void spiInit(uint8_t spiRate) {
#if SD_MISO_PIN == BOARD_SPI1_MISO_PIN
SPI.setModule(1);
#elif SD_MISO_PIN == BOARD_SPI2_MISO_PIN
SPI.setModule(2);
#endif
SPI.setDataSize(DATA_SIZE_8BIT);
SPI.setDataMode(SPI_MODE0);
SPI.setClock(SPISettings::spiRate2Clock(spiRate));
SPI.begin();
}
static uint8_t doio(uint8_t b) {
return SPI.transfer(b & 0x00FF) & 0x00FF;
}
void spiSend(uint8_t b) { doio(b); }
void spiSend(const uint8_t *buf, size_t nbyte) {
for (uint16_t i = 0; i < nbyte; i++) doio(buf[i]);
}
void spiSend(uint32_t chan, byte b) {}
void spiSend(uint32_t chan, const uint8_t *buf, size_t nbyte) {}
// Read single byte from SPI
uint8_t spiRec() { return doio(0xFF); }
uint8_t spiRec(uint32_t chan) { return 0; }
// Read from SPI into buffer
void spiRead(uint8_t *buf, uint16_t nbyte) {
for (uint16_t i = 0; i < nbyte; i++) buf[i] = doio(0xFF);
}
uint8_t spiTransfer(uint8_t b) { return doio(b); }
// Write from buffer to SPI
void spiSendBlock(uint8_t token, const uint8_t *buf) {
(void)spiTransfer(token);
for (uint16_t i = 0; i < 512; i++)
(void)spiTransfer(buf[i]);
}
// Begin SPI transaction, set clock, bit order, data mode
void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) {
// TODO: Implement this method
}
#endif // LPC_SOFTWARE_SPI
// /**
// * @brief Wait until TXE (tx empty) flag is set and BSY (busy) flag unset.
// */
static inline void waitSpiTxEnd(void *spi_d) {
#warning unimplemented
// while (SSP_GetStatus(spi_d, SSP_STAT_TXFIFO_EMPTY) == RESET) { /* nada */ } // wait until TXE=1
// while (SSP_GetStatus(spi_d, SSP_STAT_BUSY) == SET) { /* nada */ } // wait until BSY=0
}
// // Retain the pin init state of the SPI, to avoid init more than once,
// // even if more instances of SPIClass exist
static bool spiInitialised[BOARD_NR_SPI] = { false };
SPIClass::SPIClass(uint8_t device) {
// // Init things specific to each SPI device
// // clock divider setup is a bit of hack, and needs to be improved at a later date.
#if BOARD_NR_SPI >= 1
_settings[0].device_id = 0;
_settings[0].m_config.pin_miso = BOARD_SPI1_MISO_PIN;
_settings[0].m_config.pin_mosi = BOARD_SPI1_MOSI_PIN;
_settings[0].m_config.pin_sck = BOARD_SPI1_SCK_PIN;
_settings[0].m_config.pin_ssel = BOARD_SPI1_NSS_PIN;
// _settings[0].dataMode = SPI_MODE0;
// _settings[0].dataSize = DATA_SIZE_8BIT;
// _settings[0].clock = SPI_CLOCK_MAX;
// //_settings[0].clockDivider = determine_baud_rate(_settings[0].spi_d, _settings[0].clock);
#endif
#if BOARD_NR_SPI >= 2
_settings[1].device_id = 2;
_settings[1].m_config.pin_miso = BOARD_SPI2_MISO_PIN;
_settings[1].m_config.pin_mosi = BOARD_SPI2_MOSI_PIN;
_settings[1].m_config.pin_sck = BOARD_SPI2_SCK_PIN;
_settings[1].m_config.pin_ssel = BOARD_SPI2_NSS_PIN;
// _settings[1].dataMode = SPI_MODE0;
// _settings[1].dataSize = DATA_SIZE_8BIT;
// _settings[1].clock = SPI_CLOCK_MAX;
// //_settings[1].clockDivider = determine_baud_rate(_settings[1].spi_d, _settings[1].clock);
#endif
setModule(device);
// // Init the GPDMA controller
// // TODO: call once in the constructor? or each time?
// GPDMA_Init();
}
SPIClass::SPIClass(pin_t mosi, pin_t miso, pin_t sclk, pin_t ssel) {
#if BOARD_NR_SPI >= 1
if (mosi == BOARD_SPI1_MOSI_PIN) SPIClass(1);
#endif
#if BOARD_NR_SPI >= 2
if (mosi == BOARD_SPI2_MOSI_PIN) SPIClass(2);
#endif
}
void SPIClass::begin() {
// // Init the SPI pins in the first begin call
if ((_currentSetting->device_id == 0 && spiInitialised[0] == false) ||
(_currentSetting->device_id == 1 && spiInitialised[1] == false) ||
(_currentSetting->device_id == 2 && spiInitialised[2] == false)) {
MCUI::SSP::init(_currentSetting->device_id, _currentSetting->m_config);
spiInitialised[_currentSetting->device_id] = true;
}
updateSettings();
}
void SPIClass::beginTransaction(const SPISettings &cfg) {
setBitOrder(cfg.bitOrder);
setDataMode(cfg.dataMode);
setDataSize(cfg.dataSize);
//setClockDivider(determine_baud_rate(_currentSetting->spi_d, settings.clock));
begin();
}
uint8_t SPIClass::transfer(const uint16_t b) {
uint16_t rx_word = 0;
// clear rx fifo
while(MCUI::SSP::read(_currentSetting->device_id, &rx_word) == 1);
MCUI::SSP::write(_currentSetting->device_id, b);
while(MCUI::SSP::read(_currentSetting->device_id, &rx_word) != 1);
return rx_word;
}
uint16_t SPIClass::transfer16(const uint16_t data) {
return (transfer((data >> 8) & 0xFF) << 8) | (transfer(data & 0xFF) & 0xFF);
}
void SPIClass::end() {
// // Neither is needed for Marlin
// //SSP_Cmd(_currentSetting->spi_d, DISABLE);
// //SSP_DeInit(_currentSetting->spi_d);
}
void SPIClass::send(uint8_t data) {
MCUI::SSP::write(_currentSetting->device_id, data);
}
void SPIClass::dmaSend(void *buf, uint16_t length, bool minc) {
// //TODO: LPC dma can only write 0xFFF bytes at once.
// GPDMA_Channel_CFG_Type GPDMACfg;
// /* Configure GPDMA channel 0 -------------------------------------------------------------*/
// /* DMA Channel 0 */
// GPDMACfg.ChannelNum = 0;
// // Source memory
// GPDMACfg.SrcMemAddr = (uint32_t)buf;
// // Destination memory - Not used
// GPDMACfg.DstMemAddr = 0;
// // Transfer size
// GPDMACfg.TransferSize = length;
// // Transfer width
// GPDMACfg.TransferWidth = (_currentSetting->dataSize == DATA_SIZE_16BIT) ? GPDMA_WIDTH_HALFWORD : GPDMA_WIDTH_BYTE;
// // Transfer type
// GPDMACfg.TransferType = GPDMA_TRANSFERTYPE_M2P;
// // Source connection - unused
// GPDMACfg.SrcConn = 0;
// // Destination connection
// GPDMACfg.DstConn = (_currentSetting->spi_d == LPC_SSP0) ? GPDMA_CONN_SSP0_Tx : GPDMA_CONN_SSP1_Tx;
// GPDMACfg.DMALLI = 0;
// // Enable dma on SPI
// SSP_DMACmd(_currentSetting->spi_d, SSP_DMA_TX, ENABLE);
// // Only increase memory if minc is true
// GPDMACfg.MemoryIncrease = (minc ? GPDMA_DMACCxControl_SI : 0);
// // Setup channel with given parameter
// GPDMA_Setup(&GPDMACfg);
// // Enable DMA
// GPDMA_ChannelCmd(0, ENABLE);
// // Wait for data transfer
// while (!GPDMA_IntGetStatus(GPDMA_STAT_RAWINTTC, 0) && !GPDMA_IntGetStatus(GPDMA_STAT_RAWINTERR, 0)) { }
// // Clear err and int
// GPDMA_ClearIntPending (GPDMA_STATCLR_INTTC, 0);
// GPDMA_ClearIntPending (GPDMA_STATCLR_INTERR, 0);
// // Disable DMA
// GPDMA_ChannelCmd(0, DISABLE);
// waitSpiTxEnd(_currentSetting->spi_d);
// SSP_DMACmd(_currentSetting->spi_d, SSP_DMA_TX, DISABLE);
}
uint16_t SPIClass::read() {
uint16_t rx_word = 0;
MCUI::SSP::read(_currentSetting->device_id, &rx_word);
return rx_word;
}
void SPIClass::read(uint8_t *buf, uint32_t len) {
uint16_t rx_word = 0;
// clear rx fifo
while(MCUI::SSP::read(_currentSetting->device_id, &rx_word) == 1);
for (uint16_t i = 0; i < len; i++) {
MCUI::SSP::write(_currentSetting->device_id, 0xFF);
while(MCUI::SSP::read(_currentSetting->device_id, &rx_word) != 1);
buf[i] = rx_word;
}
}
void SPIClass::setClock(uint32_t clock) { _currentSetting->clock = clock; }
void SPIClass::setModule(uint8_t device) { _currentSetting = &_settings[device - 1]; } // SPI channels are called 1, 2, and 3 but the array is zero-indexed
void SPIClass::setBitOrder(uint8_t bitOrder) { _currentSetting->bitOrder = bitOrder; }
void SPIClass::setDataMode(uint8_t dataMode) { _currentSetting->dataMode = dataMode; }
void SPIClass::setDataSize(uint32_t dataSize) { _currentSetting->dataSize = dataSize; }
// /**
// * Set up/tear down
// */
void SPIClass::updateSettings() { }
SPIClass SPI(1);
#if SD_MISO_PIN == BOARD_SPI1_MISO_PIN
SPIClass SPI(1);
#elif SD_MISO_PIN == BOARD_SPI2_MISO_PIN
SPIClass SPI(2);
#endif
#endif // TARGET_LPC4078
-78
View File
@@ -1,78 +0,0 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#ifdef TARGET_LPC4078
#include "MarlinSerial.h"
#include "../../inc/MarlinConfig.h"
MarlinCDCSerial MCDCSerial0;
#define MarlinSerial(ID) \
MarlinSerial _MSerial##ID(ID); \
MSerialT MSerial##ID(true, _MSerial##ID)
#if USING_HW_SERIAL0
MarlinSerial(0);
#endif
#if USING_HW_SERIAL1
MarlinSerial(1);
#endif
#if USING_HW_SERIAL2
MarlinSerial(2);
#endif
#if USING_HW_SERIAL3
MarlinSerial(3);
#endif
#if ENABLED(EMERGENCY_PARSER)
bool MarlinSerial::recv_callback(const char c) {
// Need to figure out which serial port we are and react in consequence (Marlin does not have CONTAINER_OF macro)
if (false) {}
#if USING_HW_SERIAL0
else if (this == &_MSerial0) emergency_parser.update(MSerial0.emergency_state, c);
#endif
#if USING_HW_SERIAL1
else if (this == &_MSerial1) emergency_parser.update(MSerial1.emergency_state, c);
#endif
#if USING_HW_SERIAL2
else if (this == &_MSerial2) emergency_parser.update(MSerial2.emergency_state, c);
#endif
#if USING_HW_SERIAL3
else if (this == &_MSerial3) emergency_parser.update(MSerial3.emergency_state, c);
#endif
return true;
}
#include "../../feature/e_parser.h"
EmergencyParser::State emergency_state;
bool CDC_RecvCallback(const char c) {
emergency_parser.update(emergency_state, c);
return true;
}
#endif
#endif // TARGET_LPC4078
-108
View File
@@ -1,108 +0,0 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include <mcu_interface.h>
#include <interface/uart.h>
#include <driver/usb_cdc.h>
#include <UART.h>
#include "../../inc/MarlinConfigPre.h"
#if ENABLED(EMERGENCY_PARSER)
#include "../../feature/e_parser.h"
#endif
#include "../../core/serial_hook.h"
#ifndef SERIAL_PORT
#define SERIAL_PORT 0
#endif
#ifndef RX_BUFFER_SIZE
#define RX_BUFFER_SIZE 128
#endif
#ifndef TX_BUFFER_SIZE
#define TX_BUFFER_SIZE 32
#endif
class MarlinCDCSerial : public HardwareSerial {
public:
MarlinCDCSerial() {}
void begin(unsigned long baudrate) override {}
void begin(unsigned long baudrate, uint16_t config) override { }
void end() override { }
int available() override {
return MCUI::CDCSerial0::available();
}
int peek() override { char c = 0; return MCUI::CDCSerial0::peek((uint8_t*)&c)? c : -1; }
int read() override { char c = 0; return MCUI::CDCSerial0::read((uint8_t*)&c, 1)? c : -1; }
void flush() override {};
size_t write(uint8_t c) override { return write(&c, 1); }
size_t write(const uint8_t *buffer, size_t size) override { return MCUI::CDCSerial0::connected() ? MCUI::CDCSerial0::write(buffer, size) : 0; }
using Print::write;
operator bool() override { return true; }
};
extern MarlinCDCSerial MCDCSerial0;
class MarlinSerial : public HardwareSerial {
public:
MarlinSerial(const uint32_t uart_id) : uart_device(uart_id) {}
void begin(unsigned long baudrate) override {
uart_device.configure_pins(P0_02, P0_03);
uart_device.init({ .baud = baudrate });
#if ENABLED(EMERGENCY_PARSER)
uart_device.set_rx_callback([this](char rx_value){ return this->recv_callback(rx_value); } );
#endif
}
void begin(unsigned long baudrate, uint16_t config) override {
begin(baudrate);
}
void end() override { }
int available() override {
return uart_device.rx_available();
}
int peek() override { char c = 0; return uart_device.peek(&c)? c : -1; }
int read() override { char c = 0; return uart_device.read(&c)? c : -1; }
void flush() override {};
size_t write(uint8_t c) override { return write(&c, 1); }
size_t write(const uint8_t *buffer, size_t size) override { return uart_device.write((const char *)buffer, size); }
using Print::write; // pull in write(str) and write(buf, size) from Print
operator bool() override { return true; }
bool recv_callback(char value);
private:
MCUI::BufferedUARTC uart_device;
};
// On LPC176x framework, HardwareSerial does not implement the same interface as Arduino's Serial, so overloads
// of 'available' and 'read' method are not used in this multiple inheritance scenario.
// Instead, use a ForwardSerial here that adapts the interface.
typedef ForwardSerial1Class<MarlinSerial> MSerialT;
extern MSerialT MSerial0;
extern MSerialT MSerial1;
extern MSerialT MSerial2;
extern MSerialT MSerial3;
// Consequently, we can't use a RuntimeSerial either. The workaround would be to use
// a RuntimeSerial<ForwardSerial<MarlinSerial>> type here. Ignore for now until it's actually required.
#if ENABLED(SERIAL_RUNTIME_HOOK)
#error "SERIAL_RUNTIME_HOOK is not yet supported for LPC176x."
#endif
-51
View File
@@ -1,51 +0,0 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#ifdef TARGET_LPC4078
#include "../../inc/MarlinConfig.h"
#include "HAL.h"
#if ENABLED(POSTMORTEM_DEBUGGING)
#include "../shared/MinSerial.h"
#include <debug_frmwrk.h>
static void TX(char c) { _DBC(c); }
void install_min_serial() { HAL_min_serial_out = &TX; }
#if DISABLED(DYNAMIC_VECTORTABLE)
extern "C" {
__attribute__((naked)) void JumpHandler_ASM() {
__asm__ __volatile__ (
"b CommonHandler_ASM\n"
);
}
void __attribute__((naked, alias("JumpHandler_ASM"))) HardFault_Handler();
void __attribute__((naked, alias("JumpHandler_ASM"))) BusFault_Handler();
void __attribute__((naked, alias("JumpHandler_ASM"))) UsageFault_Handler();
void __attribute__((naked, alias("JumpHandler_ASM"))) MemManage_Handler();
void __attribute__((naked, alias("JumpHandler_ASM"))) NMI_Handler();
}
#endif
#endif // POSTMORTEM_DEBUGGING
#endif // TARGET_LPC4078
-47
View File
@@ -1,47 +0,0 @@
#ifdef TARGET_LPC4078
#include <Arduino.h>
#include "SoftwareSPI.h"
#include <mcu_interface.h>
uint8_t swSpiTransfer(uint8_t b, const uint8_t spi_speed, const pin_t sck_pin, const pin_t miso_pin, const pin_t mosi_pin) {
for (uint8_t i = 0; i < 8; i++) {
if (spi_speed == 0) {
MCUI::gpio_set(mosi_pin, !!(b & 0x80));
MCUI::gpio_set(sck_pin, HIGH);
b <<= 1;
if (miso_pin >= 0 && MCUI::gpio_get(miso_pin)) b |= 1;
MCUI::gpio_set(sck_pin, LOW);
}
else {
const uint8_t state = (b & 0x80) ? HIGH : LOW;
for (uint8_t j = 0; j < spi_speed; j++)
MCUI::gpio_set(mosi_pin, state);
for (uint8_t j = 0; j < spi_speed + (miso_pin >= 0 ? 0 : 1); j++)
MCUI::gpio_set(sck_pin, HIGH);
b <<= 1;
if (miso_pin >= 0 && MCUI::gpio_get(miso_pin)) b |= 1;
for (uint8_t j = 0; j < spi_speed; j++)
MCUI::gpio_set(sck_pin, LOW);
}
}
return b;
}
void swSpiBegin(const pin_t sck_pin, const pin_t miso_pin, const pin_t mosi_pin) {
pinMode(sck_pin, OUTPUT);
if (MCUI::pin_is_valid(miso_pin)) pinMode(miso_pin, INPUT);
pinMode(mosi_pin, OUTPUT);
}
uint8_t swSpiInit(const uint8_t spiRate, const pin_t sck_pin, const pin_t mosi_pin) {
MCUI::gpio_set(mosi_pin, HIGH);
MCUI::gpio_set(sck_pin, LOW);
return (SystemCoreClock == 120000000 ? 44 : 38) / std::pow(2, 6 - std::min(spiRate, (uint8_t)6));
}
#endif // TARGET_LPC4078
-5
View File
@@ -1,5 +0,0 @@
#include <mcu_interface.h>
uint8_t swSpiTransfer(uint8_t b, const uint8_t spi_speed, const pin_t sck_pin, const pin_t miso_pin, const pin_t mosi_pin);
void swSpiBegin(const pin_t sck_pin, const pin_t miso_pin, const pin_t mosi_pin);
uint8_t swSpiInit(const uint8_t spiRate, const pin_t sck_pin, const pin_t mosi_pin);
-116
View File
@@ -1,116 +0,0 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#ifdef TARGET_LPC4078
/**
* Emulate EEPROM storage using Flash Memory
*
* Use a single 32K flash sector to store EEPROM data. To reduce the
* number of erase operations a simple "leveling" scheme is used that
* maintains a number of EEPROM "slots" within the larger flash sector.
* Each slot is used in turn and the entire sector is only erased when all
* slots have been used.
*
* A simple RAM image is used to hold the EEPROM data during I/O operations
* and this is flushed to the next available slot when an update is complete.
* If RAM usage becomes an issue we could store this image in one of the two
* 16Kb I/O buffers (intended to hold DMA USB and Ethernet data, but currently
* unused).
*/
#include "../../inc/MarlinConfig.h"
#include "../shared/eeprom_api.h"
//#include <cstdio>
#ifndef MARLIN_EEPROM_SIZE
#define MARLIN_EEPROM_SIZE 4032 // 4KB
#endif
size_t PersistentStore::capacity() { return 4032; }
constexpr uint32_t page_size = MCUI::EEPROM::page_size;
uint32_t buffered_page = 0;
uint8_t page_buffer[page_size];
bool buffered_page_dirty = false;
bool PersistentStore::access_start() {
MCUI::EEPROM::init();
MCUI::EEPROM::read_page(buffered_page, page_buffer, page_size);
return true;
}
bool PersistentStore::access_finish() {
if (buffered_page_dirty) {
MCUI::EEPROM::write_page(buffered_page, page_buffer, page_size);
}
return true;
}
bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
uint32_t address = pos;
//printf("Marlin::eeprom::write(pos = %d, size = %d)\n", pos, size);
uint32_t value_index = 0;
for (uint32_t addr = address; addr < address + size; ++addr) {
uint32_t page_address = addr & 0xFFFFFFC0;
if (page_address != buffered_page) {
//printf("Marlin::eeprom::write(@%ld):: page change new(%ld) != current(%d)\n",addr, page_address, buffered_page);
if (buffered_page_dirty == true) MCUI::EEPROM::write_page(buffered_page, page_buffer, page_size);
buffered_page = page_address;
buffered_page_dirty = false;
MCUI::EEPROM::read_page(buffered_page, page_buffer, page_size);
}
page_buffer[addr & ~0xFFFFFFC0] = value[value_index++];
buffered_page_dirty = true;
}
pos += size;
crc16(crc, value, size);
return false; // return true for any error
}
bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
uint32_t address = pos;
//printf("Marlin::eeprom::read(pos = %d, size = %d, writing = %d)\n", pos, size, writing);
uint32_t value_index = 0;
for (uint32_t addr = address; addr < address + size; ++addr) {
uint32_t page_address = addr & 0xFFFFFFC0;
if (page_address != buffered_page) {
if (buffered_page_dirty) {
MCUI::EEPROM::write_page(buffered_page, page_buffer, page_size);
buffered_page_dirty = false;
}
buffered_page = page_address;
MCUI::EEPROM::read_page(buffered_page, page_buffer, page_size);
}
if (writing) value[value_index++] = page_buffer[addr & ~0xFFFFFFC0];
else crc16(crc, &page_buffer[addr & ~0xFFFFFFC0], 1);
}
if (writing) crc16(crc, value, size);
pos += size;
return false; // return true for any error
}
#endif // TARGET_LPC4078
-191
View File
@@ -1,191 +0,0 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* Endstop Interrupts
*
* Without endstop interrupts the endstop pins must be polled continually in
* the temperature-ISR via endstops.update(), most of the time finding no change.
* With this feature endstops.update() is called only when we know that at
* least one endstop has changed state, saving valuable CPU cycles.
*
* This feature only works when all used endstop pins can generate an 'external interrupt'.
*
* Test whether pins issue interrupts on your board by flashing 'pin_interrupt_test.ino'.
* (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino)
*/
#include "../../module/endstops.h"
// One ISR for all EXT-Interrupts
void endstop_ISR() { endstops.update(); }
void setup_endstop_interrupts() {
#define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
#define LPC1768_PIN_INTERRUPT_M(pin) ((pin >> 0x5 & 0x7) == 0 || (pin >> 0x5 & 0x7) == 2)
#if HAS_X_MAX
#if !LPC1768_PIN_INTERRUPT_M(X_MAX_PIN)
#error "X_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(X_MAX_PIN);
#endif
#if HAS_X_MIN
#if !LPC1768_PIN_INTERRUPT_M(X_MIN_PIN)
#error "X_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(X_MIN_PIN);
#endif
#if HAS_Y_MAX
#if !LPC1768_PIN_INTERRUPT_M(Y_MAX_PIN)
#error "Y_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Y_MAX_PIN);
#endif
#if HAS_Y_MIN
#if !LPC1768_PIN_INTERRUPT_M(Y_MIN_PIN)
#error "Y_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Y_MIN_PIN);
#endif
#if HAS_Z_MAX
#if !LPC1768_PIN_INTERRUPT_M(Z_MAX_PIN)
#error "Z_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z_MAX_PIN);
#endif
#if HAS_Z_MIN
#if !LPC1768_PIN_INTERRUPT_M(Z_MIN_PIN)
#error "Z_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z_MIN_PIN);
#endif
#if HAS_Z2_MAX
#if !LPC1768_PIN_INTERRUPT_M(Z2_MAX_PIN)
#error "Z2_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z2_MAX_PIN);
#endif
#if HAS_Z2_MIN
#if !LPC1768_PIN_INTERRUPT_M(Z2_MIN_PIN)
#error "Z2_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z2_MIN_PIN);
#endif
#if HAS_Z3_MAX
#if !LPC1768_PIN_INTERRUPT_M(Z3_MAX_PIN)
#error "Z3_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z3_MAX_PIN);
#endif
#if HAS_Z3_MIN
#if !LPC1768_PIN_INTERRUPT_M(Z3_MIN_PIN)
#error "Z3_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z3_MIN_PIN);
#endif
#if HAS_Z4_MAX
#if !LPC1768_PIN_INTERRUPT_M(Z4_MAX_PIN)
#error "Z4_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z4_MAX_PIN);
#endif
#if HAS_Z4_MIN
#if !LPC1768_PIN_INTERRUPT_M(Z4_MIN_PIN)
#error "Z4_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z4_MIN_PIN);
#endif
#if HAS_Z_MIN_PROBE_PIN
#if !LPC1768_PIN_INTERRUPT_M(Z_MIN_PROBE_PIN)
#error "Z_MIN_PROBE_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
_ATTACH(Z_MIN_PROBE_PIN);
#endif
#if HAS_I_MAX
#if !LPC1768_PIN_INTERRUPT_M(I_MAX_PIN)
#error "I_MAX_PIN is not INTERRUPT-capable."
#endif
_ATTACH(I_MAX_PIN);
#elif HAS_I_MIN
#if !LPC1768_PIN_INTERRUPT_M(I_MIN_PIN)
#error "I_MIN_PIN is not INTERRUPT-capable."
#endif
_ATTACH(I_MIN_PIN);
#endif
#if HAS_J_MAX
#if !LPC1768_PIN_INTERRUPT_M(J_MAX_PIN)
#error "J_MAX_PIN is not INTERRUPT-capable."
#endif
_ATTACH(J_MAX_PIN);
#elif HAS_J_MIN
#if !LPC1768_PIN_INTERRUPT_M(J_MIN_PIN)
#error "J_MIN_PIN is not INTERRUPT-capable."
#endif
_ATTACH(J_MIN_PIN);
#endif
#if HAS_K_MAX
#if !LPC1768_PIN_INTERRUPT_M(K_MAX_PIN)
#error "K_MAX_PIN is not INTERRUPT-capable."
#endif
_ATTACH(K_MAX_PIN);
#elif HAS_K_MIN
#if !LPC1768_PIN_INTERRUPT_M(K_MIN_PIN)
#error "K_MIN_PIN is not INTERRUPT-capable."
#endif
_ATTACH(K_MIN_PIN);
#endif
#if HAS_U_MAX
#if !LPC1768_PIN_INTERRUPT_M(U_MAX_PIN)
#error "U_MAX_PIN is not INTERRUPT-capable."
#endif
_ATTACH(U_MAX_PIN);
#elif HAS_U_MIN
#if !LPC1768_PIN_INTERRUPT_M(U_MIN_PIN)
#error "U_MIN_PIN is not INTERRUPT-capable."
#endif
_ATTACH(U_MIN_PIN);
#endif
#if HAS_V_MAX
#if !LPC1768_PIN_INTERRUPT_M(V_MAX_PIN)
#error "V_MAX_PIN is not INTERRUPT-capable."
#endif
_ATTACH(V_MAX_PIN);
#elif HAS_V_MIN
#if !LPC1768_PIN_INTERRUPT_M(V_MIN_PIN)
#error "V_MIN_PIN is not INTERRUPT-capable."
#endif
_ATTACH(V_MIN_PIN);
#endif
#if HAS_W_MAX
#if !LPC1768_PIN_INTERRUPT_M(W_MAX_PIN)
#error "W_MAX_PIN is not INTERRUPT-capable."
#endif
_ATTACH(W_MAX_PIN);
#elif HAS_W_MIN
#if !LPC1768_PIN_INTERRUPT_M(W_MIN_PIN)
#error "W_MIN_PIN is not INTERRUPT-capable."
#endif
_ATTACH(W_MIN_PIN);
#endif
}
-120
View File
@@ -1,120 +0,0 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* Fast I/O Routines for LPC1768/9
* Use direct port manipulation to save scads of processor time.
* Contributed by Triffid_Hunter and modified by Kliment, thinkyhead, Bob-the-Kuhn, et.al.
*/
/**
* Description: Fast IO functions LPC1768
*
* For TARGET LPC1768
*/
#include "../shared/Marduino.h"
#include <mcu_interface.h>
#define PWM_PIN(P) true // all pins are software PWM capable
#define LPC_PIN(pin) MCUI::gpio_pin(pin)
#define LPC_GPIO(port) MCUI::gpio_port(port)
#define SET_DIR_INPUT(IO) MCUI::gpio_set_input(IO)
#define SET_DIR_OUTPUT(IO) MCUI::gpio_set_output(IO)
#define SET_MODE(IO, mode) pinMode(IO, mode)
#define WRITE_PIN_SET(IO) MCUI::gpio_set(IO)
#define WRITE_PIN_CLR(IO) MCUI::gpio_clear(IO)
#define READ_PIN(IO) MCUI::gpio_get(IO)
#define WRITE_PIN(IO,V) MCUI::gpio_set(IO, V)
/**
* Magic I/O routines
*
* Now you can simply SET_OUTPUT(STEP); WRITE(STEP, HIGH); WRITE(STEP, LOW);
*
* Why double up on these macros? see https://gcc.gnu.org/onlinedocs/gcc-4.8.5/cpp/Stringification.html
*/
/// Read a pin
#define _READ(IO) READ_PIN(IO)
/// Write to a pin
#define _WRITE(IO,V) WRITE_PIN(IO,V)
/// toggle a pin
#define _TOGGLE(IO) MCUI::gpio_toggle(IO)
/// set pin as input
#define _SET_INPUT(IO) SET_DIR_INPUT(IO)
/// set pin as output
#define _SET_OUTPUT(IO) SET_DIR_OUTPUT(IO)
/// set pin as input with pullup mode
#define _PULLUP(IO,V) pinMode(IO, (V) ? INPUT_PULLUP : INPUT)
/// set pin as input with pulldown mode
#define _PULLDOWN(IO,V) pinMode(IO, (V) ? INPUT_PULLDOWN : INPUT)
/// check if pin is an input
#define _IS_INPUT(IO) (!MCUI::gpio_get_dir(IO))
/// check if pin is an output
#define _IS_OUTPUT(IO) (MCUI::gpio_get_dir(IO))
/// Read a pin wrapper
#define READ(IO) _READ(IO)
/// Write to a pin wrapper
#define WRITE(IO,V) _WRITE(IO,V)
/// toggle a pin wrapper
#define TOGGLE(IO) _TOGGLE(IO)
/// set pin as input wrapper
#define SET_INPUT(IO) _SET_INPUT(IO)
/// set pin as input with pullup wrapper
#define SET_INPUT_PULLUP(IO) do{ _SET_INPUT(IO); _PULLUP(IO, HIGH); }while(0)
/// set pin as input with pulldown wrapper
#define SET_INPUT_PULLDOWN(IO) do{ _SET_INPUT(IO); _PULLDOWN(IO, HIGH); }while(0)
/// set pin as output wrapper - reads the pin and sets the output to that value
#define SET_OUTPUT(IO) do{ _WRITE(IO, _READ(IO)); _SET_OUTPUT(IO); }while(0)
// set pin as PWM
#define SET_PWM SET_OUTPUT
/// check if pin is an input wrapper
#define IS_INPUT(IO) _IS_INPUT(IO)
/// check if pin is an output wrapper
#define IS_OUTPUT(IO) _IS_OUTPUT(IO)
// Shorthand
#define OUT_WRITE(IO,V) do{ SET_OUTPUT(IO); WRITE(IO,V); }while(0)
// digitalRead/Write wrappers
#define extDigitalRead(IO) digitalRead(IO)
#define extDigitalWrite(IO,V) digitalWrite(IO,V)
-276
View File
@@ -1,276 +0,0 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#pragma once
// #if PIO_PLATFORM_VERSION < 1001
// #error "nxplpc-arduino-lpc176x package is out of date, Please update the PlatformIO platforms, frameworks and libraries. You may need to remove the platform and let it reinstall automatically."
// #endif
// #if PIO_FRAMEWORK_VERSION < 2006
// #error "framework-arduino-lpc176x package is out of date, Please update the PlatformIO platforms, frameworks and libraries."
// #endif
/**
* Detect an old pins file by checking for old ADC pins values.
*/
#define _OLD_TEMP_PIN(P) PIN_EXISTS(P) && _CAT(P,_PIN) <= 7 && !WITHIN(_CAT(P,_PIN), TERN(LPC1768_IS_SKRV1_3, 0, 2), 3) // Include P0_00 and P0_01 for SKR V1.3 board
#if _OLD_TEMP_PIN(TEMP_BED)
#error "TEMP_BED_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#elif _OLD_TEMP_PIN(TEMP_0)
#error "TEMP_0_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#elif _OLD_TEMP_PIN(TEMP_1)
#error "TEMP_1_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#elif _OLD_TEMP_PIN(TEMP_2)
#error "TEMP_2_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#elif _OLD_TEMP_PIN(TEMP_3)
#error "TEMP_3_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#elif _OLD_TEMP_PIN(TEMP_4)
#error "TEMP_4_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#elif _OLD_TEMP_PIN(TEMP_5)
#error "TEMP_5_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#elif _OLD_TEMP_PIN(TEMP_6)
#error "TEMP_6_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#elif _OLD_TEMP_PIN(TEMP_7)
#error "TEMP_7_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
#endif
#undef _OLD_TEMP_PIN
/**
* Because PWM hardware channels all share the same frequency, along with the
* fallback software channels, FAST_PWM_FAN is incompatible with Servos.
*/
static_assert(!(NUM_SERVOS && ENABLED(FAST_PWM_FAN)), "BLTOUCH and Servos are incompatible with FAST_PWM_FAN on LPC176x boards.");
#if SPINDLE_LASER_FREQUENCY
static_assert(!NUM_SERVOS, "BLTOUCH and Servos are incompatible with SPINDLE_LASER_FREQUENCY on LPC176x boards.");
#endif
/**
* Test LPC176x-specific configuration values for errors at compile-time.
*/
//#if ENABLED(SPINDLE_LASER_USE_PWM) && !(SPINDLE_LASER_PWM_PIN == 4 || SPINDLE_LASER_PWM_PIN == 6 || SPINDLE_LASER_PWM_PIN == 11)
// #error "SPINDLE_LASER_PWM_PIN must use SERVO0, SERVO1 or SERVO3 connector"
//#endif
#if MB(RAMPS_14_RE_ARM_EFB, RAMPS_14_RE_ARM_EEB, RAMPS_14_RE_ARM_EFF, RAMPS_14_RE_ARM_EEF, RAMPS_14_RE_ARM_SF)
#if IS_RRD_FG_SC && HAS_DRIVER(TMC2130) && DISABLED(TMC_USE_SW_SPI)
#error "Re-ARM with REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER and TMC2130 requires TMC_USE_SW_SPI."
#endif
#endif
static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported on LPC176x.");
/**
* Flag any serial port conflicts
*
* Port | TX | RX |
* --- | --- | --- |
* Serial | P0_02 | P0_03 |
* Serial1 | P0_15 | P0_16 |
* Serial2 | P0_10 | P0_11 |
* Serial3 | P0_00 | P0_01 |
*/
#define ANY_TX(N,V...) DO(IS_TX##N,||,V)
#define ANY_RX(N,V...) DO(IS_RX##N,||,V)
#if USING_HW_SERIAL0
#define IS_TX0(P) (P == P0_02)
#define IS_RX0(P) (P == P0_03)
#if IS_TX0(TMC_SW_MISO) || IS_RX0(TMC_SW_MOSI)
#error "Serial port pins (0) conflict with Trinamic SPI pins!"
#elif HAS_PRUSA_MMU1 && (IS_TX0(E_MUX1_PIN) || IS_RX0(E_MUX0_PIN))
#error "Serial port pins (0) conflict with Multi-Material-Unit multiplexer pins!"
#elif (AXIS_HAS_SPI(X) && IS_TX0(X_CS_PIN)) || (AXIS_HAS_SPI(Y) && IS_RX0(Y_CS_PIN))
#error "Serial port pins (0) conflict with X/Y axis SPI pins!"
#endif
#undef IS_TX0
#undef IS_RX0
#endif
#if USING_HW_SERIAL1
#define IS_TX1(P) (P == P0_15)
#define IS_RX1(P) (P == P0_16)
#define _IS_TX1_1 IS_TX1
#define _IS_RX1_1 IS_RX1
#if IS_TX1(TMC_SW_SCK)
#error "Serial port pins (1) conflict with other pins!"
#elif HAS_ROTARY_ENCODER
#if IS_TX1(BTN_EN2) || IS_RX1(BTN_EN1)
#error "Serial port pins (1) conflict with Encoder Buttons!"
#elif ANY_TX(1, SD_SCK_PIN, LCD_PINS_D4, DOGLCD_SCK, LCD_RESET_PIN, LCD_PINS_RS, SHIFT_CLK_PIN) \
|| ANY_RX(1, LCD_SDSS, LCD_PINS_RS, SD_MISO_PIN, DOGLCD_A0, SD_SS_PIN, LCD_SDSS, DOGLCD_CS, LCD_RESET_PIN, LCD_BACKLIGHT_PIN)
#error "Serial port pins (1) conflict with LCD pins!"
#endif
#endif
#undef IS_TX1
#undef IS_RX1
#undef _IS_TX1_1
#undef _IS_RX1_1
#endif
#if USING_HW_SERIAL2
#define IS_TX2(P) (P == P0_10)
#define IS_RX2(P) (P == P0_11)
#define _IS_TX2_1 IS_TX2
#define _IS_RX2_1 IS_RX2
#if IS_TX2(X2_ENABLE_PIN) || ANY_RX(2, X2_DIR_PIN, X2_STEP_PIN) || (AXIS_HAS_SPI(X2) && IS_TX2(X2_CS_PIN))
#error "Serial port pins (2) conflict with X2 pins!"
#elif IS_TX2(Y2_ENABLE_PIN) || ANY_RX(2, Y2_DIR_PIN, Y2_STEP_PIN) || (AXIS_HAS_SPI(Y2) && IS_TX2(Y2_CS_PIN))
#error "Serial port pins (2) conflict with Y2 pins!"
#elif IS_TX2(Z2_ENABLE_PIN) || ANY_RX(2, Z2_DIR_PIN, Z2_STEP_PIN) || (AXIS_HAS_SPI(Z2) && IS_TX2(Z2_CS_PIN))
#error "Serial port pins (2) conflict with Z2 pins!"
#elif IS_TX2(Z3_ENABLE_PIN) || ANY_RX(2, Z3_DIR_PIN, Z3_STEP_PIN) || (AXIS_HAS_SPI(Z3) && IS_TX2(Z3_CS_PIN))
#error "Serial port pins (2) conflict with Z3 pins!"
#elif IS_TX2(Z4_ENABLE_PIN) || ANY_RX(2, Z4_DIR_PIN, Z4_STEP_PIN) || (AXIS_HAS_SPI(Z4) && IS_TX2(Z4_CS_PIN))
#error "Serial port pins (2) conflict with Z4 pins!"
#elif ANY_RX(2, X_DIR_PIN, Y_DIR_PIN)
#error "Serial port pins (2) conflict with other pins!"
#elif Y_HOME_TO_MIN && IS_TX2(Y_STOP_PIN)
#error "Serial port pins (2) conflict with Y endstop pin!"
#elif USES_Z_MIN_PROBE_PIN && IS_TX2(Z_MIN_PROBE_PIN)
#error "Serial port pins (2) conflict with probe pin!"
#elif ANY_TX(2, X_ENABLE_PIN, Y_ENABLE_PIN) || ANY_RX(2, X_DIR_PIN, Y_DIR_PIN)
#error "Serial port pins (2) conflict with X/Y stepper pins!"
#elif HAS_MULTI_EXTRUDER && (IS_TX2(E1_ENABLE_PIN) || (AXIS_HAS_SPI(E1) && IS_TX2(E1_CS_PIN)))
#error "Serial port pins (2) conflict with E1 stepper pins!"
#elif EXTRUDERS && ANY_RX(2, E0_DIR_PIN, E0_STEP_PIN)
#error "Serial port pins (2) conflict with E stepper pins!"
#endif
#undef IS_TX2
#undef IS_RX2
#undef _IS_TX2_1
#undef _IS_RX2_1
#endif
#if USING_HW_SERIAL3
#define PIN_IS_TX3(P) (PIN_EXISTS(P) && P##_PIN == P0_00)
#define PIN_IS_RX3(P) (P##_PIN == P0_01)
#if PIN_IS_TX3(X_MIN) || PIN_IS_RX3(X_MAX)
#error "Serial port pins (3) conflict with X endstop pins!"
#elif PIN_IS_TX3(Y_SERIAL_TX) || PIN_IS_TX3(Y_SERIAL_RX) || PIN_IS_RX3(X_SERIAL_TX) || PIN_IS_RX3(X_SERIAL_RX)
#error "Serial port pins (3) conflict with X/Y axis UART pins!"
#elif PIN_IS_TX3(X2_DIR) || PIN_IS_RX3(X2_STEP)
#error "Serial port pins (3) conflict with X2 pins!"
#elif PIN_IS_TX3(Y2_DIR) || PIN_IS_RX3(Y2_STEP)
#error "Serial port pins (3) conflict with Y2 pins!"
#elif PIN_IS_TX3(Z2_DIR) || PIN_IS_RX3(Z2_STEP)
#error "Serial port pins (3) conflict with Z2 pins!"
#elif PIN_IS_TX3(Z3_DIR) || PIN_IS_RX3(Z3_STEP)
#error "Serial port pins (3) conflict with Z3 pins!"
#elif PIN_IS_TX3(Z4_DIR) || PIN_IS_RX3(Z4_STEP)
#error "Serial port pins (3) conflict with Z4 pins!"
#elif HAS_MULTI_EXTRUDER && (PIN_IS_TX3(E1_DIR) || PIN_IS_RX3(E1_STEP))
#error "Serial port pins (3) conflict with E1 pins!"
#endif
#undef PIN_IS_TX3
#undef PIN_IS_RX3
#endif
#undef ANY_TX
#undef ANY_RX
//
// Flag any i2c pin conflicts
//
#if ANY(HAS_MOTOR_CURRENT_I2C, HAS_MOTOR_CURRENT_DAC, EXPERIMENTAL_I2CBUS, I2C_POSITION_ENCODERS, PCA9632, I2C_EEPROM)
#define USEDI2CDEV_M 1 // <Arduino>/Wire.cpp
#if USEDI2CDEV_M == 0 // P0_27 [D57] (AUX-1) .......... P0_28 [D58] (AUX-1)
#define PIN_IS_SDA0(P) (P##_PIN == P0_27)
#define IS_SCL0(P) (P == P0_28)
#if ENABLED(SDSUPPORT) && PIN_IS_SDA0(SD_DETECT)
#error "SDA0 overlaps with SD_DETECT_PIN!"
#elif PIN_IS_SDA0(E0_AUTO_FAN)
#error "SDA0 overlaps with E0_AUTO_FAN_PIN!"
#elif PIN_IS_SDA0(BEEPER)
#error "SDA0 overlaps with BEEPER_PIN!"
#elif IS_SCL0(BTN_ENC)
#error "SCL0 overlaps with Encoder Button!"
#elif IS_SCL0(SD_SS_PIN)
#error "SCL0 overlaps with SD_SS_PIN!"
#elif IS_SCL0(LCD_SDSS)
#error "SCL0 overlaps with LCD_SDSS!"
#endif
#undef PIN_IS_SDA0
#undef IS_SCL0
#elif USEDI2CDEV_M == 1 // P0_00 [D20] (SCA) ............ P0_01 [D21] (SCL)
#define PIN_IS_SDA1(P) (PIN_EXISTS(P) && P##_PIN == P0_00)
#define PIN_IS_SCL1(P) (P##_PIN == P0_01)
#if PIN_IS_SDA1(X_MIN) || PIN_IS_SCL1(X_MAX)
#error "One or more i2c (1) pins overlaps with X endstop pins! Disable i2c peripherals."
#elif PIN_IS_SDA1(X2_DIR) || PIN_IS_SCL1(X2_STEP)
#error "One or more i2c (1) pins overlaps with X2 pins! Disable i2c peripherals."
#elif PIN_IS_SDA1(Y2_DIR) || PIN_IS_SCL1(Y2_STEP)
#error "One or more i2c (1) pins overlaps with Y2 pins! Disable i2c peripherals."
#elif PIN_IS_SDA1(Z2_DIR) || PIN_IS_SCL1(Z2_STEP)
#error "One or more i2c (1) pins overlaps with Z2 pins! Disable i2c peripherals."
#elif PIN_IS_SDA1(Z3_DIR) || PIN_IS_SCL1(Z3_STEP)
#error "One or more i2c (1) pins overlaps with Z3 pins! Disable i2c peripherals."
#elif PIN_IS_SDA1(Z4_DIR) || PIN_IS_SCL1(Z4_STEP)
#error "One or more i2c (1) pins overlaps with Z4 pins! Disable i2c peripherals."
#elif HAS_MULTI_EXTRUDER && (PIN_IS_SDA1(E1_DIR) || PIN_IS_SCL1(E1_STEP))
#error "One or more i2c (1) pins overlaps with E1 pins! Disable i2c peripherals."
#endif
#undef PIN_IS_SDA1
#undef PIN_IS_SCL1
#elif USEDI2CDEV_M == 2 // P0_10 [D38] (X_ENABLE_PIN) ... P0_11 [D55] (X_DIR_PIN)
#define PIN_IS_SDA2(P) (P##_PIN == P0_10)
#define PIN_IS_SCL2(P) (P##_PIN == P0_11)
#if PIN_IS_SDA2(Y_STOP)
#error "i2c SDA2 overlaps with Y endstop pin!"
#elif USES_Z_MIN_PROBE_PIN && PIN_IS_SDA2(Z_MIN_PROBE)
#error "i2c SDA2 overlaps with Z probe pin!"
#elif PIN_IS_SDA2(X_ENABLE) || PIN_IS_SDA2(Y_ENABLE)
#error "i2c SDA2 overlaps with X/Y ENABLE pin!"
#elif AXIS_HAS_SPI(X) && PIN_IS_SDA2(X_CS)
#error "i2c SDA2 overlaps with X CS pin!"
#elif PIN_IS_SDA2(X2_ENABLE)
#error "i2c SDA2 overlaps with X2 enable pin! Disable i2c peripherals."
#elif PIN_IS_SDA2(Y2_ENABLE)
#error "i2c SDA2 overlaps with Y2 enable pin! Disable i2c peripherals."
#elif PIN_IS_SDA2(Z2_ENABLE)
#error "i2c SDA2 overlaps with Z2 enable pin! Disable i2c peripherals."
#elif PIN_IS_SDA2(Z3_ENABLE)
#error "i2c SDA2 overlaps with Z3 enable pin! Disable i2c peripherals."
#elif PIN_IS_SDA2(Z4_ENABLE)
#error "i2c SDA2 overlaps with Z4 enable pin! Disable i2c peripherals."
#elif HAS_MULTI_EXTRUDER && PIN_IS_SDA2(E1_ENABLE)
#error "i2c SDA2 overlaps with E1 enable pin! Disable i2c peripherals."
#elif HAS_MULTI_EXTRUDER && AXIS_HAS_SPI(E1) && PIN_IS_SDA2(E1_CS)
#error "i2c SDA2 overlaps with E1 CS pin! Disable i2c peripherals."
#elif EXTRUDERS && (PIN_IS_SDA2(E0_STEP) || PIN_IS_SDA2(E0_DIR))
#error "i2c SCL2 overlaps with E0 STEP/DIR pin! Disable i2c peripherals."
#elif PIN_IS_SDA2(X_DIR) || PIN_IS_SDA2(Y_DIR)
#error "One or more i2c pins overlaps with X/Y DIR pin! Disable i2c peripherals."
#endif
#undef PIN_IS_SDA2
#undef PIN_IS_SCL2
#endif
#undef USEDI2CDEV_M
#endif
#if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
#error "SERIAL_STATS_MAX_RX_QUEUED is not supported on LPC176x."
#elif ENABLED(SERIAL_STATS_DROPPED_RX)
#error "SERIAL_STATS_DROPPED_RX is not supported on LPX176x."
#endif

Some files were not shown because too many files have changed in this diff Show More