Compare commits

...

1250 Commits

Author SHA1 Message Date
InsanityAutomation b788ce25f5 Update Configuration_adv.h 2024-01-09 11:10:48 -05:00
InsanityAutomation 1a9a5b82a8 AddTwinNebula 2024-01-09 09:33:38 -05:00
InsanityAutomation cb9f103421 Merge branch 'bugfix-2.1.x' into LulzbotTestBase 2024-01-09 09:03:28 -05:00
InsanityAutomation 9479cd9ce7 Merge branch 'bugfix-2.1.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.1.x 2024-01-09 09:00:33 -05:00
thinkyhead 477b70eccf [cron] Bump distribution date (2024-01-09) 2024-01-09 00:22:16 +00:00
narno2202 b2dd2dc217 🚸 FT Motion M493 report less precision (#26643) 2024-01-07 22:26:34 -06:00
narno2202 b106f59eb4 🐛 Refine FT Motion, I2S Stepping (#26628)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-01-07 22:17:43 -06:00
mikemerryguy 38f483c4a6 🩹 Skip post-G28 XY move for untrusted X or Y (#26644)
Followup to #26469

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-01-07 22:14:24 -06:00
Scott Lahteine f4eafed188 🔧 Z_PROBE_END_SCRIPT => EVENT_GCODE_AFTER_G29 2024-01-07 21:59:25 -06:00
Scott Lahteine 5987a5464b 🎨 Use float CEIL/FLOOR 2024-01-07 19:34:34 -06:00
thinkyhead 3a888e956b [cron] Bump distribution date (2024-01-08) 2024-01-08 00:30:52 +00:00
Alexander Gavrilenko 4cddc61eda 🐛 Fix SPI TFT for STM32F1/F4 (#26052) 2024-01-07 18:18:18 -06:00
InsanityAutomation c7de99b141 Update Configuration_adv.h 2024-01-06 19:36:23 -05:00
InsanityAutomation 9ad55840bb Update SanityCheck.h 2024-01-06 18:41:49 -05:00
InsanityAutomation 81011a71b1 Merge branch 'bugfix-2.1.x' into LulzbotTestBase 2024-01-06 18:41:43 -05:00
thinkyhead 2a8c00bdeb [cron] Bump distribution date (2024-01-06) 2024-01-06 00:21:22 +00:00
Scott Lahteine 4ae2a76492 🎨 Clean up ws 2024-01-05 12:34:50 -06:00
Scott Lahteine a5d097abe6 ✏️ Fix CTC_A10S_A13 typo
Followup to #26514
2024-01-04 18:51:32 -06:00
thinkyhead 5e0a8d2124 [cron] Bump distribution date (2024-01-05) 2024-01-05 00:21:26 +00:00
plampix 994aa9f692 ️ Slimmer null T command (#26615)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-01-04 17:09:53 -06:00
Andrew 6e67ad51b7 🎨 Followup to optional M111/M115 (#26626)
Followup to #26603
2024-01-04 17:07:53 -06:00
Scott Lahteine 52693f72af 🎨 Clean up some checks & includes 2024-01-04 13:06:41 -06:00
Jason Smith 991f433ac1 🐛 Fix hangs in DUE native USB (#26572) 2024-01-03 21:14:17 -06:00
Taylor Talkington 54b7da18cb 🩹 Fix Bed PID Autotune output (#26606)
Followup to #25928
2024-01-03 20:45:50 -06:00
thinkyhead f8771e9ad5 [cron] Bump distribution date (2024-01-04) 2024-01-04 00:21:47 +00:00
Orel be1dee7caf 🎨 Clean up old #includes (#26621) 2024-01-03 14:02:20 -06:00
narno2202 68b7802fc1 📝 Update M493 (FT_MOTION) comments (#26620)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-01-03 13:19:19 -06:00
plampix 6d407767e7 🔧 CONFIGURE_FILAMENT_CHANGE - Optional M603 (#26613)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-01-03 09:43:18 -06:00
I3DBeeTech 4a9e102c2e 📺 I3DBEE TECH Beez Mini 12864 (#26596) 2024-01-02 18:53:41 -06:00
ellensp 1ac6428c82 🔪 Options to slim M111, remove M115 (#26603)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-01-02 18:52:12 -06:00
thinkyhead 7c159a20e5 [cron] Bump distribution date (2024-01-03) 2024-01-03 00:21:14 +00:00
ellensp 5b74e25108 🔨 BSD string workaround (#26532)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2024-01-02 01:25:26 -06:00
thinkyhead f02fa6339f [cron] Bump distribution date (2024-01-02) 2024-01-02 00:21:06 +00:00
InsanityAutomation 832e1ca0e7 Merge branch 'bugfix-2.1.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.1.x 2024-01-01 14:03:46 -05:00
Scott Lahteine 3b6f1bff8b 🧑‍💻 Update pinsformat 2024-01-01 00:57:02 -06:00
Scott Lahteine 1d615717e8 🧑‍💻 Python version of pins formatting script 2024-01-01 00:22:38 -06:00
thinkyhead 99c570212d [cron] Bump distribution date (2024-01-01) 2024-01-01 00:24:20 +00:00
nagubash 13e82fa44a 🔨 Fix formatting issue in Makefile (#26599) 2023-12-31 15:03:04 -06:00
narno2202 95878df30d 🐛 Fix homing with FT_MOTION (#26595) 2023-12-31 15:00:57 -06:00
ellensp 5d1ede08aa CTC_A10S_A13 (#26514) 2023-12-31 03:54:26 -06:00
thinkyhead 2203505182 [cron] Bump distribution date (2023-12-31) 2023-12-31 00:23:28 +00:00
ellensp 06dc7f4f52 🔧 Fix, extend FAN / AUTOFAN confict check (#26591)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-30 05:18:42 -06:00
Scott Lahteine e6f1b074df 🩹 Restore usleep for native / sim 2023-12-30 05:08:32 -06:00
thinkyhead f605c045e3 [cron] Bump distribution date (2023-12-30) 2023-12-30 00:20:29 +00:00
Keith Bennett 2d97f082e5 BigTreeTech Manta M8P V2.0 (STM32H723ZE) (#26578) 2023-12-28 22:50:52 -06:00
narno2202 ba91fa09b7 ️ Optimize FT_MOTION (#26557) 2023-12-28 22:41:34 -06:00
Keith Bennett 1aeee2cd1f 🔧 TriGorilla Pro default to ONBOARD_SDIO (#26586) 2023-12-28 20:10:45 -06:00
thinkyhead 4e23e52a89 [cron] Bump distribution date (2023-12-29) 2023-12-29 00:17:32 +00:00
Keith Bennett 88cf3cb1e0 📌 Specify U8glib-HAL@0.5.4 (#26582) 2023-12-28 18:07:52 -06:00
Keith Bennett 59d26e463a 🔨 Newer Platform & Toolchain for STM32G0 (#26585) 2023-12-28 17:38:19 -06:00
thinkyhead cc641d796d [cron] Bump distribution date (2023-12-28) 2023-12-28 00:21:10 +00:00
Scott Lahteine 9d324f7b1f 🎨 Remove unused usleep 2023-12-27 15:16:58 -06:00
Scott Lahteine 654e7a84ff 🩹 Minor MKS UI fix 2023-12-27 15:16:21 -06:00
Scott Lahteine d903a5ef43 Initial support for HC32 U8G LCD (#26568)
Co-authored-by: Chris <52449218+shadow578@users.noreply.github.com>
2023-12-27 01:27:43 -06:00
Scott Lahteine 15f26b4021 🧑‍💻 AS_CHAR => C (#26569) 2023-12-27 01:25:51 -06:00
Taylor Talkington 10d80eb894 📝 Docs: Binary File Transfer (BFT) Protocol (#26570) 2023-12-27 01:24:16 -06:00
Scott Lahteine 858954baad 🧑‍💻 Update Uncrustify config 2023-12-27 01:17:14 -06:00
thinkyhead 3840663410 [cron] Bump distribution date (2023-12-27) 2023-12-27 00:28:24 +00:00
Scott Lahteine bd36644d85 🧑‍💻 Move U8G defines to HALs 2023-12-26 17:53:49 -06:00
Keith Bennett c485f513d7 BigTreeTech Kraken V1.0 (STM32H723ZG) (#26565)
Co-authored-by: bigtreetech <38851044+bigtreetech@users.noreply.github.com>
2023-12-26 17:45:42 -06:00
Keith Bennett 06b9e40042 🧑‍💻 Use MAX31865 flag (#26574)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-26 17:43:06 -06:00
Scott Lahteine 7603023928 🔨 Apply signature.py help 2023-12-25 20:58:38 -06:00
thinkyhead dbf81f40de [cron] Bump distribution date (2023-12-26) 2023-12-26 00:20:41 +00:00
Dennis bb557e5195 🩹 Fix string buffer warning (#26550)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-24 21:40:20 -06:00
Keith Bennett 89fdfcfaf9 🩹 Fix MARKFORGED_INVERSE typos (#26558)
Followup to #26516
2023-12-24 21:37:20 -06:00
Scott Lahteine d9a388bab8 🩹 Fix some serial chars 2023-12-24 21:31:54 -06:00
thinkyhead b44e68e2ab [cron] Bump distribution date (2023-12-25) 2023-12-25 00:21:58 +00:00
Scott Lahteine 0f09554929 🧑‍💻 DWIN icon updates, etc. 2023-12-24 15:25:43 -06:00
ellensp 18b0dbb501 🐛 Creality Free Runs fixups (#26562)
Followup to #25636, #26533

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-24 12:07:00 -06:00
thinkyhead fa8d2bd108 [cron] Bump distribution date (2023-12-24) 2023-12-24 00:23:04 +00:00
Scott Lahteine d1ebaba71d 🔨 Remove signature.py debug 2023-12-23 16:27:13 -06:00
Skopus 71e0275a4c Orca 3D Modular Controller (#26534) 2023-12-23 04:24:19 -06:00
Scott Lahteine 205b0a679e 🎨 Whitespace in the rightplace 2023-12-23 04:19:23 -06:00
Mihai 3029a6b1aa 🩹 Jerk correction for LIN_ADVANCE + CLASSIC_JERK (#26551)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-23 01:45:37 -06:00
thinkyhead 342048b1df [cron] Bump distribution date (2023-12-23) 2023-12-23 00:20:19 +00:00
Scott Lahteine ec060f979f 📝 Clean up variant labels 2023-12-22 17:47:29 -06:00
Andrew 56ac5d03ed 🚸 Update ProUI Plot graph (#26539) 2023-12-22 12:57:06 -06:00
Scott Lahteine ec7ab5a277 🔨 Build flag tweaks 2023-12-21 22:35:51 -06:00
Scott Lahteine 2c5468ce33 🎨 Planner indent 2023-12-21 22:34:19 -06:00
thinkyhead dbdb2ecdf7 [cron] Bump distribution date (2023-12-22) 2023-12-22 00:21:13 +00:00
Scott Lahteine c18294d83c 🔧 Optional FAN_INVERTING 2023-12-21 15:30:03 -06:00
Scott Lahteine 401ba6613b 🔧 Up to 12 PWM fans 2023-12-21 15:25:48 -06:00
thinkyhead 19617b79db [cron] Bump distribution date (2023-12-21) 2023-12-21 06:06:34 +00:00
Scott Lahteine eeacf76cfd 🔧 config.ini / JSON dump by @section (#26556) 2023-12-20 22:07:59 -06:00
thinkyhead 738584d342 [cron] Bump distribution date (2023-12-20) 2023-12-20 06:06:01 +00:00
Scott Lahteine f69effd2eb 🚸 Just "warn" on SD fail 2023-12-19 20:57:32 -06:00
narno2202 67d7562609 🐛️ FT_MOTION improvements (#26074)
Co-Authored-By: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-19 20:01:11 -06:00
thinkyhead 0ede16cd5a [cron] Bump distribution date (2023-12-18) 2023-12-18 00:22:22 +00:00
geijt 4a89ef6273 Fix Creality E3 "Free-runs" (#26533)
Followup to #25636
2023-12-17 16:33:46 -06:00
thinkyhead 145ab7b1ec [cron] Bump distribution date (2023-12-16) 2023-12-16 06:05:48 +00:00
Scott Lahteine 3f9c2f89fc 🔧 Fix IDEX home check
Followup to #25780
2023-12-15 23:40:26 -06:00
Scott Lahteine 00298e6681 🔧 Update fan 0 conflict check
Followup to #25568
2023-12-15 20:23:59 -06:00
thinkyhead 68ab7f6bb7 [cron] Bump distribution date (2023-12-15) 2023-12-15 00:21:58 +00:00
Bob Kuhn 7ab63cde62 Creality E3 Free-runs Silent Motherboard (#25636) 2023-12-14 17:37:40 -06:00
Mihai b90133813a 🐛 Fix planner jerk limits (#26529)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-14 14:16:15 -06:00
Scott Lahteine 75da3555ee 🔧 Update CLASSIC_JERK conditionals 2023-12-14 10:06:14 -06:00
thinkyhead 8bce9dec90 [cron] Bump distribution date (2023-12-14) 2023-12-14 00:21:11 +00:00
jesterhead82 fef74398e4 MARKFORGED_INVERSE (#26516) 2023-12-13 01:44:11 -06:00
thinkyhead 775c6bb20e [cron] Bump distribution date (2023-12-13) 2023-12-13 06:12:17 +00:00
Andrew 06710e54de EDITABLE_DISPLAY_TIMEOUT (#26517)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-12 23:33:03 -06:00
thinkyhead 81cfa23882 [cron] Bump distribution date (2023-12-12) 2023-12-12 06:09:34 +00:00
ellensp f3fd9e28f5 🐛 Fix MKS TS35 with BTT SKR 1.3/1.4 (#26176) 2023-12-11 19:30:28 -06:00
rondlh b94a335493 SERIAL_DMA (for some STM32Fx) (#26328) 2023-12-11 18:48:02 -06:00
thinkyhead 01aa87c307 [cron] Bump distribution date (2023-12-10) 2023-12-10 00:23:34 +00:00
mikemerryguy 473817f2f4 🚸 Adjust Progress / Completion (#26466)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-09 01:38:31 -06:00
David Buezas a1c3a2b03a 🚸 Encoder improvements (#26501) 2023-12-09 00:48:57 -06:00
Scott Lahteine bdfe4a108c 🩹 Fix UBL debug output 2023-12-08 23:18:53 -06:00
thinkyhead 10fe229aad [cron] Bump distribution date (2023-12-09) 2023-12-09 00:20:55 +00:00
Scott Lahteine dfec58e5dc ️ Use strlcpy with buffer size (#26513) 2023-12-08 00:47:18 -06:00
thinkyhead 6c04cf40f4 [cron] Bump distribution date (2023-12-08) 2023-12-08 06:06:47 +00:00
Keith Bennett fe7203ee55 🔨 Use PIO versioning (including HC32) (#26512) 2023-12-07 22:35:34 -06:00
thinkyhead 483b8dcc05 [cron] Bump distribution date (2023-12-06) 2023-12-06 06:06:45 +00:00
Andrew a41e16ffee Voxelab Aquila N32 (via Maple) (#26470)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-05 23:11:41 -06:00
studiodyne 425af4240b 🐛 Fix tool-change E prime (#26494)
Followup to #17248
2023-12-05 23:05:48 -06:00
thinkyhead 4a4c1db606 [cron] Bump distribution date (2023-12-05) 2023-12-05 06:06:24 +00:00
ellensp 2b1375c8ea 🐛 Fix thermistor 14 & 60 constexprness (#26499) 2023-12-04 23:27:58 -06:00
Alexander Gavrilenko 065440891b 🚸 UI refresh for some events (#26487) 2023-12-04 22:46:39 -06:00
ellensp d58168a03f 🩹 Fix a NeoPixel override (#26492) 2023-12-04 22:19:02 -06:00
ellensp 8cf936ccb1 🩹 Fix ftostrX3sign (#26497) 2023-12-04 21:35:12 -06:00
David Buezas d5d45e85e4 DOUBLE_LCD_FRAMERATE (#26500) 2023-12-04 21:31:34 -06:00
thinkyhead 0d4f41fb6d [cron] Bump distribution date (2023-12-04) 2023-12-04 00:22:06 +00:00
Scott Lahteine 1c1c473910 Fix auto-label action comments 2023-12-03 01:22:14 -06:00
Scott Lahteine dde878db04 Use actions/github-script@v7 2023-12-03 00:32:28 -06:00
Keith Bennett 1a42c38e0e 🩹 Replace more DEBUG_ECHOF (#26495)
Followup to #25928
2023-12-03 00:03:46 -06:00
thinkyhead e695c473af [cron] Bump distribution date (2023-12-03) 2023-12-03 00:23:05 +00:00
Scott Lahteine bd6eb83250 🩹 Fix some minor issues 2023-12-01 21:47:25 -06:00
Andrew c484228c56 Fix some action labels (#26490)
Co-authored-by: thisiskeithb <13375512+thisiskeithb@users.noreply.github.com>
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-01 21:18:24 -06:00
thinkyhead f265fb5943 [cron] Bump distribution date (2023-12-02) 2023-12-02 00:20:23 +00:00
ellensp b17d3d3e9c 🧑‍💻 More num-to-string digits / precisions (#26343)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-12-01 09:25:57 -06:00
Scott Lahteine c53844ff91 Temporary CI Tests for 2.1.x 2023-12-01 04:45:55 -06:00
Scott Lahteine e393c7fa0e Temporarily allow PR against 2.1.x 2023-11-30 20:51:55 -06:00
thinkyhead b55678a7d0 [cron] Bump distribution date (2023-12-01) 2023-12-01 00:23:41 +00:00
Erkan Ozgur Yilmaz fe8266b591 🚸 Fix BLTouch HSMode deploy (#26311) 2023-11-30 16:52:11 -06:00
Scott Lahteine 3d8e3c3c9a 🐛 Touch fixes (#26455) 2023-11-30 16:25:11 -06:00
thinkyhead 61349dc6d3 [cron] Bump distribution date (2023-11-30) 2023-11-30 00:21:18 +00:00
Scott Lahteine 95821b07b1 Auto-label older open [BUG] issues 2023-11-29 16:46:58 -06:00
Scott Lahteine d62ee95d28 🔨 Update config/schema scripts (#26483) 2023-11-29 14:24:20 -06:00
Scott Lahteine b962014087 Label bug reports 2023-11-29 14:19:30 -06:00
Scott Lahteine 921198e81c 🧑‍💻 More SAMD51 ADCs 2023-11-28 21:13:29 -06:00
thinkyhead 3457952854 [cron] Bump distribution date (2023-11-29) 2023-11-29 00:27:28 +00:00
mikemerryguy f4228cc4c1 XY_AFTER_HOMING, EVENT_GCODE_AFTER_HOMING (#26469)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-28 17:55:21 -06:00
ellensp dabcd65903 🚸 Fix ProUI hostui.notify('finished') (#26478) 2023-11-28 16:23:18 -06:00
thinkyhead 8fa4f5a40f [cron] Bump distribution date (2023-11-28) 2023-11-28 12:08:12 +00:00
Keith Bennett b95aa36b01 📝 Community Reporting redux (#26368) 2023-11-28 00:46:21 -06:00
I3DBeeTech 7a96a082b7 BlackBeezMini 3D by I3DBEE (#26406)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
Co-authored-by: thisiskeithb <13375512+thisiskeithb@users.noreply.github.com>
2023-11-28 00:43:17 -06:00
Andrew b78f0012e9 📝 Fix comment dates (#26472) 2023-11-28 00:10:18 -06:00
thinkyhead e958b6da9e [cron] Bump distribution date (2023-11-27) 2023-11-27 00:23:10 +00:00
Chris 86338ca835 HAL for HC32F460 (#26414) 2023-11-26 17:58:56 -06:00
Scott Lahteine 8a110b80bf Use Python 3.9 for CI 2023-11-26 14:39:43 -06:00
Scott Lahteine 9a12f06f19 🎨 Update file headers
Marlin is collectively © by the Organization, with individual contributors having © on their original work as documented in the commit history.
2023-11-26 12:52:17 -06:00
ellensp 7d334775d0 Update MinSerial.cpp
Add missing commas
2023-11-26 23:05:50 +13:00
David Buezas 0a86a5f39c MAX Thermocouples for Heated Bed (#26441)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-25 19:55:51 -06:00
thinkyhead e7cf0e12ea [cron] Bump distribution date (2023-11-26) 2023-11-26 00:27:32 +00:00
ellensp e41df97c42 🔧 Pins for FYSETC Spider King 4.07 (#26461) 2023-11-25 17:15:38 -06:00
Andrew 20a26d5053 🧑‍💻 Use ftpl for item strings (#26462) 2023-11-25 16:46:42 -06:00
Keith Bennett 924d7769ec BD_SENSOR_PROBE_NO_STOP (#26353) 2023-11-25 16:31:53 -06:00
Jason Smith 8ff937c7d8 🐛 Fix PANDA ZHU missing #endif (#26460) 2023-11-24 23:26:02 -08:00
ellensp ae695e8309 👽️ Update Teensy 4.0/4.1 Serial (#26457) 2023-11-24 21:27:55 -06:00
thinkyhead e98e307d17 [cron] Bump distribution date (2023-11-25) 2023-11-25 00:20:09 +00:00
Vovodroid bd872a7a98 🔧 Configurable FR/Flow edit ranges (#26446)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-24 13:03:06 -06:00
thinkyhead fd3de02a37 [cron] Bump distribution date (2023-11-24) 2023-11-24 00:20:39 +00:00
Jason Smith 1bee537a09 🧑‍💻 Add sim launch example for Windows (#26456) 2023-11-23 10:17:41 -08:00
Scott Lahteine ded942a4e4 🐛 Fix expand_u8str_P string substitution
Fixes #26424
2023-11-22 22:18:53 -06:00
Scott Lahteine bf61e52390 ️ Tiny string optimization 2023-11-22 21:06:47 -06:00
Erkan Ozgur Yilmaz 2d9262cc5a ️ Fix MMU2 sscanf bug, optimize (#26449)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-22 20:39:40 -06:00
thinkyhead 993cc9463e [cron] Bump distribution date (2023-11-23) 2023-11-23 00:21:17 +00:00
Andrew c2376d62e2 🩹 Fix JyersUI/ProUI narrowing (#26453)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-22 02:40:50 -06:00
Andrew f3473495d0 🚸 Fixes for ProUI popup, abort (#26308) 2023-11-22 02:19:29 -06:00
Andrew c5b267162c 🌐 Regenerate Russian font data (#26428) 2023-11-22 02:07:44 -06:00
Scott Lahteine 8322848c35 Smarter use_example_configs 2023-11-22 01:35:46 -06:00
thinkyhead 61cb98dc0f [cron] Bump distribution date (2023-11-22) 2023-11-22 00:21:52 +00:00
Scott Lahteine 2b1666fcb0 ✏️ GT2560_V41b followup 2023-11-21 14:07:39 -06:00
ellensp 6ae2cde663 🐛Fix GT2560_V41b Z2 pin (#26370)
* Update pins_GT2560_V41b.h

Fix Z2_STOP_PIN

* use mega2560ext

when board has pins > D69

* Allow overrides, consistent with other pins in this file

---------

Co-authored-by: Jason Smith <jason.inet@gmail.com>
2023-11-21 09:43:08 -08:00
Andrew cc8f7c83da 🚸 Fix, clean up ProUI (#26434)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-21 03:57:31 -06:00
Jason Smith 20445b8e83 🧑‍💻 Update pins formatter script (#26450) 2023-11-21 03:42:44 -06:00
thinkyhead 12881d5576 [cron] Bump distribution date (2023-11-21) 2023-11-21 00:21:26 +00:00
Keith Bennett b88cb86069 BTT Octopus Pro V1.0.1 (STM32H723ZE) (#26159) 2023-11-20 11:55:27 -08:00
Scott Lahteine 3d3be15665 🔨 Fix Ender-5 S1 env 2023-11-20 02:18:53 -06:00
Keith Bennett 0142783836 🚸 Fix more MarlinUI title centering (#26440)
Followup to #26339
2023-11-20 01:24:32 -06:00
Andrew 006768ab58 🚸 Fix MarlinUI axis move / UBL strings (#26439)
Followup to #26344
2023-11-20 01:23:07 -06:00
Scott Lahteine 376673df28 🚸 Minor touch calibration improvement (#26445) 2023-11-20 00:53:35 -06:00
thinkyhead f830756356 [cron] Bump distribution date (2023-11-20) 2023-11-20 00:21:38 +00:00
Keith Bennett 1fceb7c580 🔥 Remove VAkE 403D part deux (#26443)
Followup to #25969
2023-11-19 15:57:03 -06:00
Jason Smith 5287cfbb59 🐛 Fix rotational AxisFlags (#26444)
Followup to #26438
2023-11-19 15:23:20 -06:00
Scott Lahteine f345f60f73 🔨 Similar board name errors 2023-11-18 23:49:59 -06:00
thinkyhead e2c8015199 [cron] Bump distribution date (2023-11-19) 2023-11-19 00:22:58 +00:00
Scott Lahteine aed577271f 🔨 Rotational move items (#26438) 2023-11-17 22:39:00 -06:00
thinkyhead f50ca52c57 [cron] Bump distribution date (2023-11-18) 2023-11-18 00:20:36 +00:00
ellensp 36e66bdd9f 🔧 Define MarlinUI axis moves with lists (#26344)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-17 14:11:59 -06:00
EvilGremlin 19869d3a7d 🔨 Creality STM32F401RC w/out bootloader (#26373) 2023-11-16 19:57:00 -06:00
thinkyhead c8118c3a58 [cron] Bump distribution date (2023-11-17) 2023-11-17 00:20:53 +00:00
Scott Lahteine 7fe07dc4ce 🩹 Fix runout state in menu (#26394)
Fixes #26386
2023-11-16 16:05:31 -06:00
thinkyhead 3e8a5b6151 [cron] Bump distribution date (2023-11-15) 2023-11-15 00:20:46 +00:00
ellensp 28bc19720a 🐛 Put I2C init ahead of LCD init (#26409) 2023-11-14 02:33:15 -06:00
ellensp a8cb89b3da 🐛 Fix BTT SKR Mini E3 pins (#26410) 2023-11-14 02:31:13 -06:00
Keith Bennett df2251e23e 🔨 Fix PINS_DEBUGGING for some STM32H7 (#26416) 2023-11-14 02:29:07 -06:00
Andrew 31154278b3 🔨 Fix legacy auto_build.py (#26427) 2023-11-14 02:27:05 -06:00
Keith Bennett 613b4105a2 🔨 Fix updated build script (#26423)
Followup to #26265

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-14 01:52:22 -06:00
Scott Lahteine 10e06e1970 🧑‍💻 Prevent mixed bitmap encoding
Followup to #26419
2023-11-14 01:23:46 -06:00
Andrew c751dcfcf9 🎨 Python ; cleanup (#26426) 2023-11-13 23:48:01 -06:00
Scott Lahteine 178938d957 ️ Extend bitmap compression
Followup to #26419
2023-11-13 23:43:57 -06:00
thinkyhead a8313c3b7e [cron] Bump distribution date (2023-11-14) 2023-11-14 00:20:32 +00:00
Scott Lahteine dc26531207 COMPACT_CUSTOM_BOOTSCREEN (#26419) 2023-11-13 17:24:15 -06:00
Scott Lahteine c74e6ad868 🔨 Use classic ld on macOS 2023-11-13 04:29:01 -06:00
thinkyhead a62eec4ae3 [cron] Bump distribution date (2023-11-13) 2023-11-13 00:21:11 +00:00
ellensp 235ad4dd9d 🚸 Fix DOGM centering (#26415) 2023-11-12 00:25:51 -06:00
thinkyhead d06923d0e7 [cron] Bump distribution date (2023-11-12) 2023-11-12 06:05:50 +00:00
Luiz Eduardo Carneiro 7f59b65fc8 MINGDA D2 D301 v1.0 (#26340) 2023-11-11 20:44:45 -06:00
Vovodroid 884a3249fe BED_ANNEALING_GCODE (#26341)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-11 20:40:49 -06:00
Vladimir Sitnikov d159ec5c90 🔨 Specific package versions (#26265)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-11 20:13:23 -06:00
Scott Lahteine 7c43f4e696 Fix opt_add in tests 2023-11-11 20:10:11 -06:00
ellensp 7c8ea8e0e0 🧑‍💻 Fix M808 debug (#26367) 2023-11-11 20:02:53 -06:00
thinkyhead 573eae8d95 [cron] Bump distribution date (2023-11-11) 2023-11-11 00:19:53 +00:00
ellensp bf0acc9611 🐛 SKR Pro boards have DIAG pins (#26399)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-09 20:30:41 -06:00
thinkyhead ddc310fc4b [cron] Bump distribution date (2023-11-10) 2023-11-10 00:20:21 +00:00
Keith Bennett 10782c770d 🩹 Probe XY Offset followup (#26397)
Followup to #26267
2023-11-09 17:44:02 -06:00
Andrew b2758208c7 G27 P3 / P4 (#26401)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-09 16:34:48 -06:00
Scott Lahteine bf5612c0ed 🧑‍💻 Use __FLT_MAX__ for HUGE_VALF 2023-11-09 16:05:11 -06:00
InsanityAutomation 83bdfeb5cb Merge branch 'bugfix-2.1.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.1.x 2023-11-08 09:39:42 -05:00
thinkyhead 9a6c2635ee [cron] Bump distribution date (2023-11-07) 2023-11-07 00:20:29 +00:00
Scott Lahteine 3341683db2 🧑‍💻 Use FLT_MAX for HUGE_VALF 2023-11-05 21:30:04 -06:00
thinkyhead 0bdbf52bc6 [cron] Bump distribution date (2023-11-06) 2023-11-06 00:21:03 +00:00
Scott Lahteine e4e85e39b3 Get LCD/Controller in bug report 2023-11-05 15:01:12 -06:00
Scott Lahteine 0621594442 Update stale / close durations 2023-11-05 14:55:06 -06:00
Scott Lahteine dba613fadd 🔨 Fix test of env['PROGNAME']
Fixes #26386
2023-11-05 12:30:02 -06:00
thinkyhead 5ac4ebad78 [cron] Bump distribution date (2023-11-05) 2023-11-05 12:06:43 +00:00
Vladimir Sitnikov cb044d989c Probe XY Offset value limits (#26267)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-11-05 01:46:57 -05:00
thinkyhead 0d42196d11 [cron] Bump distribution date (2023-11-04) 2023-11-04 06:05:47 +00:00
tombrazier cac742009c 🐛 Fix Backlash Compensation layer shift (#26392) 2023-11-03 23:12:33 -05:00
Scott Lahteine 76f938309e 🔨 Minor schema.py updates 2023-11-01 15:36:26 -05:00
thinkyhead 24cf29b6a8 [cron] Bump distribution date (2023-11-01) 2023-11-01 01:19:48 +00:00
Chris 41a6f2bc8d 🧑‍💻 Improve POSTMORTEM_DEBUGGING (#26374)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-31 19:10:37 -05:00
Giuliano Zaro e0767f8675 🌐 Fix long Italian string (#26378) 2023-10-31 19:03:28 -05:00
Giuliano Zaro 5523c12cfd 🩹 Fix MarlinUI UTF-8 chars (#26381) 2023-10-31 19:02:11 -05:00
thinkyhead a6c8afc5a9 [cron] Bump distribution date (2023-10-29) 2023-10-29 00:21:30 +00:00
Vladimir Sitnikov cb8df74a9c 🚸 Move Debug menu down (#26266) 2023-10-27 20:01:04 -05:00
Vladimir Sitnikov 050439ccba 🧑‍💻 Update .editorconfig settings (#26264)
Fixes #26219
2023-10-27 19:46:09 -05:00
thinkyhead 6907df0bd6 [cron] Bump distribution date (2023-10-28) 2023-10-28 00:18:59 +00:00
Giuliano Zaro 5a259a7266 🌐 Update Italian language (#26208) 2023-10-27 17:18:15 -05:00
ellensp b082f1a2b8 ️ Faster COMPACT_MARLIN_BOOT_LOGO (rle16) (#26153) 2023-10-27 17:15:23 -05:00
tombrazier c666b492c4 🔥 Automatic minimum planner junction speed (#26198) 2023-10-27 17:06:04 -05:00
tombrazier aa0671fb32 🩹 Fix Input Shaping max_isr_rate with Distinct E factors (#26167) 2023-10-27 16:10:02 -05:00
thinkyhead f82d0109e4 [cron] Bump distribution date (2023-10-27) 2023-10-27 00:19:27 +00:00
Scott Lahteine 2a88e76002 🧑‍💻 Misc. LCD / string updates 2023-10-25 19:41:32 -05:00
thinkyhead b25f523aca [cron] Bump distribution date (2023-10-26) 2023-10-26 00:23:31 +00:00
Scott Lahteine 046439a5a1 🧑‍💻 Echo by default in dev mode 2023-10-25 14:27:22 -05:00
thinkyhead bcd07c2c91 [cron] Bump distribution date (2023-10-24) 2023-10-24 00:19:54 +00:00
Scott Lahteine e9b04ada1d 🩹 Fix PLR debug with NO_VOLUMETRICS 2023-10-23 19:00:44 -05:00
Scott Lahteine ff5eb5de29 🩹 No GET_TEXT with DGUS_TFT
Followup to #26164
2023-10-23 19:00:44 -05:00
Scott Lahteine fd62c42faa 🩹 No GET_TEXT with DGUS_TFT
Followup to #26164
2023-10-23 17:07:04 -05:00
thinkyhead 089d075c8f [cron] Bump distribution date (2023-10-23) 2023-10-23 00:20:43 +00:00
Scott Lahteine 45a6e9614e 📝 Community Reporting 2023-10-22 18:39:22 -05:00
Marcio T 9e6d0ea610 🩹 Fix FTDI Eve Touch UI meshGetter, etc. (#26342)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-22 17:22:16 -05:00
Keith Bennett c345087b41 🔨 Add MKS Eagle FD Envs (#26346) 2023-10-22 15:46:34 -05:00
Keith Bennett 8de007021a 🧑‍💻 Don't Recommend DevContainer (#26348) 2023-10-22 15:44:29 -05:00
Scott Lahteine f72588595b 🚸 SD refresh UI update with NO_SD_DETECT (#26366)
Co-authored-by: Sascha <k.puligheddu@alice.it>
2023-10-22 15:17:30 -05:00
Keith Bennett 797ea5efa7 🚸 Fix MarlinUI expanded label alignment (#26339)
Co-authored-by: ellensp <530024+ellensp@users.noreply.github.com>
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-22 15:15:38 -05:00
ellensp 156e7c1c54 🐛 Fix TFT compile, K8400 pins (#26359) 2023-10-22 14:25:28 -05:00
thinkyhead b8b1aa345c [cron] Bump distribution date (2023-10-21) 2023-10-21 00:19:15 +00:00
Scott Lahteine b0ece8f8df 🧑‍💻 MarlinUI menu tweaks
Changes in prep for #26339
2023-10-20 17:25:47 -05:00
studiodyne 4b0b00c8da Tool Migration-specific settings (#26244)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-19 20:23:23 -05:00
Andrew 6d3122d4e8 🚸 Misc. JyersUI tweaks (#26228)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-19 20:22:04 -05:00
ellensp 0f27e38eb9 🎨 Update GT2560 V41b (#26351) 2023-10-19 19:34:22 -05:00
thinkyhead 6156050024 [cron] Bump distribution date (2023-10-20) 2023-10-20 00:20:00 +00:00
Andrew cacbe005b5 🩹 Fix ProUI G-code preview (#26213) 2023-10-19 18:01:43 -05:00
thinkyhead caca5636ce [cron] Bump distribution date (2023-10-15) 2023-10-15 06:05:56 +00:00
Marcio T 6a35ab6557 Z_PROBE_ERROR_TOLERANCE (expose) (#26229)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-14 23:54:54 -05:00
thinkyhead 87de4c134b [cron] Bump distribution date (2023-10-13) 2023-10-13 18:06:12 +00:00
Scott Lahteine 7944628400 🧑‍💻 IA Creality optional code 2023-10-13 09:48:14 -05:00
thinkyhead 251a84b741 [cron] Bump distribution date (2023-10-12) 2023-10-12 18:20:54 +00:00
Scott Lahteine d695e5f7bc 🔧 Misc. probe opts 2023-10-12 13:03:02 -05:00
Scott Lahteine 4744997c16 📝 GCode => G-Code 2023-10-12 12:14:57 -05:00
Scott Lahteine 5bd39ba73f 🧑‍💻 FxdTiCtrl => FTMotion redux 2023-10-12 12:14:53 -05:00
Marcio T 7f887f2342 🚸 Update FTDI Eve / CocoaPress UI (#26233) 2023-10-12 11:14:58 -05:00
Scott Lahteine e7e77d9612 🧑‍💻 FxdTiCtrl => FTMotion 2023-10-12 10:12:35 -05:00
Scott Lahteine a7a3abb9bf 📝 Macro comments 2023-10-12 09:21:00 -05:00
thinkyhead 6f68da5be4 [cron] Bump distribution date (2023-10-11) 2023-10-11 06:06:33 +00:00
Andrew Bortz e9b9d634c4 Nonlinear Extrusion Control (M592) (#26127) 2023-10-10 22:24:48 -05:00
thinkyhead 6d301a282e [cron] Bump distribution date (2023-10-10) 2023-10-10 00:19:51 +00:00
studiodyne 61591fd233 🐛 Fix tool-change E prime (#26237)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-09 17:50:09 -05:00
Marcella Cavalcanti e97d82f77b FYSETC Cheetah v3.0 (#26314) 2023-10-09 16:55:44 -05:00
Keith Bennett b58d5dabf8 🔧 BTT_MINI_12864_V1 => BTT_MINI_12864 (#26160) 2023-10-08 20:07:09 -05:00
Dipl.-Ing. Raoul Rubien, BSc 047bce0cdd 🔧 More angles for 2x Servo Switching Nozzle (#26303)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-08 19:22:40 -05:00
thinkyhead c81e217334 [cron] Bump distribution date (2023-10-09) 2023-10-09 00:20:31 +00:00
Scott Lahteine 9cd341c2c3 🩹 Patches for MSC SD (#26332) 2023-10-08 18:09:49 -05:00
Scott Lahteine f0ad1e9b70 🧑‍💻 Update dev scripts 2023-10-08 16:49:18 -05:00
Scott Lahteine 414b1f8327 🩹 Serial warning followup
Followup to #26306
2023-10-08 16:49:18 -05:00
Erkan Ozgur Yilmaz e68320ee2b 🐛 Fix MMU late init (#26331) 2023-10-08 15:39:46 -05:00
ellensp 7fa643a11e 🔨 Specify LPC toolchain 1.100301.220327 (#26249) 2023-10-08 15:16:28 -05:00
thinkyhead 375e724dee [cron] Bump distribution date (2023-10-08) 2023-10-08 00:21:49 +00:00
Keith Bennett 6c0f4bbafd CI test for STM32G0 (#26327) 2023-10-07 01:21:41 -05:00
Orel 4cab75115f 🩹 Fix G33 output (#26299)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-07 01:10:22 -05:00
Scott Lahteine 014609ad87 🔧 Move some config options 2023-10-07 00:29:34 -05:00
Bob Kuhn f7a3172c20 🐛 Fix DELTA Z when not using probe for homing (#26297) 2023-10-06 23:53:52 -05:00
Bob Kuhn b799f7d1f3 🔧 Forbid UBL Hilbert Curve on DELTA (#26296) 2023-10-06 23:45:32 -05:00
Vladimir Sitnikov f3851408fe 🔧 No TMC_HOME_PHASE on tandem steppers (#26310)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-06 23:44:27 -05:00
Scott Lahteine 03cf2b577b misc. formatting, grid condition 2023-10-06 21:55:57 -05:00
Vovodroid b3b6f23320 🧑‍💻 Tweak an 'if' block (#26300) 2023-10-06 20:03:02 -05:00
Piotr Piatkowski 821ba43131 🩹 Fix Endstop Test debug menu (#26326) 2023-10-06 19:56:10 -05:00
thinkyhead 31bf73b89b [cron] Bump distribution date (2023-10-07) 2023-10-07 00:19:28 +00:00
Scott Lahteine 229ea71421 📝 Update dgus_e3s1pro comment 2023-10-06 19:02:34 -05:00
Scott Lahteine f085e2ca93 🩹 Remove extraneous 'inline'
See #26085
2023-10-06 17:20:08 -05:00
Keith Bennett db98f06110 🚸 Warning alerts for non-fatal errors (#26306)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-10-06 17:09:58 -05:00
Scott Lahteine bbb5aacc48 📝 Update config sections 2023-10-06 16:12:23 -05:00
Scott Lahteine 91ab18d1d2 📝 Some settings units 2023-10-06 16:08:30 -05:00
thinkyhead 273cbc6871 [cron] Bump distribution date (2023-10-05) 2023-10-05 06:06:14 +00:00
EvilGremlin 596d1ff104 🩹 Fix TFT string code (#26292) 2023-10-04 23:47:23 -05:00
thinkyhead 896492442c [cron] Bump distribution date (2023-10-04) 2023-10-04 00:36:20 +00:00
Keith Bennett b9e58cd3ea 🔧 BigTreeTech Manta M4P is v2.1 (#26226) 2023-10-03 15:23:40 -05:00
ellensp d961dbae8d 🔧 Fix SanityCheck typo (#26223) 2023-10-03 15:21:53 -05:00
Scott Lahteine be031e1850 📝 More ExtUI documentation 2023-10-03 15:20:35 -05:00
Scott Lahteine 15dfbabc9c 🔧 Temp report precision option (#26253) 2023-10-03 14:52:04 -05:00
kisslorand 102de7dac3 🚸 More precision in G30 output (#26255) 2023-10-03 14:50:33 -05:00
kisslorand 7338a2fec8 🚸 Use SERIAL_FLOAT_PRECISION for SERIAL_ECHO(float) (#26254) 2023-10-03 14:48:52 -05:00
thinkyhead d56136f06c [cron] Bump distribution date (2023-09-30) 2023-09-30 00:19:06 +00:00
ellensp 34a0c9d143 📝 Update BTT SKR Mini E3 v3.0 comments (#26318) 2023-09-29 18:12:29 -05:00
thinkyhead 11f98adcce [cron] Bump distribution date (2023-08-26) 2023-08-26 00:22:53 +00:00
jaysuk 209fadd2e6 Mellow Fly E3 V2 (STM32F407VG) (#26081) 2023-08-25 18:43:57 -05:00
Andrew 8fa6a4da2e 🚸 Fixes for ProUI, JyersUI, backlight, etc. (#26086)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-08-25 18:33:49 -05:00
Scott Lahteine 4613f85bb7 🧑‍💻 Encapsulate ProUI G-code preview 2023-08-25 13:33:33 -05:00
thinkyhead e1121a4cd0 [cron] Bump distribution date (2023-08-25) 2023-08-25 00:19:03 +00:00
lukasradek 20fec98f70 🧑‍💻 Adjust LCD string draw (#26154) 2023-08-24 12:41:30 -05:00
thinkyhead adfc787a45 [cron] Bump distribution date (2023-08-24) 2023-08-24 00:18:43 +00:00
Scott Lahteine 86be9a85d0 📝 Thermistor info updates (#26202) 2023-08-23 13:44:40 -05:00
thinkyhead f6de698fc8 [cron] Bump distribution date (2023-08-23) 2023-08-23 00:25:27 +00:00
Anson Liu edc7379546 G-code 'T' report current tool (#26151)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-08-22 19:21:41 -05:00
Scott Lahteine ab8af7fa9c 🔧 Allow arbitrary BLOCK_BUFFER_SIZE 2023-08-22 19:16:35 -05:00
Keith Bennett fb74caebb5 🔧 Fix Linear Leveling grid size sanity check (#26199) 2023-08-22 18:40:59 -05:00
Scott Lahteine 88cdf487b4 🚸 Avoid LCD messages starting with "Error:" (#26164) 2023-08-22 17:36:53 -05:00
narno2202 be91eaed2c 🩹 Fix FT Motion menu Back item (#26175) 2023-08-22 17:13:53 -05:00
thinkyhead b5a08c2518 [cron] Bump distribution date (2023-08-22) 2023-08-22 00:18:52 +00:00
Scott Lahteine b02ea02dbb Fix unused test 2023-08-21 16:52:26 -05:00
Yuri D'Elia d69ce77503 🐛 Fixes for G2/G3 arcs (#26170) 2023-08-21 14:39:49 -05:00
thinkyhead d1803ec044 [cron] Bump distribution date (2023-08-21) 2023-08-21 00:19:10 +00:00
Scott Lahteine f2665e597f 🎨 FTDI cleanup 2023-08-20 13:47:43 -05:00
thinkyhead db5ead4230 [cron] Bump distribution date (2023-08-20) 2023-08-20 00:19:51 +00:00
GHGiampy f7d5188b2f 🐛 Fixes for ProUI, build rename (#26177)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-08-19 15:53:45 -05:00
thinkyhead 1d17c34e12 [cron] Bump distribution date (2023-08-18) 2023-08-18 00:18:38 +00:00
Vovodroid 49ead19d00 🔧 Reversible file alpha sorting (#26130)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-08-17 18:13:10 -05:00
thinkyhead 7e7dcb8692 [cron] Bump distribution date (2023-08-16) 2023-08-16 06:08:59 +00:00
Scott Lahteine cf50240e82 📝 Update INO (c) 2023-08-15 21:03:42 -05:00
thinkyhead 79f6d9bdac [cron] Bump distribution date (2023-08-14) 2023-08-14 00:19:27 +00:00
Martin Turski 6af6060aa0 🔧 Configurable SD card retry/timeout (#25340)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-08-13 15:57:38 -05:00
thinkyhead 2bac7835e8 [cron] Bump distribution date (2023-08-08) 2023-08-08 00:22:24 +00:00
EvilGremlin fd41757aef 🐛 Fix MKS Robin Mini servo timer (#26150) 2023-08-07 16:54:27 -05:00
Giuliano Zaro f338f65bdf 🚸 Adjust ColorUI chamber bmp (#26149) 2023-08-07 16:51:22 -05:00
Miguel Risco-Castillo 867f5e9069 🚸 UI Sound off/on with M300 E<0|1> (#26142) 2023-08-07 16:16:33 -05:00
Miguel Risco-Castillo 88f5e2c639 🐛 Fix UBL probe_entire_mesh skips points (#26141)
Fixes #26132
2023-08-07 16:11:12 -05:00
Keith Bennett ca0209b868 🔨 Fix USB FD env names (#26131) 2023-08-07 16:00:50 -05:00
Ari-SSO 4f691e622f 🩹 PROBING_TOOL followup (#26122)
Followup to #24411

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-08-07 04:35:22 -05:00
Scott Lahteine fecadaca82 🔧 Clarify WIFISUPPORT (#26097) 2023-08-07 04:24:04 -05:00
Aleks 709def5e7b 🩹 Fix M3 uninitialized warning (#26091) 2023-08-07 04:09:26 -05:00
narno2202 a5e4b4bd7d 🚸 FT_MOTION menu updates (#26083) 2023-08-07 03:30:24 -05:00
thinkyhead a817794444 [cron] Bump distribution date (2023-08-07) 2023-08-07 06:51:07 +00:00
Mark ffef8f1b29 🚸 BD Sensor Z axis stop height (#26015) 2023-08-06 23:33:20 -05:00
Bart Meijer 205a679959 ️ SAMD21 LCD uses HW SPI with media (#26012) 2023-08-06 23:12:30 -05:00
lukasradek b956001d81 🚸 Update LCD Manual Leveling display (#26088) 2023-08-06 22:08:35 -05:00
Keith Bennett 1dd3c9e73f 📝 STM32G0B0 SKR Mini E3 V3.0 / Manta M4P (#26087) 2023-08-06 22:04:11 -05:00
Scott Lahteine 8d74a63e4b 📝 Update a config comment 2023-08-06 21:04:40 -05:00
thinkyhead 27fd97a8bb [cron] Bump distribution date (2023-08-06) 2023-08-06 00:21:12 +00:00
magicmaker3 4d89db5209 MM-JOKER (ESP32) board (#25897) 2023-08-05 18:10:49 -05:00
Pagliarulo Onofrio f66323ecfb Geeetech GT2560 V4.1B board (#25888) 2023-08-05 00:03:10 -05:00
Giuliano Zaro 863198a73f VOLUMETRIC_EXTRUDER_LIMIT_MAX (#25884) 2023-08-04 23:56:40 -05:00
Scott Lahteine ad112b4d3d 🐛 Fix case TRRunaway 2023-08-04 23:49:38 -05:00
thinkyhead c088081c00 [cron] Bump distribution date (2023-08-05) 2023-08-05 00:54:22 +00:00
Alexey D. Filimonov 06d46a0ef9 AUTO_POWER_SPINDLE_LASER (#25739) 2023-08-04 19:07:56 -05:00
Scott Lahteine 27e68a61fa 🧑‍💻 Update some SDSUPPORT 2023-08-04 18:29:52 -05:00
Dmitry Pogrebnyak 4e31fa66e2 STATUS_HEAT_POWER (#25268) 2023-08-04 14:59:17 -05:00
InsanityAutomation 6128d61186 Merge branch 'bugfix-2.1.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.1.x 2023-08-04 09:47:12 -04:00
thinkyhead 87231b625f [cron] Bump distribution date (2023-08-04) 2023-08-04 06:06:04 +00:00
Martin Turski 3baa318ec7 🧑‍💻 Option to reset AVR pin states (#25364)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-08-03 22:56:40 -05:00
Martin Turski 820d2b58b3 🚸 Option to report temperature on error (#25341)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-08-03 21:40:38 -05:00
thinkyhead fe4819a9c1 [cron] Bump distribution date (2023-08-03) 2023-08-03 08:45:07 +00:00
Scott Lahteine 8ae19e45d6 🔨 Prevent variant overwrite
Co-Authored-By: Martin Turski <turningtides@outlook.de>
2023-08-03 01:28:23 -05:00
ellensp aaa590855a 📝 E3S1PRO is T5L (#26143) 2023-08-02 22:55:29 -05:00
thinkyhead a629471ed7 [cron] Bump distribution date (2023-08-02) 2023-08-02 06:06:02 +00:00
Scott Lahteine bed26734a2 🔧 More endstops refactoring (#25758) 2023-08-01 23:03:06 -05:00
thinkyhead 5da7143fe5 [cron] Bump distribution date (2023-07-30) 2023-07-30 00:24:18 +00:00
ellensp 2c9bc872e7 🔧 Check AVR Rx/Tx conflict w/ LCD_EN (#26069) 2023-07-29 18:34:16 -05:00
ellensp abd1896ce2 🔧 STM32 support 9 UARTs (#26072) 2023-07-29 18:30:56 -05:00
thinkyhead 347a7dc71e [cron] Bump distribution date (2023-07-29) 2023-07-29 00:21:43 +00:00
Scott Lahteine ae9f2710f0 🔨 Old renamed AVRs 2023-07-28 16:53:01 -05:00
Scott Lahteine 2a82ca87b0 🩹 Fix ProUI compile without Advanced Pause 2023-07-27 23:03:36 -05:00
thinkyhead 6f8178598f [cron] Bump distribution date (2023-07-28) 2023-07-28 00:21:36 +00:00
Scott Lahteine 6cc4dd10bc 🐛 Fix hotend idle timeout checks 2023-07-27 17:20:09 -05:00
lukasradek d036097bca 🚸 Fix HD44780 EDIT_ITEM position (#26073) 2023-07-27 16:08:21 -05:00
thinkyhead 6ba50aa6ea [cron] Bump distribution date (2023-07-27) 2023-07-27 00:21:22 +00:00
Giuliano Zaro fdad658e5f 🐛 Fix runout extra length (#26082)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
Co-authored-by: justvlade <7622616+justvlade@users.noreply.github.com>
2023-07-26 18:38:59 -05:00
InsanityAutomation 6657c44cc7 Merge branch 'bugfix-2.1.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.1.x 2023-07-26 11:52:43 -04:00
thinkyhead 79be07f9a4 [cron] Bump distribution date (2023-07-24) 2023-07-24 06:06:23 +00:00
ellensp 5bcaae62f2 ️ Compact RGB565 TFT boot images (#26011)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-07-23 22:31:39 -05:00
thinkyhead e451dec674 [cron] Bump distribution date (2023-07-22) 2023-07-22 06:05:47 +00:00
ellensp 6379d4dbca 🩹 Suppress G33 string warning (#26095) 2023-07-21 22:05:04 -05:00
thinkyhead 91c6a7180d [cron] Bump distribution date (2023-07-21) 2023-07-21 06:06:24 +00:00
Scott Lahteine 9135e3f7d3 🚸 Revert M206 Home Offset behavior (#25996) 2023-07-20 21:10:03 -05:00
Scott Lahteine a0e3dea8b8 🚸 ColorUI Touch Calibrate in CW order 2023-07-20 20:28:45 -05:00
thinkyhead 6bc42300a1 [cron] Bump distribution date (2023-07-20) 2023-07-20 06:06:07 +00:00
Scott Lahteine 45193b4a1d 🔥 Always use ISR for BABYSTEPPING (#26035) 2023-07-19 21:12:32 -05:00
thinkyhead 885e9cc057 [cron] Bump distribution date (2023-07-18) 2023-07-18 00:41:02 +00:00
Alexander Gavrilenko 244de2458a 🧑‍💻 Improve TFT Color UI layout / theme (#26077)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-07-17 02:53:36 -05:00
thinkyhead 4d6e5c12b3 [cron] Bump distribution date (2023-07-17) 2023-07-17 06:20:28 +00:00
Scott Lahteine a5d47f84ae 🎨 Rename Helvetica 14 (2) 2023-07-17 01:01:36 -05:00
Scott Lahteine 5fd0247239 🎨 Rename Helvetica 14 (1) 2023-07-17 01:01:14 -05:00
Scott Lahteine 821d77fe4c 🎨 Misc. comment open 2023-07-16 23:44:03 -05:00
Keith Bennett fef772ef29 🩹 Fix SPI TFT build on SKR V2 & V3/EZ (#26041)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-07-16 23:32:16 -05:00
Scott Mikutsky 3815157214 🐛 Ensure BLTouch deploy in HS Mode (#26033) 2023-07-16 23:29:56 -05:00
thinkyhead 810c1693ac [cron] Bump distribution date (2023-07-16) 2023-07-16 06:08:45 +00:00
Andrew fc2272c4b4 🩹 Fix, clean up ProUI, JyersUI (#26078)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-07-15 20:10:42 -05:00
tombrazier 45f7ebb92b 🩹 Fix Input Shaping "enable" for SHAPING_FREQ_[XY] == 0 (#26075) 2023-07-15 20:06:21 -05:00
thinkyhead 28f69a052c [cron] Bump distribution date (2023-07-15) 2023-07-15 00:26:39 +00:00
Keith Bennett ef3054d1a8 BTT Octopus Pro V1.1 (STM32H723ZE) (#26043) 2023-07-14 18:24:17 -05:00
thinkyhead bcf61cc91c [cron] Bump distribution date (2023-07-06) 2023-07-06 00:27:11 +00:00
Giuliano Zaro 57d26f7e4f 🩹 Fix HOST_STATUS_NOTIFICATIONS compile (#26040) 2023-07-05 01:21:54 -05:00
thinkyhead 67a9a7e66f [cron] Bump distribution date (2023-07-05) 2023-07-04 20:30:07 -05:00
Scott Lahteine 16f19b2c1f 🩹 Fix ProUI tramming 2023-07-04 20:30:07 -05:00
Scott Lahteine ed4e22b548 🧑‍💻 print_pos => print_xyz 2023-07-04 18:44:14 -05:00
Keith Bennett 929497d527 📝 Update config URLs (#26049) 2023-07-04 16:07:56 -05:00
Keith Bennett f479f8377d 🎨 Clean up TFT Colors (#26050) 2023-07-04 15:25:26 -05:00
thinkyhead 1feb70c91b [cron] Bump distribution date (2023-07-04) 2023-07-04 15:17:53 -05:00
Scott Lahteine 179260878f 🎨 Misc. fixes and formatting 2023-07-04 15:17:53 -05:00
thinkyhead 7b8a2180ff [cron] Bump distribution date (2023-07-03) 2023-07-03 00:25:59 +00:00
Alexander Gavrilenko 3ea87ad54c SPI TFT / Touchscreen for STM32H7 (#25784)
Co-authored-by: thisiskeithb <13375512+thisiskeithb@users.noreply.github.com>
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-07-01 20:16:12 -05:00
Scott Lahteine c483fe76c7 🩹 Fix ProUI _remain_time
Followup to #25982
2023-07-01 20:01:45 -05:00
Scott Lahteine b50add4694 🔨 Wrapper for GCC < 8 2023-07-01 19:54:39 -05:00
thinkyhead 275642b297 [cron] Bump distribution date (2023-07-02) 2023-07-02 00:31:20 +00:00
Scott Lahteine 38e92b522b 📝 mm/m => mm/min 2023-07-01 18:56:53 -05:00
Scott Lahteine 7f5b0b4008 🩹 Define drawTrinamicConfigMenu
Followup to #25982
2023-07-01 18:26:51 -05:00
Scott Lahteine 60f74f3cb3 🔨 Suppress truncation warning 2023-07-01 18:20:32 -05:00
Scott Lahteine 1a241e6e86 🐛 Fix M105 (MString append TS) and EEPROM ver
Followup to #24390
2023-07-01 17:51:13 -05:00
Scott Lahteine 4985acafad 🐛 Prevent MString infinite recursion (#26037)
Followup to #24390
2023-07-01 04:33:53 -05:00
Anson Liu f9c8703e77 🩹 Fix missing include cycles.h (#25927) 2023-07-01 02:19:16 -05:00
Christophe Huriaux b77e2a5020 Ender 3 S1 Pro/Plus stock touchscreen (#25905)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-06-30 23:06:08 -05:00
thinkyhead f766a90f5f [cron] Bump distribution date (2023-07-01) 2023-07-01 00:53:49 +00:00
Scott Lahteine 0878b99b2c 🌐 Language Import/Export (#25889) 2023-06-30 19:21:56 -05:00
Keith Bennett 1bc155e810 🎨 Simplify BTT Octopus Max EZ LCD Pins (#26019) 2023-06-30 19:21:37 -05:00
Scott Lahteine f14f1be168 🎨 Standardize naming (ProUI) (#25982) 2023-06-30 19:16:00 -05:00
thinkyhead 7247acdece [cron] Bump distribution date (2023-06-30) 2023-06-30 00:24:45 +00:00
narno2202 7b23fd3548 🐛 Fix FT Motion runout in progress (#26020) 2023-06-29 17:06:05 -05:00
Keith Bennett d9349caeee ️ Ethernet Buffer for Input Shaping on LPC (#26027) 2023-06-29 15:27:25 -05:00
Andrew 97e15812fa 🔨 Makefile + 256K Creality Maple + Heater IDs (#26018) 2023-06-29 12:21:14 -05:00
Krzysztof Błażewicz cb12114a7e 🩹 Fix JyersUI typos (#26029)
Followup to #24390
2023-06-29 02:18:32 -05:00
thinkyhead aee8e15fd2 [cron] Bump distribution date (2023-06-29) 2023-06-29 00:25:22 +00:00
Giuliano Zaro 6474773555 🐛 Fix AD4985 with 5V input, add AD595 3.3V warning (#26021)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-06-28 17:06:50 -05:00
Krzysztof Błażewicz be18edd604 🚸 JyersUI MPC menu (#26017)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-06-27 22:51:47 -05:00
Scott Lahteine bbfaf7474c 🎨 CrealityDWIN => JyersDWIN (#26026) 2023-06-27 21:44:42 -05:00
Scott Lahteine 46b5753f56 🎨 Indent temp structs 2023-06-27 20:34:01 -05:00
thinkyhead a5ac50fcbf [cron] Bump distribution date (2023-06-28) 2023-06-28 00:25:35 +00:00
Scott Lahteine 574dd34c49 ♻️ String helper class (#24390) 2023-06-27 13:19:36 -05:00
thinkyhead 4a734e4de4 [cron] Bump distribution date (2023-06-26) 2023-06-26 00:26:36 +00:00
Katelyn Schiesser 402c4ef5d3 🚸 M86-M87 Hotend Idle Timeout (#25015)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-06-25 17:32:56 -05:00
thinkyhead 0138aff890 [cron] Bump distribution date (2023-06-25) 2023-06-25 12:07:25 +00:00
Scott Lahteine f281fb473d 🎨 Minor code cleanup 2023-06-25 01:31:07 -05:00
thinkyhead a256e47b9c [cron] Bump distribution date (2023-06-24) 2023-06-24 12:07:28 +00:00
Scott Lahteine 9bf95418a7 🐛 Fix TFT_LTDC::writeReg
Followup to #25939
2023-06-24 02:57:58 -05:00
InsanityAutomation 52c37ee699 Merge branch 'bugfix-2.1.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.1.x 2023-06-23 09:26:59 -04:00
thinkyhead 60f591f3b6 [cron] Bump distribution date (2023-06-23) 2023-06-23 12:11:03 +00:00
Miguel Risco-Castillo 858916d628 🚸 Update DWIN ProUI (#26003) 2023-06-23 04:57:22 -05:00
mjbogusz 2218bab542 🚸 Color UI remaining time (#24843) 2023-06-23 04:56:34 -05:00
narno2202 a58e530f92 🩹 Fix 'M493 S12' (#26007) 2023-06-23 04:52:10 -05:00
Scott Lahteine 1fbeac7b52 🎨 Adjust TFT code/comments 2023-06-23 01:59:11 -05:00
thinkyhead 18ccc40443 [cron] Bump distribution date (2023-06-22) 2023-06-22 12:06:59 +00:00
Scott Lahteine 8c9172cf5d 🍻 Fixed-Time Motion integration (#25719) 2023-06-22 02:54:21 -05:00
thinkyhead 2dc76689ea [cron] Bump distribution date (2023-06-20) 2023-06-20 00:21:56 +00:00
Scott Lahteine 91401d7e5f 🔧 Move non-DUE conditions 2023-06-19 15:07:23 -05:00
Keith Bennett 733209f9a2 🔧 MPC adjustments (#25986) 2023-06-19 00:12:50 -05:00
thinkyhead d79b42c710 [cron] Bump distribution date (2023-06-19) 2023-06-19 00:24:00 +00:00
Mark 441416728c 🚸 Bed distance sensor improvements (#25847) 2023-06-18 04:18:08 -05:00
Andrew dd1792bdfc 🔨 Update CMakeLists.txt (#25983) 2023-06-17 23:19:28 -05:00
thinkyhead 927b3cc41a [cron] Bump distribution date (2023-06-18) 2023-06-18 00:25:52 +00:00
ellensp c180a99c79 📝 Update BTT SKR V3 board comments (#25973) 2023-06-17 16:44:49 -05:00
Giuliano Zaro a3df3d40ee 🐛 Fix G2/G3 limiting_speed (#25988) 2023-06-17 15:55:02 -05:00
discip 1e5c279da3 🔨 Fix marlin_STM32H723VG mcu value (#25991)
Followup to #25921
2023-06-17 15:53:03 -05:00
EvilGremlin 5b8b8e005b 🔧 BLTOUCH_HS_MODE hex value check (#25992) 2023-06-17 15:49:22 -05:00
Scott Lahteine 238951a966 🎨 More more lowercase (partial ProUI)
Followup to #25939
2023-06-16 22:26:32 -05:00
thinkyhead 78b342661a [cron] Bump distribution date (2023-06-17) 2023-06-17 00:22:04 +00:00
Scott Lahteine 41a5fbb16a 🎨 More lowercase
Followup to #25939
2023-06-16 18:13:46 -05:00
thinkyhead eca80db9b6 [cron] Bump distribution date (2023-06-16) 2023-06-16 00:24:24 +00:00
ellensp 8261af3010 BTT RAMPS 1.6+ (#25970) 2023-06-14 19:57:15 -05:00
Keith Bennett 9728d79ade 📝 Document Manta E3 EZ / E3V2 LCD custom wiring (#25976) 2023-06-14 19:43:24 -05:00
Keith Bennett 067091458a 🎨 Group STM32G0 pins includes (#25977) 2023-06-14 19:41:43 -05:00
Scott Lahteine 166ed28995 🎨 Lowercase followup
Followup to #25939
2023-06-14 19:37:54 -05:00
thinkyhead 5cfe3af0ef [cron] Bump distribution date (2023-06-15) 2023-06-15 00:26:48 +00:00
Scott Lahteine d26955bde6 🔧 Sanity check IA_CREALITY mesh size 2023-06-14 19:06:30 -05:00
Scott Lahteine c3694f1c03 🎨 Lowercase methods, functions, data members (#25939)
For: TFT, DGUS, MarlinUI, Anycubic, JyersUI, CrealityUI
2023-06-14 17:24:50 -05:00
thinkyhead 1726ba5bda [cron] Bump distribution date (2023-06-13) 2023-06-13 00:23:25 +00:00
Keith Bennett aa2f4051bb 🔥 Remove VAkE 403D (#25969) 2023-06-12 16:39:49 -05:00
Scott Lahteine 2ef71c6eba ♻️ Simplify SERIAL_ECHO (#25928)
Since this increases AVR code size, try to optimize further.
2023-06-12 16:38:14 -05:00
thinkyhead d9d2dae883 [cron] Bump distribution date (2023-06-12) 2023-06-12 00:25:11 +00:00
Keith Bennett bea1a914be 🔨 SKR Mini E3 v3.0.1 XFER (#25955) 2023-06-11 16:49:37 -05:00
thinkyhead 85067e14b5 [cron] Bump distribution date (2023-06-11) 2023-06-11 00:29:06 +00:00
Keith Bennett 00ab015de7 🔨 Firmware rename followup (#25966)
Followup to #25957
2023-06-10 19:20:50 -05:00
thinkyhead b5d3d0141f [cron] Bump distribution date (2023-06-10) 2023-06-10 00:22:22 +00:00
ellensp 3706c16729 🐛 Fix dummy thermistors 998-999 (#25956) 2023-06-09 02:59:23 -05:00
Scott Lahteine 0ed46406d1 🔨 Simpler distinct firmware rename (#25957) 2023-06-09 02:56:25 -05:00
Bart Meijer 82ddd55a1a 🩹 Conditional u8g for SAMD21 (#25947) 2023-06-08 21:55:26 -05:00
Miguel Risco-Castillo 34e23bcf95 🐛 Fix _MINMAX_TEST typo (#25954) 2023-06-08 20:47:35 -05:00
thinkyhead f3cda01b95 [cron] Bump distribution date (2023-06-09) 2023-06-09 00:30:56 +00:00
Scott Lahteine 2a79aad2dd 🔨 Fix serial port #error text 2023-06-08 19:22:52 -05:00
Scott Lahteine bbbd6045cb 🔨 Update STM32Hxx boards/variants
Followup to #25934
2023-06-08 19:22:52 -05:00
Dmitry Plastinin 683916e17a 🚸 Portrait TS35 move axis screen (#25945) 2023-06-07 23:14:34 -05:00
Scott Lahteine 9360e13cdd 🚸 General TFT cleanup 2023-06-07 22:46:25 -05:00
Keith Bennett 9d830d7207 🔨 Clean up some BTT envs, etc. (#25934)
Followup to #25921

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-06-07 22:16:30 -05:00
Scott Lahteine 54a82b4337 🚸 Fix TFT menu positioning (#25942)
Co-authored-by: Ed <751406+helakejr@users.noreply.github.com>
2023-06-07 20:58:55 -05:00
Scott Lahteine d1e995670d 🔧 Z-MIN as CREALITY V25 S1 probe 2023-06-07 20:29:39 -05:00
thinkyhead 10947a463b [cron] Bump distribution date (2023-06-08) 2023-06-08 00:23:27 +00:00
Keith Bennett e8f5f9d732 🔨 Teensy 4.1 pins env check (#25937) 2023-06-07 03:03:35 -05:00
Giuliano Zaro 984f9fe7d6 🌐 Update Italian language (#25940) 2023-06-07 03:01:07 -05:00
thinkyhead 322d5dc29c [cron] Bump distribution date (2023-06-07) 2023-06-07 00:25:18 +00:00
Scott Lahteine 8f1d80b0ba 🧑‍💻 Use Flags<> for runout (#25938) 2023-06-06 15:30:28 -05:00
Scott Lahteine 35016633d8 🩹 Conditional include probe.h 2023-06-06 02:58:28 -05:00
Scott Lahteine 4b8e4ef38e ️ Mixer label in PROGMEM 2023-06-05 23:56:22 -05:00
Scott Lahteine 17cc5fa872 🧑‍💻 Suppress narrowing warnings
Followup to #25924
2023-06-05 21:09:08 -05:00
Scott Lahteine a6b32a5a91 🧑‍💻 Bypass error in build_example 2023-06-05 20:39:20 -05:00
Scott Lahteine e116a99eda 🩹 Fix JyersUI corner pos
Followup to #25631
2023-06-05 20:24:12 -05:00
thinkyhead bfd6be3799 [cron] Bump distribution date (2023-06-06) 2023-06-06 00:24:34 +00:00
Scott Lahteine 6a29d5d5af 🧑‍💻 Fix mfconfig trailing space 2023-06-05 17:25:42 -05:00
Scott Lahteine fbc5bd0d04 🩹 Wrap HAS_DISPLAY for if()
Followup to #24877
2023-06-05 16:24:20 -05:00
Scott Lahteine 7680fe2b59 🧑‍💻 Dir change is AxisBits
Followup to #25761
2023-06-05 16:01:32 -05:00
Scott Lahteine 70288c6c4f 🎨 Detab C/C++ 2023-06-05 01:02:56 -05:00
Roi Rodríguez Huertas 3b681f7b74 🔧 TMC Driver axis baud for Soft Serial (#25664) 2023-06-05 00:13:57 -05:00
thinkyhead 6e8035e5aa [cron] Bump distribution date (2023-06-05) 2023-06-05 00:24:02 +00:00
kisslorand f8423f9da0 🩹 Fix D576 buffer underrun reporting (#25931) 2023-06-04 04:49:27 -05:00
Andrew 1a2816284c ✏️ Fix LCD contrast typo (#25929) 2023-06-04 04:20:07 -05:00
thinkyhead f8c5152369 [cron] Bump distribution date (2023-06-04) 2023-06-04 00:27:30 +00:00
Giuliano Zaro 6136e48df5 🐛 Fix M25/M125 for LCDs with ui.resume_print (#24877) 2023-06-03 16:09:29 -05:00
Manuel McLure b8655ca0ed 🔧 BTT SKR 3 has onboard endstop pullups (#24876) 2023-06-03 15:39:41 -05:00
Scott Lahteine ba08dcfb76 🧑‍💻 Fix narrowing conversions (#25924) 2023-06-03 04:40:07 -05:00
Keith Bennett ac954b57f7 🩹 Endstop hit state followup (#25885)
Followup to #25574
2023-06-02 22:50:45 -05:00
ellensp 739f1027f8 🔨 STM32H723VG (1024KB) (#25921) 2023-06-02 22:47:57 -05:00
ellensp a6b56d171d 🎨 Lowercase followup (#25923)
Followup to #25914
2023-06-02 22:37:29 -05:00
thinkyhead ad0d700a3e [cron] Bump distribution date (2023-06-03) 2023-06-03 00:22:16 +00:00
Scott Lahteine 86c811660e 🧑‍💻 Remove LOOP macros (#25917) 2023-06-02 14:30:34 -05:00
Scott Lahteine 2691167afe 🧑‍💻 Dump BOTH and EITHER macros (#25908) 2023-06-02 14:26:02 -05:00
Scott Lahteine 32be4065ef 🧑‍💻 numtostr use functions 2023-06-02 14:22:29 -05:00
Scott Lahteine bc385122e9 🎨 Lowercase method / data member names (#25914) 2023-06-02 13:34:13 -05:00
Scott Lahteine e45eddfd6c 🔨 Fix pins debugging for Simulator 2023-06-02 12:46:23 -05:00
alextrical 5004159550 🔨 Clarify env error (#25915) 2023-06-02 11:32:43 -05:00
Scott Lahteine d9659d3177 📝 M122 comment 2023-06-01 22:58:17 -05:00
thinkyhead 2de2185d97 [cron] Bump distribution date (2023-06-02) 2023-06-02 01:38:48 +00:00
I3DBeeTech 49134a9467 🔧 Update LCD with NeoPixel Contrast (#25893) 2023-06-01 18:28:34 -05:00
Scott Lahteine 6044cb9955 🌐 Remove unused strings 2023-06-01 17:39:08 -05:00
EvilGremlin ded810cebf 🌐 Update Russian translation (#25840) 2023-06-01 17:35:42 -05:00
Scott Lahteine 9e0dcd4a2b 🧑‍💻 ExtUI::onLevelingStart/Done for all leveling (#25913) 2023-06-01 16:53:02 -05:00
Scott Lahteine ad23b8c559 🚸 Probe Wizard display fix 2023-06-01 14:54:23 -05:00
Keith Bennett 3999d67e51 🔧 Default has Heated Bed (#25895)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-06-01 14:44:19 -05:00
thinkyhead 67f0d6ae5e [cron] Bump distribution date (2023-05-30) 2023-05-30 00:33:07 +00:00
Scott Lahteine 47616c7dfa 🔨 Install 'heatshrink' if needed (#25896) 2023-05-29 19:00:09 -05:00
DejitaruJin d926d4dea4 🩹 Fix and improve GT2560 pins (#25890)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-28 20:22:00 -05:00
thinkyhead b4ba3dd7f3 [cron] Bump distribution date (2023-05-29) 2023-05-29 00:21:30 +00:00
Keith Bennett 0b4500155e 🩹 Update KEDI / GODI LCD_PINS_EN pin (#25886) 2023-05-28 15:29:36 -05:00
thinkyhead ef93b401c3 [cron] Bump distribution date (2023-05-27) 2023-05-27 00:22:42 +00:00
Scott Lahteine 154e48ba22 🎨 Misc. spacing 2023-05-26 18:59:12 -05:00
Scott Lahteine f73fe76b6c 🌐 Language export to CSV 2023-05-26 18:17:37 -05:00
thinkyhead d20ce5ff0a [cron] Bump distribution date (2023-05-26) 2023-05-26 00:21:31 +00:00
EvilGremlin a3eace117c 🧑‍💻 Improve missing translations script (#25841)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-25 02:32:04 -05:00
Scott Lahteine 772e19aab9 EP_BABYSTEPPING (#25869) 2023-05-24 22:10:40 -05:00
Scott Lahteine 1a4e208c69 🩹 Fix card.ls call (in easythreed_ui)
Fix regression in #24679
2023-05-24 21:24:31 -05:00
thinkyhead e2a7249907 [cron] Bump distribution date (2023-05-25) 2023-05-25 00:20:08 +00:00
ellensp eb439b93a5 🩹 Fix ESP32 compile error (#25873) 2023-05-24 02:58:11 -05:00
Scott Lahteine 317450af32 🧑‍💻 Updated toolchain for ststm32@~14.1.0 (#25846) 2023-05-24 02:53:12 -05:00
Scott Lahteine 37d0f49a82 🧑‍💻 Misc. ExtUI LCD cleanup (#25872) 2023-05-24 01:05:55 -05:00
thinkyhead 9036cec562 [cron] Bump distribution date (2023-05-24) 2023-05-24 00:21:21 +00:00
Scott Lahteine e7a5d4d416 Update checkout actions 2023-05-23 03:15:02 -05:00
thinkyhead e82ec734d9 [cron] Bump distribution date (2023-05-23) 2023-05-23 00:21:34 +00:00
alextrical 9ceecefae2 🔨 Fix BTT EBB42 V1.1 compile with -flto (#25849) 2023-05-21 20:38:28 -05:00
thinkyhead 8cd2b0976a [cron] Bump distribution date (2023-05-22) 2023-05-22 00:27:46 +00:00
Scott Lahteine ae3b00db74 🧑‍💻 Fall back to SPI0 with YHCB2004 (#25856) 2023-05-21 17:35:41 -05:00
Andrew d22ce55cd5 🩹 Fix ProUI Manual Mesh / UBL Viewer (#25858) 2023-05-21 17:34:19 -05:00
Scott Lahteine ea63ac8f4d 🩹 Fix TFT LVGL compile error (#25865)
Fixes regression from #24302
2023-05-21 08:38:42 -05:00
thinkyhead 06b1f85514 [cron] Bump distribution date (2023-05-21) 2023-05-21 00:23:00 +00:00
Scott Lahteine 5ed307ceb8 📝 MKS TinyBee pins header 2023-05-20 04:28:33 -05:00
Scott Lahteine 5bc84bf08c 🚸 Improve EEPROM validation (#25860) 2023-05-19 23:30:48 -05:00
thinkyhead 26dfbd0660 [cron] Bump distribution date (2023-05-20) 2023-05-20 00:19:33 +00:00
Scott Lahteine 7d5bd4dfbc 🎨 Cutter pins cleanup 2023-05-19 06:54:48 -05:00
thinkyhead 48c14f1109 [cron] Bump distribution date (2023-05-19) 2023-05-19 00:20:49 +00:00
Scott Lahteine 7249c3c46f 🩹 M493 report followup 2023-05-18 15:48:10 -05:00
I3DBeeTech a886906f01 I3DBEEZ9 board (#25614) 2023-05-18 03:23:29 -05:00
Scott Lahteine 74a6f5961b 🔨 Fix Windows path backslash treated as escape
Co-Authored-By: Luc <8822552+luc-github@users.noreply.github.com>
2023-05-18 03:10:26 -05:00
thinkyhead 51fbe03016 [cron] Bump distribution date (2023-05-18) 2023-05-18 06:06:02 +00:00
Krzysztof Błażewicz b2f372b20f 🚸 Unify edit limits for some E3V2 LCDs (#25045)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-18 00:38:21 -05:00
thinkyhead 3b2341fb61 [cron] Bump distribution date (2023-05-17) 2023-05-17 00:22:49 +00:00
ellensp 3136435c19 🐛 Fix MKS Robin Nano 1.3 F4 pin collision (#25838) 2023-05-16 13:50:57 -05:00
Scott Lahteine 060ddf5e95 🚸 Support Bed Leveling Mesh > 16x16
Co-Authored-By: raTmole <ratmole@users.noreply.github.com>
2023-05-16 02:54:52 -05:00
Giuliano Zaro df078cac92 🔧 TMC Config Inheritance followup (#25783) 2023-05-16 02:46:19 -05:00
Scott Lahteine ed66f498eb 🚸 Fixed-Time Motion EEPROM and Menu (#25835) 2023-05-16 02:46:19 -05:00
Scott Lahteine fadd60441e 🩹 Improve edit menu rounding 2023-05-16 01:32:36 -05:00
Scott Lahteine 25ddde0394 🧑‍💻 Change Marlin DIR bits: 1=Forward, 0=Reverse (#25791) 2023-05-15 22:00:15 -05:00
lukasradek 48496dfec1 ✏️ Fix pin debug ternary (#25832) 2023-05-15 20:49:45 -05:00
Scott Lahteine 6e5f41fe6b 🧑‍💻 Serial ternary args, etc. 2023-05-15 19:50:36 -05:00
thinkyhead dd184cf3c2 [cron] Bump distribution date (2023-05-16) 2023-05-16 00:20:38 +00:00
Andrew 99e38c40be 🩹 Ensure pin_is_protected is defined (#25829) 2023-05-15 16:24:36 -05:00
Scott Lahteine 46e8b9cad9 🔧 Disable FT Motion by default 2023-05-15 00:03:53 -05:00
ellensp 2e24637bd6 "One Click" Print newest file (#25781)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-14 20:48:55 -05:00
Scott Lahteine d17d86d6a5 🧑‍💻 M43 updates 2023-05-14 19:49:57 -05:00
Scott Lahteine b364e44716 📌 TH3D EZBoard SD_DETECT_PIN 27 2023-05-14 19:48:10 -05:00
thinkyhead 1c5426d4af [cron] Bump distribution date (2023-05-15) 2023-05-15 00:22:01 +00:00
ellensp e66cd41654 🐛 Safe Delay for ProUI startup animation (#25827) 2023-05-14 16:47:19 -05:00
Scott Lahteine 5201869a55 🧑‍💻 IA RTS refactor 2023-05-13 21:44:38 -05:00
thinkyhead 18e63ad880 [cron] Bump distribution date (2023-05-14) 2023-05-13 21:44:30 -05:00
Scott Lahteine 4a2db0f706 🧑‍💻 ftdi_language 2023-05-13 19:30:52 -05:00
Scott Lahteine f97a813a2a NUM_REDUNDANT_FANS too 2023-05-13 18:09:48 -05:00
Scott Lahteine 4e1bfc4e0d 🎨 Misc. tweaks to HALs 2023-05-13 18:00:21 -05:00
Vert 5859ff0280 NUM_REDUNDANT_FANS (#25808)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-13 16:51:12 -05:00
ellensp 40aa398285 🐛 Fix large edit value to encoder conversion (#25812) 2023-05-13 16:43:57 -05:00
Giuliano Zaro e89e67fde0 🧑‍💻 Assume Auto Fans < HOTENDS (#25815) 2023-05-13 16:36:23 -05:00
Giuliano Zaro de78b60252 🩹 Remove extraneous MPC temp check (#25816) 2023-05-13 16:31:31 -05:00
Giuliano Zaro 30c3daf031 🔧 No DISABLE_OTHER_EXTRUDERS if < 2 steppers (#25818) 2023-05-13 16:28:17 -05:00
Alexey D. Filimonov d5fdbb89ea 🚸 TFT optional axes/extruder (#25624)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-13 16:25:36 -05:00
Giuliano Zaro 06aed792c0 🩹 MMU2 unload followup (#25825)
Followup to #20147
2023-05-13 16:23:23 -05:00
Scott Lahteine 18005cb91e 🧑‍💻 Constexpr types.h operators (#25811) 2023-05-13 16:12:59 -05:00
Scott Lahteine e41dc273c9 🔧 Update config.ini and script 2023-05-12 20:30:49 -05:00
thinkyhead e7de3b92c9 [cron] Bump distribution date (2023-05-13) 2023-05-13 00:19:22 +00:00
Scott Lahteine 79b0f31585 🔨 Use 'build_src_filter' (#25810) 2023-05-11 19:39:30 -05:00
thinkyhead 5f89ef99e9 [cron] Bump distribution date (2023-05-12) 2023-05-12 00:25:57 +00:00
StevilKnevil 01f5bd3330 🚸 Improved MPCTEMP autotune (#25503) 2023-05-11 19:09:02 -05:00
Muhammad Arslan 8fb9b5804e Blackpill-based custom board (#25152)
Co-authored-by: striker <striker@gmail.com>
2023-05-11 08:18:24 -05:00
thinkyhead a07b7161e9 [cron] Bump distribution date (2023-05-11) 2023-05-11 00:20:08 +00:00
Chris Bagwell 7707cbf338 🔧 Fix SHAPING_MIN_FREQ check (#25358) 2023-05-10 05:59:28 -05:00
Scott Lahteine 03bb28c277 🎨 Misc. temperature cleanup 2023-05-10 04:25:14 -05:00
ellensp 9cf1a8891f 🩹 Optional X followup (#25804) 2023-05-10 04:19:05 -05:00
Scott Lahteine 53b79f5f70 🩹 No const on return type 2023-05-10 04:05:52 -05:00
thinkyhead 21e3e535a6 [cron] Bump distribution date (2023-05-10) 2023-05-10 00:20:07 +00:00
Giuliano Zaro a6404aca45 🔧 Move SOFT_PWM_SCALE fallback to cpp (#25800)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-09 15:52:59 -05:00
ellensp d52d26b4ef 🔧 Update multi-stepper axis conditionals (#25798)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-09 15:37:34 -05:00
Skopus 3a8809c1a7 KEDI (STM32F1) and GODI (ESP32) boards (#25796) 2023-05-09 15:31:17 -05:00
ellensp 1f9bfc5c74 🚸 Optional X-Axis (#25418)
Co-authored-by: alextrical <35117191+alextrical@users.noreply.github.com>
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-09 13:59:25 -05:00
thinkyhead 3e9848f49c [cron] Bump distribution date (2023-05-09) 2023-05-09 00:27:27 +00:00
Scott Lahteine 70efb515b1 🧑‍💻 PI => M_PI 2023-05-08 18:53:44 -05:00
Scott Lahteine 08207fd086 🧑‍💻 Extend AxisBits 2023-05-08 18:53:44 -05:00
Scott Lahteine c6ea99f4be 🐛 Fix babystep corrupting DIR
Followup to 2538a7c4
2023-05-08 18:53:44 -05:00
ellensp f80e706fad 🔨 MKS Robin2 PIO Env (#25792) 2023-05-08 06:54:46 -05:00
thinkyhead 2ee7ed084b [cron] Bump distribution date (2023-05-08) 2023-05-08 06:06:01 +00:00
Scott Lahteine 1f5b886d12 🩹 Creality F401 Followup
Followup to #25773
2023-05-07 22:06:52 -05:00
Scott Lahteine f207177098 🐛 Fix Babystepping for CoreXZ
Fixes #19988
2023-05-07 21:48:04 -05:00
Scott Lahteine d3ee4eecdf 🩹 Use AxisBits methods 2023-05-07 21:48:04 -05:00
thinkyhead d36f43d80b [cron] Bump distribution date (2023-05-07) 2023-05-07 00:38:13 +00:00
Scott Lahteine 99a9e265b0 🩹 Endstops prelim. followup 2023-05-06 19:15:39 -05:00
Scott Lahteine 12d8108fc6 🚸 Faster default Marlin feedrate 2023-05-06 17:37:54 -05:00
Scott Lahteine d93aa0c384 🐛 Apply direction bits at startup 2023-05-06 17:06:15 -05:00
Scott Lahteine 4528fde7f9 🔧 Apply bootscreen settings to ProUI 2023-05-06 14:57:25 -05:00
Scott Lahteine 97d8a68949 🩹 FT Motion prelim followup 2023-05-06 14:52:58 -05:00
Scott Lahteine 53d06be226 🧑‍💻 Endstops preliminary followup
Followup to #25780
2023-05-06 02:34:58 -05:00
Scott Lahteine af4ba2b1ce 🐛 Minor Fixed-Time Motion patches 2023-05-05 23:58:54 -05:00
Scott Lahteine 40895cbcbb 🔧 Allow TMC_BAUD_RATE override 2023-05-05 20:52:17 -05:00
Scott Lahteine 85325f585a 🧑‍💻 Endstops preliminary work (#25780) 2023-05-05 19:37:13 -05:00
Scott Lahteine 9b883704bc 🚸 Reorder some Menu Items 2023-05-05 19:31:18 -05:00
thinkyhead 2e06e05d7c [cron] Bump distribution date (2023-05-06) 2023-05-06 00:19:16 +00:00
Dmitry Plastinin 9cc16f87e2 🚸 TS35 portrait display (#25629) 2023-05-05 16:05:30 -05:00
Scott Lahteine f8570257f9 🐛 AxisBits union fix 2023-05-05 15:37:27 -05:00
Scott Lahteine 664b35b77c 🧑‍💻 Replace axis_bits_t with AxisBits class (#25761) 2023-05-05 03:03:33 -05:00
Scott Lahteine 2538a7c4d6 🧑‍💻 Move DIR inverting to *_DIR_WRITE 2023-05-05 02:55:03 -05:00
Scott Lahteine 1234e6af52 🧑‍💻 Axis relative flags type 2023-05-05 02:49:21 -05:00
Scott Lahteine 573bc7344b 🎨 NORM_E_DIR => FWD_E_DIR 2023-05-05 02:44:16 -05:00
Scott Lahteine 5abb594f01 🔧 TMC Config Inheritance 2023-05-05 02:27:35 -05:00
Scott Lahteine 673e6d5380 🧑‍💻 Split up stepper.h header 2023-05-05 02:27:35 -05:00
Giuliano Zaro 4e2b5b2523 🩹 Fix Extensible MMU for >8 colors (#25772)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-04 21:30:51 -05:00
thinkyhead e5dfb44fe0 [cron] Bump distribution date (2023-05-05) 2023-05-05 00:19:55 +00:00
Thomas Niccolo Reyes 001d1fd7cb 🚸 Improve MMU2 unload (like original MMU2S) (#20147)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-04 18:09:36 -05:00
Scott Lahteine 6bf789d93f 🎨 Move G28O inside ProUI 2023-05-04 18:05:56 -05:00
thinkyhead cfbd8a2e36 [cron] Bump distribution date (2023-05-04) 2023-05-04 00:20:30 +00:00
Keith Bennett 7642bfbf8b 🐛 Fix TFT Touch Calibration overrides (#25579)
…and other misc. display-related updates

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-03 16:19:32 -05:00
thinkyhead dbed3f1c41 [cron] Bump distribution date (2023-05-03) 2023-05-03 00:20:18 +00:00
Scott Lahteine e1f6435d44 Creality STM32F401RE board (e.g., Ender-5 S1) (#25773) 2023-05-02 17:59:27 -05:00
plampix 21ea9bf50f 🐛 Fix minimal M115, Cap:PROGRESS:0 (#25769)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-05-02 16:50:07 -05:00
ellensp 137ea43422 Creality Ender-2 (Melzi) (#25754) 2023-05-02 16:16:19 -05:00
plampix 9aa69cbc85 Fix G12 Nozzle Clean (#25766)
Followup to #25666
2023-05-02 00:01:44 -05:00
Scott Lahteine 61f0dd2271 🩹 Fix _CAN_HOME for new endstop flags 2023-05-01 22:18:22 -05:00
Scott Lahteine 207535af9d 🔨 Fix Multi-Language Menu criteria 2023-05-01 22:18:22 -05:00
Scott Lahteine 4812ed5053 🎨 Misc. code cleanup 2023-05-01 22:18:22 -05:00
thinkyhead f89fa4cec7 [cron] Bump distribution date (2023-05-02) 2023-05-02 00:24:02 +00:00
Scott Lahteine b042567f76 🩹 Fix TFT sanity error 2023-05-01 18:15:31 -05:00
Scott Mikutsky 4bed8a89db 🐛 Fix STM32 USB disconnect behavior (#25762) 2023-05-01 01:10:46 -05:00
Scott Lahteine 006a9e514b 🩹 NOZZLE_CLEAN_PATTERN_* Followup
Followup to #25666
2023-04-30 23:10:44 -05:00
Scott Lahteine 55cbe15b81 🔧 Remove config.ini obsolete options 2023-04-30 19:40:20 -05:00
thinkyhead 35dd6a3f77 [cron] Bump distribution date (2023-05-01) 2023-05-01 00:22:20 +00:00
Scott Lahteine 9773160639 🔧 Character display has boot screen 2023-04-30 18:32:48 -05:00
Scott Lahteine f246e0d0e4 🔧 Fix X2/Y2 axis pins check 2023-04-30 18:13:59 -05:00
Scott Lahteine 4937a64bcc 🧑‍💻 Use NUM_AXIS_ARRAY 2023-04-30 18:13:59 -05:00
ellensp b88ab391bb 🐛 Fix Ender-2 Stock LCD on MELZI_CREALITY (#25759) 2023-04-30 17:09:54 -05:00
Davide Rombolà 3b50b6aeb1 🔧 Allow BLTOUCH_HS_EXTRA_CLEARANCE == 0 (#25760) 2023-04-30 16:36:47 -05:00
Scott Lahteine ec6bc15d1b 🐛 Fix FT Motion reversed Z 2023-04-29 20:10:33 -05:00
thinkyhead 5aef2c0afa [cron] Bump distribution date (2023-04-30) 2023-04-30 00:22:44 +00:00
Scott Lahteine 4c033c3e47 🧑‍💻 Tweak homing debug 2023-04-29 12:34:56 -05:00
thinkyhead f9db5ab965 [cron] Bump distribution date (2023-04-29) 2023-04-29 00:20:26 +00:00
James Pearson c5a2e41647 🐛 Probe behavior corrections (#25631)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
Co-authored-by: David Fries <2767875+dfries@users.noreply.github.com>
2023-04-28 17:30:15 -05:00
Scott Lahteine 7d95928cbb 🐛 Fix auto pullup/down settings
Followup to #25748
2023-04-28 13:44:40 -05:00
Scott Lahteine a872232b15 🔧 Move MMU section 2023-04-28 11:03:38 -05:00
Scott Lahteine 6323de309f 🔨 Fix LPC faux pins
Followup to #25332
2023-04-28 11:03:34 -05:00
thinkyhead 0e2c5b45ec [cron] Bump distribution date (2023-04-28) 2023-04-28 00:21:29 +00:00
TheSnowfield 959f7308e7 AUTO_REPORT_REAL_POSITION option for M154 (#25738) 2023-04-27 07:37:11 -05:00
Martin Turski 9a7d9e6995 🧑‍💻 Optimize PlatformIO source filtering (#25332)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-27 07:05:24 -05:00
Scott Lahteine 774861b15d 🔧 Endstops followup 2023-04-26 20:04:01 -05:00
thinkyhead 04a25ab496 [cron] Bump distribution date (2023-04-27) 2023-04-27 00:22:32 +00:00
Scott Lahteine 467ab74523 🧑‍💻 Simplify endstops config (#25748) 2023-04-26 14:56:23 -05:00
Scott Lahteine 358a54ecdc 🔨 Servo Timer 1 with STM32F103RC_fysetc (#25741) 2023-04-26 14:39:56 -05:00
Giuliano Zaro 79b455575b 🔧 Thermistor 100 : SoC sensor (#25745)
Followup to #25642
2023-04-26 14:38:39 -05:00
Scott Lahteine d364babbc0 🧑‍💻 Change HAL_PATH macro for easier HAL relocation (#25743) 2023-04-26 14:29:21 -05:00
Scott Lahteine 1771d7ab64 Skip change alerts in CI test 2023-04-26 13:51:33 -05:00
Scott Lahteine 68f74784a3 🎨 Misc. fixes, cleanup 2023-04-26 13:50:45 -05:00
Scott Lahteine 08edb6282f 🔧 Extra axis endstop defaults 2023-04-26 03:00:53 -05:00
thinkyhead a4cc9b60fd [cron] Bump distribution date (2023-04-26) 2023-04-26 00:21:12 +00:00
Giuliano Zaro f5a905a641 TEMP_SENSOR_SOC (#25642)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-24 23:41:26 -05:00
Scott Lahteine d1738e946a 🔧 Fix LCD_SERIAL_PORT config 2023-04-24 23:41:26 -05:00
Anson Liu 650e6fc426 🔨 Prevent SlowSoftWire + Wire name conflict (#25707) 2023-04-24 21:07:12 -05:00
thinkyhead c034819cf8 [cron] Bump distribution date (2023-04-25) 2023-04-25 00:20:57 +00:00
InsanityAutomation 134958a535 Merge branch 'bugfix-2.1.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.1.x 2023-04-24 13:25:58 -04:00
Scott Lahteine 077a620e21 📝 Developer note in boards.h 2023-04-24 05:24:40 -05:00
Scott Lahteine 2954bf2697 🌐 Replace '=' with '{' for substitution 2023-04-24 00:28:16 -05:00
Nick 743903b96f 🩹 Fix Anycubic PlayTune (#25735)
Followup to #25690

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-23 19:50:39 -05:00
thinkyhead 02a14d31b2 [cron] Bump distribution date (2023-04-24) 2023-04-24 00:21:28 +00:00
plampix df4f80622e NOZZLE_CLEAN_PATTERN_* (#25666)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-23 18:12:47 -05:00
ellensp 9902097d91 🔨 Gather GD32, suppress redundant #error (#25665)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-23 18:11:02 -05:00
Scott Lahteine 10ed5ab01c 🚸 Improve PAUSE_PROBE_DEPLOY_WHEN_TRIGGERED (#25681) 2023-04-23 03:17:55 -05:00
Scott Lahteine 166935641a 🔧 Split followup 2023-04-23 03:00:56 -05:00
Scott Lahteine aaf55a21ad 🩹 Fix UBL safe measure move with extra axes
Followup to 7e79fc5b
2023-04-23 02:07:42 -05:00
Scott Lahteine 69f8da4682 🔧 Split Changes.h from SanityCheck.h (#25732) 2023-04-23 01:58:01 -05:00
Scott Lahteine f0f7ec8882 🧑‍💻 Stepper::set_directions() => apply_directions() 2023-04-23 00:47:44 -05:00
Scott Lahteine 921591d2b8 🧑‍💻 SDIO_SUPPORT => ONBOARD_SDIO 2023-04-22 23:15:31 -05:00
Scott Lahteine 5664c02d07 🧑‍💻 Generalize SDSUPPORT as HAS_MEDIA
In preparation for single- and multi-volume refactoring.
2023-04-22 22:43:09 -05:00
Jason Smith ce85b98db4 🩹 Relocate Fan conditionals, sanity-checks (#25731)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-22 22:27:01 -05:00
thinkyhead 95cfc98fe4 [cron] Bump distribution date (2023-04-23) 2023-04-23 00:22:56 +00:00
ellensp 5d8d38a911 🩹 Status / Host Prompt followup (#25720)
Followup to #25679

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-22 15:59:51 -05:00
thinkyhead 31173394b8 [cron] Bump distribution date (2023-04-22) 2023-04-22 12:06:22 +00:00
ellensp c8ed7950f4 🔧 Permit extrude without hotend (#25709)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-22 04:09:17 -05:00
Alexey D. Filimonov 89ccede139 🎨 Clean up TFT Color UI display items (#25712)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-22 04:06:19 -05:00
ellensp fba1f83855 🩹 Fix Anycubic PlayTune (#25728)
Followup to #25690
2023-04-22 04:02:51 -05:00
Nomis-97 726de7e821 🐛 Fix MKS Gen-L MOSFETs (#25717) 2023-04-22 03:16:19 -05:00
Scott Lahteine 4233e4864f 🚸 MarlinUI Endstop Test Screen, and more (#25667) 2023-04-22 01:56:10 -05:00
thinkyhead 98277f2c1c [cron] Bump distribution date (2023-04-21) 2023-04-21 00:20:12 +00:00
Scott Lahteine ded9ffa1e7 🧑‍💻 Apply INVERT_DIR to SET_STEP_DIR 2023-04-20 17:35:20 -05:00
Scott Lahteine 335ba32a0e 🩹 Fix Core Kinematics BABYSTEP_XY 2023-04-20 17:31:49 -05:00
Keith Bennett 91cce2a7b3 Panowin Cutlass / Bardo (F1 / Trinus) (#25663) 2023-04-19 21:42:05 -05:00
Keith Bennett de7726ca01 🚸 Permit G38 with Core (#25713) 2023-04-19 19:21:53 -05:00
thinkyhead c087ad04d3 [cron] Bump distribution date (2023-04-20) 2023-04-20 00:20:18 +00:00
Keith Bennett 4ac9cfba4f 🔧 Check renamed LIN_ADVANCE_K (#25710) 2023-04-19 16:53:11 -05:00
Jay Robson fad1dcefbc 🐛 Fix G38 with Z, support 9 axes (#25691)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-19 15:58:42 -05:00
ellensp 19b4ae862b 🩹 Correctly add JSON to mc.zip (#25706) 2023-04-18 19:50:11 -05:00
thinkyhead 5e2e00306e [cron] Bump distribution date (2023-04-19) 2023-04-19 00:22:13 +00:00
Giuliano Zaro 158c4de4f6 🩹 Bail on 'mc.zip' write error (#25695)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-18 03:40:13 -05:00
Scott Lahteine 0c2ed8688d 🩹 Z clearance followup 2023-04-17 21:00:25 -05:00
Scott Lahteine c8c5ab22ce 🧑‍💻 Gather Z clearances (#25701) 2023-04-17 19:29:53 -05:00
thinkyhead 364d8566b0 [cron] Bump distribution date (2023-04-18) 2023-04-18 00:25:20 +00:00
Scott Lahteine e6308f5d02 🩹 const_float_t => float 2023-04-17 19:17:57 -05:00
tombrazier 4d8ab1c401 🐛 Prevent Linear Advance stall (#25696) 2023-04-17 17:48:56 -05:00
ellensp ff44663f5f 🔨 Fix, clean up STM32F1 envs (#25697)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-17 14:51:25 -05:00
thinkyhead b39b5bbbc9 [cron] Bump distribution date (2023-04-17) 2023-04-17 00:20:56 +00:00
Scott Lahteine ace9855d6f 🧑‍💻 Minor SpindleLaser::set_enabled tweak 2023-04-16 19:11:56 -05:00
Alexey D. Filimonov 09ddf9c6ef 🩹 Fix Spindle/Laser ENA pin test (#25622) 2023-04-16 18:38:12 -05:00
Bob Kuhn 802fe519a3 🩹 Fix laser with no PWM compile (#25290) 2023-04-16 18:35:13 -05:00
Giuliano Zaro b6a1a6273f 🩹 Fix MPC compile (#25669) 2023-04-15 23:59:23 -05:00
Dennis Lawler e49cf0665a 🚸 Echo G30 out-of-bounds (#25671) 2023-04-15 23:50:26 -05:00
XDA-Bam 2fcc140c0d 🩹 Fix 'G29 J' status message (#25677) 2023-04-15 22:26:46 -05:00
Scott Lahteine 6e3b58d76a 🧑‍💻 Anycubic shared code (#25690) 2023-04-15 22:24:14 -05:00
Andrew 883bde07c6 🔧 Animated bootscreen U8glib-only (#25684) 2023-04-15 20:51:51 -05:00
Giuliano Zaro cc35cb3876 🐛 Fix Configuration Embedding (#25688) 2023-04-15 20:26:08 -05:00
Scott Lahteine 78bdf34b7b 🧑‍💻 HostUI::continue_prompt method 2023-04-15 20:22:17 -05:00
Scott Lahteine 9a1c02591b 🧑‍💻 Status Message cleanup 2023-04-15 20:22:17 -05:00
Scott Lahteine 48b712fdc0 🧑‍💻 JyersUI code cleanup 2023-04-15 20:22:17 -05:00
Scott Lahteine 6d819eb8d4 🧑‍💻 Apply simplified ?: 2023-04-15 20:22:17 -05:00
Scott Lahteine 92721d1bf7 🚸 "Main" => "Main Menu" 2023-04-15 20:22:17 -05:00
Scott Lahteine 42c62ff84e STARTUP_TUNE configuration 2023-04-15 20:19:48 -05:00
thinkyhead cc3a355ffb [cron] Bump distribution date (2023-04-16) 2023-04-16 00:21:45 +00:00
Scott Lahteine d77e921a15 STARTUP_TUNE option 2023-04-15 01:59:09 -05:00
Scott Lahteine 756fd1b9ac 🔧 Trigorilla / Chiron updates
Followup to c3f34e4e
2023-04-15 01:59:09 -05:00
thinkyhead b44d21c595 [cron] Bump distribution date (2023-04-15) 2023-04-15 00:21:50 +00:00
Scott Lahteine efc725863a 🔧 Edge Stepping sanity-check (#25674) 2023-04-14 17:14:04 -05:00
Scott Lahteine 161b99cb54 🐛 Fix some bad feedrates (#25672) 2023-04-14 01:08:51 -05:00
thinkyhead c3921bbf3f [cron] Bump distribution date (2023-04-14) 2023-04-14 00:19:41 +00:00
Scott Lahteine c8cb618fac 🔨 Improve runout script check 2023-04-13 04:59:43 -05:00
Scott Lahteine b3198ed929 🩹 Fix AUTOFAN_CASE
Followup to #25554
2023-04-13 04:59:43 -05:00
Scott Lahteine c3f34e4eb2 🔧 Move FIL_RUNOUT_PIN for Chiron + GLCD 2023-04-13 04:59:43 -05:00
thinkyhead cbe796e2d6 [cron] Bump distribution date (2023-04-13) 2023-04-13 00:19:21 +00:00
Scott Lahteine 0f34163558 🚸 Minor M43 improvements 2023-04-12 00:14:19 -05:00
Scott Lahteine f5c7b190f6 🐛 Fix BLTOUCH_HS_MODE config 2023-04-11 23:44:20 -05:00
thinkyhead 7369a6a37b [cron] Bump distribution date (2023-04-12) 2023-04-12 00:22:30 +00:00
Scott Lahteine b1537135e4 🚸 BLTouch extra clearance for PROBE_PT_RAISE 2023-04-11 18:47:31 -05:00
Scott Lahteine b3a3cf28d2 🚸 More clearance on fast probe failure 2023-04-11 18:47:31 -05:00
Scott Lahteine b5899a9664 🧑‍💻 Use largest_sensorless_adj in DELTA run_z_probe 2023-04-11 18:47:31 -05:00
Scott Lahteine 4e73fdd03a 🧑‍💻 Update move_z_after_probing/homing 2023-04-11 18:47:31 -05:00
Scott Lahteine c599c939c1 🧑‍💻 Modify try_to_probe sanity-checking 2023-04-11 18:47:31 -05:00
Scott Lahteine 8c0ae93d2a 🧑‍💻 Clarify G28 R / R0 2023-04-11 18:47:31 -05:00
Scott Lahteine f53217b2c5 🧑‍💻 Probe flag in do_z_clearance 2023-04-11 18:47:31 -05:00
Scott Lahteine 185961f898 🧑‍💻 More debug in motion.* 2023-04-11 18:47:31 -05:00
Scott Lahteine e9f483b480 📝 Improve G30 description 2023-04-11 18:47:31 -05:00
David Fries c6e564885e BLTOUCH_HS_EXTRA_CLEARANCE (#25655)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-04-11 18:37:54 -05:00
thinkyhead c37797ba2c [cron] Bump distribution date (2023-04-11) 2023-04-11 06:06:17 +00:00
Scott Lahteine 832f769b46 📝 Describe G34, spellcheck 2023-04-10 23:38:21 -05:00
Scott Lahteine c4aa39dc86 🩹 Fix BLTouch stow in homeaxis(Z) 2023-04-10 23:03:15 -05:00
Scott Lahteine 25e5a3597f 🚸 Fix G30 behavior
Co-Authored-By: David Fries <2767875+dfries@users.noreply.github.com>
2023-04-10 22:44:30 -05:00
Scott Lahteine 266786406c 🎨 Misc. probe-related cleanup 2023-04-10 20:41:33 -05:00
thinkyhead 182497fc39 [cron] Bump distribution date (2023-04-10) 2023-04-10 12:07:12 +00:00
ellensp 7a5934ff47 🔧 Update thermocouple 2 pin sanity check (#25627) 2023-04-10 05:17:50 -05:00
David Fries 54aef53c4d ️ Skip a redundant BLTouch::command (#25656) 2023-04-10 04:38:38 -05:00
ellensp 12d6043d86 🩹 Fix MARLIN_F446Zx_TRONXY variant (#25659)
Followup to 9be1554f
2023-04-10 04:16:52 -05:00
thinkyhead 8c897babce [cron] Bump distribution date (2023-04-09) 2023-04-09 00:22:09 +00:00
Scott Lahteine cd5dc7203c ♻️ LCD_PINS_ENABLE => LCD_PINS_EN 2023-04-08 14:24:58 -05:00
Chris Pepper 56f2da8c9d 🩹 Fix SD partitionTable packing (#25648) 2023-04-07 20:55:10 -05:00
Jason Smith c7290f00e0 🎨 Suppress M122 sign warning (#25613) 2023-04-07 20:52:33 -05:00
thinkyhead f1970b9da8 [cron] Bump distribution date (2023-04-08) 2023-04-08 00:18:59 +00:00
Scott Lahteine fa0b86ff98 🔧 Move TFT sanity checks 2023-04-07 18:53:49 -05:00
Scott Lahteine f0f5cd4734 🧱 Bump all the dates 2023-04-07 14:45:55 -05:00
Scott Lahteine 836c8ce5e5 🎨 Detab some build files 2023-04-07 01:54:07 -05:00
Scott Lahteine 27b828891d 🎨 Apply const (#25643) 2023-04-07 01:33:03 -05:00
ellensp 74b205c7ab 🚸 Support CoreXY without Z (#25630) 2023-04-07 01:32:25 -05:00
thinkyhead 2fa4a77584 [cron] Bump distribution date (2023-04-07) 2023-04-07 06:06:14 +00:00
Scott Lahteine 5b1f087c5b 📝 Update Ender # labels 2023-04-06 17:24:32 -05:00
Scott Lahteine 42a5ae8716 🧑‍💻 Update pinsformat.js 2023-04-06 16:58:41 -05:00
Scott Lahteine 7e700c1394 🔧 Move DOGLCD options 2023-04-05 14:02:52 -05:00
Scott Lahteine 4aec74f246 🐛 INVERT_*_DIR for FT_MOTION (#25637) 2023-04-05 11:58:24 -05:00
Scott Lahteine e687490f41 🐛 Clean up DELTA babystep Z 2023-04-04 21:52:30 -05:00
Scott Lahteine 80839cf020 🐛 Ensure root for 'M503 C' 2023-04-04 20:57:07 -05:00
Scott Lahteine c25a6737c6 🩹 FT_MOTION Followup 2023-04-01 16:51:15 -05:00
Scott Lahteine c47189a9d9 🔨 Move Docker local test script
Followup to #25583
2023-04-01 02:16:48 -05:00
Giuliano Zaro 1be2a7e4c1 🌐 Update Italian language (#25587) 2023-03-31 23:19:48 -05:00
Eduard Sukharev 06d9a2ff8f 🐛 Fix Long FIlename lookup (#25598) 2023-03-31 21:45:53 -05:00
Scott Lahteine c37fa3cc90 Fixed-Time Motion with Input Shaping by Ulendo (#25394)
Co-authored-by: Ulendo Alex <alex@ulendo.io>
2023-03-31 21:18:37 -05:00
Scott Lahteine 8cdf43f8fd 🎨 HAS_SHAPING => HAS_ZV_SHAPING 2023-03-31 20:26:49 -05:00
thinkyhead afb9ed73ac [cron] Bump distribution date (2023-04-01) 2023-04-01 00:27:45 +00:00
Scott Lahteine 06e5273d24 🧑‍💻 CardReader adjustments (#25611) 2023-03-31 18:18:25 -05:00
ellensp 16bd900a56 🔧 Fix SENSORLESS hit state error (#25604) 2023-03-31 01:04:40 -05:00
Scott Lahteine 20e2305011 🔧 DGUS_LCD_UI selectable options 2023-03-31 00:33:54 -05:00
thinkyhead b1398cf3ab [cron] Bump distribution date (2023-03-31) 2023-03-31 00:21:31 +00:00
Scott Lahteine c91f3a7884 🩹 Fix displayed mix percentages 2023-03-30 15:13:25 -05:00
Scott Lahteine 49f1cc8efe 🎨 Refine probe, more debug 2023-03-30 12:55:05 -05:00
Scott Lahteine a8ac83bbca 🐛 Fix _HAS_FAN for fan on Pin 0 2023-03-29 22:34:07 -05:00
Scott Lahteine 6a8ebdcd50 🩹 Fix Ender-3 V2 with no fan 2023-03-29 22:02:06 -05:00
Scott Lahteine e60df9d0af 🩹 Update Trigorilla V006 fan pin
Followup to #25568
2023-03-29 22:01:49 -05:00
thinkyhead 6f5fd42511 [cron] Bump distribution date (2023-03-30) 2023-03-30 00:21:52 +00:00
Chris Pepper 3b425d9a38 🔨 MarlinSimUI updates (#25589) 2023-03-28 23:45:22 -05:00
John Unland 54e29d75d7 🔨 Improve Docker local tests support (#25583) 2023-03-28 23:23:27 -05:00
Andrew 93eeee2230 🎨 Remove unused ProUI : UBLValidMesh (#25591) 2023-03-28 23:20:52 -05:00
ellensp 2c6aff5c79 🔧 Impose Hephestos 2 Bed Kit requirements (#25585) 2023-03-28 21:36:05 -05:00
thinkyhead 7185b34fd7 [cron] Bump distribution date (2023-03-29) 2023-03-29 00:24:23 +00:00
Scott Lahteine 83da21089f 🔨 Update config.ini endstop states
Followup to #25574
2023-03-28 16:38:56 -05:00
Scott Lahteine 9911104036 🔧 Fix up WiFi options (#25586) 2023-03-28 16:14:37 -05:00
Scott Lahteine de0cd66070 🎨 Misc. cleanup 2023-03-28 05:40:23 -05:00
thinkyhead 70063fb652 [cron] Bump distribution date (2023-03-28) 2023-03-28 00:21:53 +00:00
Eduard Sukharev a3ab435acf 🐛 Fix M23 long filename support (#25540) 2023-03-27 13:55:56 -05:00
Alexander Gavrilenko e0132f7a1e ️ Improve TFT DMA for STM32 (#25359) 2023-03-27 13:17:02 -05:00
Giuliano Zaro 41487bc9e7 🎨 Suppress a type warning (#25575) 2023-03-26 21:57:56 -05:00
Scott Lahteine 08675612d5 🐛 Fix AnyCubic Vyper ProcessPanelRequest
Followup to #25405
2023-03-26 21:38:49 -05:00
Scott Lahteine c2decc3e2e 🔨 Fix thread-unsafe deque iteration 2023-03-26 20:56:37 -05:00
thinkyhead 1adf76dd23 [cron] Bump distribution date (2023-03-27) 2023-03-27 00:21:15 +00:00
Scott Lahteine 61f22f34d3 🔧 Clarify axis disable / timeout (#25571) 2023-03-26 17:24:40 -05:00
Scott Lahteine 39652d93ab 🔧 Sanity-check for endstop inverting
Followup to #25574
2023-03-26 17:14:51 -05:00
tombrazier 241c062188 🐛 Prevent divide-by-zero in calc_timer_interval (#25557) 2023-03-26 04:46:55 -05:00
Scott Lahteine 24a9a66f0a 🧑‍💻 Auto Fan / Cooler Fan updates (#25554) 2023-03-26 04:36:12 -05:00
Keith Bennett 48b7c79113 🩹 Fix Touch Calibration first point (#25298) 2023-03-26 04:09:27 -05:00
Bob Kuhn 0021a58943 AnyCubic Vyper / Vyper LCD (#25405) 2023-03-26 04:07:25 -05:00
Scott Lahteine ea5d7e2eee 🔧 Refactor endstop state config (#25574) 2023-03-26 04:00:12 -05:00
Scott Lahteine cb0a8f2fe2 🎨 Timer tweaks 2023-03-25 20:18:04 -05:00
thinkyhead b4b2b3e61c [cron] Bump distribution date (2023-03-26) 2023-03-26 00:24:07 +00:00
Giuliano Zaro aeb8eabfcc 📝 Fix spelling (#25563) 2023-03-25 18:34:56 -05:00
Scott Lahteine 2e4bf0ab9b 🎨 Rename FAN_PIN to FAN0_PIN (#25568) 2023-03-25 18:20:14 -05:00
Scott Lahteine 01296788dc 🩹 Refine MKS boards with a dedicated FAN port (#25567) 2023-03-25 17:35:32 -05:00
ellensp 8d3142911c 🐛 Fix MKS Gen L 2.1 MOSFET pins (#25542) 2023-03-24 23:25:46 -05:00
Keith Bennett de4452fda6 🔧 Remove TVPM warning (#25551) 2023-03-24 23:15:33 -05:00
ellensp 1b72729698 🩹 Fix Chitu3D V6 default probe pin (#25552) 2023-03-24 23:14:21 -05:00
thinkyhead aba42052c3 [cron] Bump distribution date (2023-03-25) 2023-03-25 00:20:40 +00:00
Scott Lahteine d74e65362f 🩹 Update TRONXY_V10 SPI_FLASH pins 2023-03-24 18:43:53 -05:00
Scott Lahteine ec91d5a1ef 🎨 Misc. fixes, cleanup
Co-Authored-By: Martin Turski <turningtides@outlook.de>
2023-03-24 18:25:48 -05:00
Scott Lahteine 8b6155deee 🔨 INI Updates
Co-Authored-By: Martin Turski <turningtides@outlook.de>
2023-03-24 18:25:48 -05:00
Scott Lahteine 39d08d90cd 🎨 LPC_SOFTWARE_SPI => SOFTWARE_SPI
Co-Authored-By: Martin Turski <turningtides@outlook.de>
2023-03-24 18:25:48 -05:00
Scott Lahteine 50b6297523 🎨 Wrap font includes
Co-Authored-By: Martin Turski <turningtides@outlook.de>
2023-03-24 18:25:48 -05:00
Scott Lahteine 0914f9e0e1 🎨 Pins header comments
Co-Authored-By: Martin Turski <turningtides@outlook.de>
2023-03-24 18:25:48 -05:00
Scott Lahteine 769ad27645 🎨 TMC SPI Pins
Co-Authored-By: Martin Turski <turningtides@outlook.de>
2023-03-24 18:25:48 -05:00
Martin Turski 28666f2fb2 🩹 Reset touch screen calibration on failure (#25334)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-23 23:08:28 -05:00
thinkyhead c641208ceb [cron] Bump distribution date (2023-03-24) 2023-03-24 00:21:09 +00:00
Scott Lahteine 17b43d6b3d 🎨 calibration_stage => stage 2023-03-23 17:19:20 -05:00
thinkyhead 724ba4b4e6 [cron] Bump distribution date (2023-03-23) 2023-03-23 00:22:05 +00:00
Scott Lahteine 91b5015a8b 🧑‍💻 ExtUI::onSetPowerLoss 2023-03-22 03:44:54 -05:00
BIGTREETECH 2ecd4cca1b FILAMENT_SWITCH_AND_MOTION (#25548)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-22 02:46:03 -05:00
thinkyhead 8b1830c487 [cron] Bump distribution date (2023-03-22) 2023-03-22 00:23:38 +00:00
John Lagonikas 06cfd9c54a PROBING_TOOL (#24411) 2023-03-21 19:15:51 -05:00
thinkyhead d450f67caa [cron] Bump distribution date (2023-03-20) 2023-03-20 00:23:12 +00:00
tombrazier ca77850cbb 🐛 Avoid step rate overflow (#25541) 2023-03-19 16:30:51 -05:00
FilippoR fd36e69bd2 Z_SERVO_DEACTIVATE_AFTER_STOW (#24215) 2023-03-19 03:55:34 -05:00
Scott Lahteine 9249f61a80 🩹 Fix a serial_ternary 2023-03-18 21:57:06 -05:00
StevilKnevil 7e25e87807 REPORT_ADAPTIVE_FAN_SLOWING (#25537) 2023-03-18 19:57:34 -05:00
thinkyhead 432aeeefe3 [cron] Bump distribution date (2023-03-19) 2023-03-19 00:55:20 +00:00
Scott Lahteine e6ac9ff204 ️ Misc. optimizations 2023-03-18 19:53:27 -05:00
ellensp 283d093a4c 🩹 Fix Ender 2 stock LCD (#25538) 2023-03-18 19:17:21 -05:00
John Lagonikas 5be895d906 🚸 Temperature Variance Monitor tweaks (#23571)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-18 06:43:15 -05:00
tombrazier 3c88270361 ️ Smart Adaptive Multi-Stepping (#25474) 2023-03-18 05:34:53 -05:00
John Robertson 6f2d8a3872 🔧 Sanity-check PRINTCOUNTER_SAVE_INTERVAL + ESP32 I2S Exp (#25527)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-18 05:33:15 -05:00
Farva42 5abfc6160f 🚸 Fix / improve LCD_BED_TRAMMING (#25425)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-18 05:15:33 -05:00
Piotr Paczyński fbb1c82bc2 🐛 Prevent MPC E-permm overrun in Load Filament (#25531)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-18 05:15:33 -05:00
George Fu 927915a4e6 🐛 Fix FYSETC Cheetah v2.0 Servo/Probe pins (#24635)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-18 05:15:33 -05:00
Liam Powell 8c64fdd091 🔨 Fix STM32H723Vx_btt for case-sensitive (#25535) 2023-03-18 05:15:33 -05:00
Eduard Sukharev d0669527c4 🐛 Fix LVGL / MKS WiFi long filename (#25483)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-18 05:15:33 -05:00
James Gilliland 88da531e5d 🚸 Improve Z-Probe raise for deploy (#25498)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-18 05:15:30 -05:00
Keith Bennett 98c0cc044d 🔧 SQUARE_WAVE_STEPPING => EDGE_STEPPING (#25526)
Co-Authored-By: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-18 04:32:13 -05:00
Davide Rombolà ac1e2d0fbc 🎨 Suppress warning (#25529) 2023-03-18 01:35:54 -05:00
Davide Rombolà ce97e42aa0 🎨 Clean up IA_CREALITY includes (#25530) 2023-03-18 01:33:57 -05:00
Scott Lahteine f50603ff1d 🧑‍💻 More IntelliSense-friendly declares 2023-03-18 01:22:57 -05:00
Michael Hill c914761327 Sovol v1.3.1 (Sovol SV06) (#25267) 2023-03-18 00:56:07 -05:00
Scott Lahteine b5836b243a 🔧 Optional MPC_AUTOTUNE to save 5.5 - 5.8KB 2023-03-18 00:06:45 -05:00
thinkyhead 6f5b7a8b26 [cron] Bump distribution date (2023-03-18) 2023-03-18 00:21:56 +00:00
jamespearson04 89e8257008 🚸 Refinements for UBL G29 J (tilt mesh) (#25486) 2023-03-16 20:06:55 -05:00
thinkyhead ae4fa0ab68 [cron] Bump distribution date (2023-03-17) 2023-03-17 00:22:26 +00:00
Scott Lahteine 507c122fcf ♻️ Refactor UBL 'G29 J' 2023-03-16 00:45:13 -05:00
Scott Lahteine 51d3eabf46 ♻️ Refactor PROBE_PT_[123] 2023-03-16 00:45:13 -05:00
ellensp 41b3409ba8 🔧 Safer default for Z_MIN_PROBE_PIN override (#25524)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
2023-03-16 00:42:52 -05:00
thinkyhead 32c7e24b4b [cron] Bump distribution date (2023-03-16) 2023-03-16 00:52:51 +00:00
dwzg 0a00662b54 🩹 Fix DWIN MarlinUI Fan/E/XY (#25502) 2023-03-15 19:15:54 -05:00
Scott Lahteine 65b97438fa 🩹 Fan Menu / Status fixes
Followup to #21888
2023-03-15 19:13:57 -05:00
Scott Lahteine 10983d0cfe 🎨 Misc. tramming menu cleanup (#25519) 2023-03-15 00:29:37 -05:00
Scott Lahteine 66d94ece33 🎨 Misc. formatting 2023-03-14 19:43:09 -05:00
thinkyhead 50893c414d [cron] Bump distribution date (2023-03-15) 2023-03-15 00:30:47 +00:00
Davide Rombolà 1cf85196b6 🩹 Fix IA_CREALITY float, startup (#25493)
Followup to #25440
2023-03-14 18:54:24 -05:00
Eduard Sukharev f90c49910d 🐛 Fix long filename read/report (#25509) 2023-03-14 16:49:49 -05:00
jbubik 3156595078 🐛 Fix Polargraph without Z (#25514) 2023-03-13 20:19:24 -05:00
thinkyhead 6f5d33ce55 [cron] Bump distribution date (2023-03-14) 2023-03-14 00:20:33 +00:00
Neo2003 9039e99df1 📺 DGUS_RELOADED 1.03 (#25490) 2023-03-13 16:55:03 -05:00
Scott Lahteine db2b8a695d ️ Update ISR cycle counts
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-13 16:49:33 -05:00
Scott Lahteine 143a8701d5 ️ Optimize speed lookup for AVR
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-13 16:49:33 -05:00
Scott Lahteine 3365172e7c 🔧 Expose MULTISTEPPING_LIMIT option
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-13 16:49:33 -05:00
Scott Lahteine 549419e084 ️ Set steps_per_isr in calc_multistep_timer_interval
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-13 16:49:33 -05:00
Scott Lahteine e4b83ad5f5 ️ Major shaper optimization
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-13 16:49:33 -05:00
thinkyhead e1a209d0ce [cron] Bump distribution date (2023-03-13) 2023-03-13 00:22:40 +00:00
Scott Lahteine 4a0cb4fb4a ️ Use AxisFlags for step_needed
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-12 15:18:54 -05:00
Scott Lahteine d554844a51 ️ Use cached la_active state
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-12 15:18:54 -05:00
Scott Lahteine 194f58740a ️ Use hal_timer_t for timing vars
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-12 15:18:54 -05:00
Scott Lahteine 4fdb0fbe8e MAX7219_DEBUG_MULTISTEPPING
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-12 15:18:54 -05:00
Scott Lahteine f9d3939d23 🎨 Cosmetic stepper updates
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-12 15:18:54 -05:00
Scott Lahteine cb66bff924 ️ Exit from ISR on AVR already does sei
Co-Authored-By: tombrazier <68918209+tombrazier@users.noreply.github.com>
2023-03-12 13:23:59 -05:00
Keith Bennett 4527908c11 BTT Octopus … followup (#25495)
Followup to #25387
2023-03-11 19:44:56 -06:00
thinkyhead fe32582262 [cron] Bump distribution date (2023-03-12) 2023-03-12 00:24:43 +00:00
Keith Bennett 3e12934ea0 🐛 Fix Anet ET4 SD_SS_PIN (#25492) 2023-03-11 02:08:07 -06:00
thinkyhead 987923ecb4 [cron] Bump distribution date (2023-03-11) 2023-03-11 00:20:20 +00:00
Keith Bennett 28b101ccef BTT Octopus Max EZ 1.0, SKR 3.0 / 3.0 EZ (#25387)
BTT Octopus Max EZ V1.0 (STM32H723VE/ZE), SKR V3.0 / V3.0 EZ (STM32H723VG)
2023-03-10 17:56:33 -06:00
InsanityAutomation 2cc52318e3 Merge branch 'bugfix-2.1.x' into LulzbotTestBase 2022-11-30 15:28:39 -05:00
Scott Lahteine d602fb9421 use the conditional 2022-10-20 09:09:56 -04:00
InsanityAutomation 8c1e4b5250 Update Configuration_adv.h 2022-10-18 17:52:28 -04:00
InsanityAutomation d2a5d2d220 Fix FTDUI Status Screen Timeout 2022-10-18 17:52:20 -04:00
InsanityAutomation 9ff3500dda Merge branch 'bugfix-2.1.x' into LulzbotTestBase 2022-10-18 17:21:43 -04:00
InsanityAutomation 30e5554171 Update Configuration_adv.h 2022-08-08 10:43:32 -04:00
InsanityAutomation 190204e6b8 Merge branch 'FixArduinoDUEServos' into LulzbotTestBase 2022-06-21 10:13:56 -04:00
Jason Smith 9d4aff6eab Fix DUE timer behavior when disabling servos 2022-06-12 14:39:54 -07:00
InsanityAutomation d74ecde544 Merge branch 'FixArduinoDUEServos' into LulzbotTestBase 2022-06-11 12:20:50 -04:00
Scott Lahteine ad4cf3e332 pick best clock for prescaler 2022-06-10 22:22:40 -05:00
Scott Lahteine 701ab0db8e define HAL_TIMER_PRESCALER 2022-06-10 21:09:25 -05:00
Scott Lahteine b3f2f44124 set inactive servos LOW 2022-06-10 20:28:03 -05:00
Scott Lahteine a03ee01cee match samd51 to others 2022-06-10 20:28:03 -05:00
Scott Lahteine 9bb87da816 apply SERVO_TIMER_PRESCALER to intervals 2022-06-10 19:52:03 -05:00
Scott Lahteine 5fbb7cbe6a ws 2022-06-10 19:06:30 -05:00
InsanityAutomation 8af96b8cdd Update Servo.cpp 2022-06-09 15:48:08 -04:00
Scott Lahteine 5cdc4527d3 Merge branch 'bugfix-2.1.x' into pr/24305 2022-06-09 00:52:57 -05:00
Scott Lahteine 0206af6c07 fix servo index check, add comments 2022-06-09 00:23:09 -05:00
InsanityAutomation fb5dd40949 Revise timer to MCK/2
Co-Authored-By: sjasonsmith <20053467+sjasonsmith@users.noreply.github.com>
2022-06-08 22:24:25 -04:00
InsanityAutomation 9c1366ed99 Archim2 USB Hang Fix 2022-06-08 19:43:34 -04:00
InsanityAutomation e7c505d415 Merge branch 'bugfix-2.1.x' into LulzbotTestBase 2022-06-08 17:38:26 -04:00
InsanityAutomation e304aa9da7 Revise timer to MCK/2 2022-06-08 17:38:04 -04:00
Scott Lahteine c1775c9005 Remove MOVE_SERVO, DETACH_SERVO 2022-06-07 22:29:17 -05:00
Scott Lahteine dbd9321380 use simple fix 2022-06-07 22:28:44 -05:00
Scott Lahteine 7f6622e6ac test this if nothing else works 2022-06-07 19:31:29 -05:00
Scott Lahteine 04ffe9493b Try adjusting finISR also ?? 2022-06-07 19:31:29 -05:00
Scott Lahteine 6c39286626 Try Servo::detach adjustment ?? 2022-06-07 19:31:29 -05:00
Scott Lahteine 86b9e7ee13 servo cleanup 2022-06-07 19:31:29 -05:00
Scott Lahteine 6566031ec6 keep check for good SERVO_INDEX 2022-06-07 17:09:28 -05:00
InsanityAutomation e7a6c77d74 Resolve DUE Servo pulse issue 2022-06-07 09:14:26 -04:00
InsanityAutomation 2436e2463c Resolve DUE Servo pulse issue 2022-06-07 09:11:41 -04:00
InsanityAutomation 9fffe26c20 Allow configurable dwell for servo move on Switching Nozzle 2022-06-07 09:11:08 -04:00
InsanityAutomation 3ab1c95ab3 Update Configuration.h 2022-05-29 18:42:03 -04:00
InsanityAutomation 7f32519aa9 Use raw positions for G34 probing to honor M206 offsets 2022-05-29 18:36:14 -04:00
InsanityAutomation ff91016e81 Config improvements 2022-05-29 17:23:13 -04:00
InsanityAutomation 4615345773 Import Marcios EMI Filtering 2022-05-29 15:33:29 -04:00
InsanityAutomation 25ff9813c6 fix upstream warnings 2022-05-22 13:53:09 -04:00
InsanityAutomation 8ba8ae85c4 minor tweaks 2022-05-22 13:52:46 -04:00
InsanityAutomation dc1cd03897 Additional merge conflicts not flagged by rebase 2022-05-22 13:39:26 -04:00
InsanityAutomation 304ca54aba Merge branch 'bugfix-2.0.x' into LulzbotTestBase 2022-05-22 13:34:16 -04:00
InsanityAutomation e175f3f729 Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x 2022-05-22 13:04:47 -04:00
InsanityAutomation 641fc9c833 Merge branch 'LulzbotTestBase' of https://github.com/InsanityAutomation/Marlin into LulzbotTestBase 2022-05-22 13:04:29 -04:00
Roxy-3D 6e2597593a Allow BTT Octopus boards to use ST-Link for programing and debugging 2022-05-13 17:48:59 -05:00
Roxy-3D c29a949a13 Update stm32f4.ini
Allow Platform-IO to upload to the Octopus boards directly with an ST-Link attached.
2022-05-13 17:29:50 -05:00
Marcio Teixeira 26268313c4 Remove tags from non-clickable text. 2021-08-06 20:22:29 -04:00
Marcio Teixeira da8412db6a Additional tweaks for FTDI Eve spinner dialog box 2021-08-06 20:22:04 -04:00
InsanityAutomation 9bf6c900c4 A few fixes 2021-08-06 20:21:05 -04:00
InsanityAutomation aa6e7b0300 Update preflight-checks.py 2021-08-05 22:18:48 -04:00
InsanityAutomation 0663c5a372 Merge branch 'bugfix-2.0.x' into LulzbotTestBase 2021-08-02 11:08:17 -04:00
InsanityAutomation ad42498dfb Merge branch 'bugfix-2.0.x' into LulzbotTestBase 2021-06-05 13:07:08 -04:00
InsanityAutomation 662d03896b Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x 2021-06-05 12:51:39 -04:00
InsanityAutomation 8b09d27cd9 Custom User Menus confirm and hide when printing 2021-03-12 16:15:03 -05:00
InsanityAutomation d7c8cf3a9e Update Configuration_adv.h 2021-02-08 11:15:49 -05:00
InsanityAutomation c9ae761066 Merge branch 'LulzbotTestBase' of https://github.com/InsanityAutomation/Marlin into LulzbotTestBase 2021-01-03 12:46:00 -05:00
InsanityAutomation 7bed426de3 Update G12 for Taz Pro 2021-01-03 12:41:19 -05:00
InsanityAutomation 048de70ee6 Fix mesh screen include 2021-01-03 12:27:05 -05:00
InsanityAutomation 6049f226bc Merge branch 'bugfix-2.0.x' into LulzbotTestBase 2021-01-03 12:26:36 -05:00
InsanityAutomation c02083677a Fixes after rebase 2020-11-15 14:05:26 -05:00
InsanityAutomation 64ed7aff53 Merge branch 'bugfix-2.0.x' into LulzbotTestBase 2020-11-13 19:26:18 -05:00
thinkyhead a694291420 [cron] Bump distribution date (2020-10-20) 2020-10-20 00:15:55 +00:00
Scott Lahteine 0216e032be Host prompt followup 2020-10-19 04:34:14 -05:00
Scott Lahteine 2d8aa0cea1 Tweak a host prompt call 2020-10-19 04:25:48 -05:00
InsanityAutomation d1eb100806 Update G28.cpp 2020-10-16 09:30:41 -04:00
InsanityAutomation 1d3c53ae2f Update G34_M422.cpp 2020-10-12 09:07:45 -04:00
InsanityAutomation 97d5da4c11 Update platformio.ini 2020-10-12 09:07:45 -04:00
InsanityAutomation 359e0641c4 set config version 2020-10-12 09:07:45 -04:00
InsanityAutomation 2c4e4edade Tweak env 2020-10-12 09:07:45 -04:00
InsanityAutomation c6ae6c53a8 Update G29.cpp 2020-10-12 09:07:45 -04:00
InsanityAutomation c596e9f3f0 Fix z-min mechanical gantry alignment 2020-10-12 09:07:45 -04:00
InsanityAutomation 37ebee1cef Merge compatability fixes 2020-10-12 09:07:45 -04:00
InsanityAutomation 76cbaeeb2e Update Configuration_adv.h 2020-10-12 09:07:45 -04:00
InsanityAutomation 79b8ad13f1 Tweaks for MiniV2 broken endstop and gantry calibration position 2020-10-12 09:07:45 -04:00
InsanityAutomation d0a8bc29be Update Configuration_adv.h 2020-10-12 09:07:45 -04:00
InsanityAutomation 10901d9092 Make thermal timing more forgiving, at least until PID can be better tuned for BMG-M 2020-10-12 09:07:45 -04:00
InsanityAutomation dddc232294 Update Configuration_adv.h 2020-10-12 09:07:45 -04:00
InsanityAutomation 1419f2637e Adjust PID and currents on tool menu 2020-10-12 09:07:45 -04:00
InsanityAutomation 91b08d2deb Nozzle as proble home offset application to probe points 2020-10-12 09:07:45 -04:00
InsanityAutomation 2f3af1c9da Allow M206 offsets to apply to z safe home move 2020-10-12 09:07:45 -04:00
InsanityAutomation 2d6a5201cf Batch 1 2020-10-12 09:07:44 -04:00
InsanityAutomation a390a348d0 Enable Post G28 by default as its usually necessary 2020-10-12 09:07:44 -04:00
InsanityAutomation b3a732b43a Update Configuration_adv.h 2020-10-12 09:07:44 -04:00
Scott Lahteine bb6d74383e Provide MSG_ITERATION 2020-10-12 09:07:44 -04:00
Scott Lahteine 9e8b2121dd reorder 2020-10-12 09:07:44 -04:00
Scott Lahteine af91b4d29f Stepper current refactor 2020-10-12 09:07:44 -04:00
Scott Lahteine 609325a8b4 Various fixes, cleanup 2020-10-12 09:07:44 -04:00
InsanityAutomation 3bd861bf19 DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-10-12 09:07:44 -04:00
InsanityAutomation ed3de53587 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-12 09:07:44 -04:00
InsanityAutomation 82eddcd6e7 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-12 09:07:44 -04:00
InsanityAutomation 3929349c1b Fix z-min mechanical gantry alignment 2020-10-12 09:07:44 -04:00
InsanityAutomation e095f94f9f Merge compatability fixes 2020-10-12 09:07:44 -04:00
InsanityAutomation 9127ec6bd7 Update Configuration_adv.h 2020-10-12 09:07:40 -04:00
InsanityAutomation 7a9d26d1a0 Tweaks for MiniV2 broken endstop and gantry calibration position 2020-10-12 09:07:40 -04:00
InsanityAutomation af0b517e8f Update Configuration_adv.h 2020-10-12 09:07:40 -04:00
InsanityAutomation aeb062b33e Bring over pro tft fixes from main branch 2020-10-12 09:07:40 -04:00
InsanityAutomation 15fe76dd6a Make thermal timing more forgiving, at least until PID can be better tuned for BMG-M 2020-10-12 09:07:40 -04:00
InsanityAutomation 7265db1b36 Update Configuration_adv.h 2020-10-12 09:07:39 -04:00
InsanityAutomation c5104c1d2b Adjust PID and currents on tool menu 2020-10-12 09:07:39 -04:00
InsanityAutomation 8b91d1d255 Nozzle as proble home offset application to probe points 2020-10-12 09:07:39 -04:00
InsanityAutomation 9518cb0f2e Allow M206 offsets to apply to z safe home move 2020-10-12 09:07:18 -04:00
InsanityAutomation c2bd4928a5 Batch 1 2020-10-12 09:06:42 -04:00
InsanityAutomation 7120df3b85 Update G34_M422.cpp 2020-10-12 09:06:39 -04:00
InsanityAutomation f25156971b Revert "Merge branch 'Reimplement-Prusa-M915-into-G34' of https://github.com/InsanityAutomation/Marlin into Reimplement-Prusa-M915-into-G34"
This reverts commit 491cfc6ae0, reversing
changes made to d42b24369f.
2020-10-12 09:06:39 -04:00
Scott Lahteine 650ca3baa6 Move test 2020-10-12 09:06:36 -04:00
Scott Lahteine 3ceb4a5c46 Add a CI test 2020-10-12 09:06:30 -04:00
Scott Lahteine 8511d9e781 Update Configuration_adv.h 2020-10-12 09:06:30 -04:00
InsanityAutomation 7aa6d3ef09 Enable Post G28 by default as its usually necessary 2020-10-12 09:06:30 -04:00
InsanityAutomation f7fdbb4eb3 Update Configuration_adv.h 2020-10-12 09:06:25 -04:00
InsanityAutomation 7d0cd9ccf5 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-12 09:05:22 -04:00
InsanityAutomation ead8d29316 Enable Post G28 by default as its usually necessary 2020-10-12 09:05:15 -04:00
InsanityAutomation 58a6d42db6 Update Configuration_adv.h 2020-10-12 09:05:12 -04:00
InsanityAutomation 50833c9836 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-12 09:03:49 -04:00
InsanityAutomation 5d704b8494 Fix rebase issues 2020-10-12 09:03:17 -04:00
Scott Lahteine 3621a0a3f6 Update G34_M422.cpp 2020-10-12 09:03:17 -04:00
Scott Lahteine 10b9e5ca34 Move test 2020-10-12 09:03:17 -04:00
Scott Lahteine bcef7ad91b ibid 2020-10-12 09:03:17 -04:00
Scott Lahteine 1666980b5b Fix wrapper on G34_M422.cpp 2020-10-12 09:03:17 -04:00
Scott Lahteine 58a6d1b8d4 Add a CI test 2020-10-12 09:03:17 -04:00
Scott Lahteine 2151f4c50b Use MOTOR_CURRENT_COUNT 2020-10-12 09:03:17 -04:00
Scott Lahteine ee7e532761 Update G34_M422.cpp 2020-10-12 09:03:17 -04:00
Scott Lahteine 4a7665a1e9 Update Configuration_adv.h 2020-10-12 09:03:17 -04:00
InsanityAutomation 1e4d50b6e8 Update Configuration_adv.h 2020-10-12 09:03:17 -04:00
InsanityAutomation 3ae543dd30 Fix compile errors 2020-10-12 09:03:17 -04:00
Scott Lahteine 041959f903 Clean up G34/M422 2020-10-12 09:03:17 -04:00
Scott Lahteine df922ed7c8 Stepper current refactor 2020-10-12 09:03:17 -04:00
Scott Lahteine 41534e78f8 Various fixes, cleanup 2020-10-12 09:03:17 -04:00
InsanityAutomation fabdb6a51e DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-10-12 09:03:16 -04:00
InsanityAutomation fac1a75596 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-12 09:03:16 -04:00
InsanityAutomation bd5ded15e7 Enable Post G28 by default as its usually necessary 2020-10-12 09:03:16 -04:00
InsanityAutomation 530e807bcd Prevent min move from going into overflow sending Z to 65k 2020-10-12 09:03:16 -04:00
InsanityAutomation 251a0268c4 Update Configuration_adv.h 2020-10-12 09:03:16 -04:00
InsanityAutomation 4fdded0e2d Fix compile errors 2020-10-12 09:03:16 -04:00
Scott Lahteine f4e26c785f …and… 2020-10-12 09:03:16 -04:00
Scott Lahteine 9100ed15fa Fix sprintf_P call 2020-10-12 09:03:16 -04:00
Scott Lahteine dc82db35d4 helpful patch 2020-10-12 09:03:16 -04:00
Scott Lahteine 610fb6fd35 Clean up G34/M422 2020-10-12 09:03:16 -04:00
Scott Lahteine 594882f7a9 Provide MSG_ITERATION 2020-10-12 09:03:16 -04:00
Scott Lahteine 4e160fea16 reorder 2020-10-12 09:03:16 -04:00
Scott Lahteine 99d5ad3b09 Stepper current refactor 2020-10-12 09:03:16 -04:00
Scott Lahteine a9f6080931 Various fixes, cleanup 2020-10-12 09:03:16 -04:00
InsanityAutomation 1b0301c89f Add missed lines from working branch 2020-10-12 09:03:16 -04:00
InsanityAutomation 94798e4465 Update G34_M422.cpp 2020-10-12 09:03:16 -04:00
InsanityAutomation 65b59a6646 DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-10-12 09:03:15 -04:00
InsanityAutomation 09f5b5d00a Sanity Checks, gcode calls 2020-10-12 09:03:15 -04:00
InsanityAutomation 3487cbad21 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-12 09:03:15 -04:00
InsanityAutomation da8e07b697 Merge branch 'LulzbotTestBase' of https://github.com/InsanityAutomation/Marlin into LulzbotTestBase 2020-10-11 17:00:24 -04:00
InsanityAutomation 402a13a980 Update G34_M422.cpp 2020-10-11 11:48:45 -04:00
InsanityAutomation 56f7a03a5c Update platformio.ini 2020-10-11 11:32:20 -04:00
InsanityAutomation 3113388293 set config version 2020-10-11 10:06:50 -04:00
InsanityAutomation eecfc0479a Tweak env 2020-10-11 10:06:50 -04:00
InsanityAutomation 9984643e4c Update G29.cpp 2020-10-11 10:06:50 -04:00
InsanityAutomation 58114b32ba Fix z-min mechanical gantry alignment 2020-10-11 10:06:50 -04:00
InsanityAutomation 50a6fb637f Merge compatability fixes 2020-10-11 10:06:50 -04:00
InsanityAutomation d71b12cd8b Update Configuration_adv.h 2020-10-11 10:06:50 -04:00
InsanityAutomation 42842f71e0 Tweaks for MiniV2 broken endstop and gantry calibration position 2020-10-11 10:06:49 -04:00
InsanityAutomation 5213de4eaa Update Configuration_adv.h 2020-10-11 10:06:49 -04:00
InsanityAutomation 602c9fffe0 Make thermal timing more forgiving, at least until PID can be better tuned for BMG-M 2020-10-11 10:06:49 -04:00
InsanityAutomation 4d73906008 Update Configuration_adv.h 2020-10-11 10:06:49 -04:00
InsanityAutomation 0da50d80ef Adjust PID and currents on tool menu 2020-10-11 10:06:49 -04:00
InsanityAutomation f0bbc163c6 Nozzle as proble home offset application to probe points 2020-10-11 10:06:49 -04:00
InsanityAutomation 78aec86650 Allow M206 offsets to apply to z safe home move 2020-10-11 10:06:42 -04:00
InsanityAutomation 6bd2a602ca Batch 1 2020-10-11 10:06:42 -04:00
InsanityAutomation 6b923de48d Enable Post G28 by default as its usually necessary 2020-10-11 10:06:38 -04:00
InsanityAutomation a645efd189 Update Configuration_adv.h 2020-10-11 10:06:35 -04:00
Scott Lahteine a717a3eacb Provide MSG_ITERATION 2020-10-11 10:06:24 -04:00
Scott Lahteine da03b84eff reorder 2020-10-11 10:06:20 -04:00
Scott Lahteine aa6d23c7cb Stepper current refactor 2020-10-11 10:06:20 -04:00
Scott Lahteine 2a1826f1ed Various fixes, cleanup 2020-10-11 10:06:16 -04:00
InsanityAutomation 8e79ea09e4 DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-10-11 10:06:07 -04:00
InsanityAutomation e29dbb946e Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-11 10:06:00 -04:00
InsanityAutomation b1f8fa881d Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-11 10:05:50 -04:00
InsanityAutomation c2a2d04b50 Update G29.cpp 2020-10-11 10:05:43 -04:00
InsanityAutomation 84d0a5ebd1 Fix z-min mechanical gantry alignment 2020-10-11 10:05:43 -04:00
InsanityAutomation 6ed5c22d7c Merge compatability fixes 2020-10-11 10:05:39 -04:00
InsanityAutomation 07246fdc30 Update Configuration_adv.h 2020-10-11 10:05:35 -04:00
InsanityAutomation 14899ca3f7 Tweaks for MiniV2 broken endstop and gantry calibration position 2020-10-11 10:05:35 -04:00
InsanityAutomation 2d0972d35d Update Configuration_adv.h 2020-10-11 10:05:35 -04:00
InsanityAutomation c43828b2e3 Bring over pro tft fixes from main branch 2020-10-11 10:05:34 -04:00
InsanityAutomation bc13685c46 Make thermal timing more forgiving, at least until PID can be better tuned for BMG-M 2020-10-11 10:05:26 -04:00
InsanityAutomation 14d374dc2b Update Configuration_adv.h 2020-10-11 10:05:26 -04:00
InsanityAutomation 5dc45f2ceb Adjust PID and currents on tool menu 2020-10-11 10:05:26 -04:00
InsanityAutomation 8ed81063a2 Nozzle as proble home offset application to probe points 2020-10-11 10:05:26 -04:00
InsanityAutomation cb92d78a46 Allow M206 offsets to apply to z safe home move 2020-10-11 10:05:21 -04:00
InsanityAutomation d94a20e63a Batch 1 2020-10-11 10:05:10 -04:00
InsanityAutomation b2ff518c27 Update G29.cpp 2020-10-11 09:55:14 -04:00
Scott Lahteine 4c1d5e8fcf Update G29.cpp 2020-10-11 09:55:14 -04:00
Scott Lahteine e13d6ba012 safe_homing_xy is defined in motion.h 2020-10-11 09:55:14 -04:00
InsanityAutomation ec08edd240 Update G28.cpp 2020-10-11 09:55:13 -04:00
InsanityAutomation 1c890a9da0 Apply home offsets to probing and Z Safe Homing 2020-10-11 09:55:13 -04:00
InsanityAutomation e070ce987f Update G34_M422.cpp 2020-10-11 09:51:37 -04:00
InsanityAutomation 45b75301a8 Revert "Merge branch 'Reimplement-Prusa-M915-into-G34' of https://github.com/InsanityAutomation/Marlin into Reimplement-Prusa-M915-into-G34"
This reverts commit 491cfc6ae0, reversing
changes made to d42b24369f.
2020-10-11 09:45:39 -04:00
InsanityAutomation 491cfc6ae0 Merge branch 'Reimplement-Prusa-M915-into-G34' of https://github.com/InsanityAutomation/Marlin into Reimplement-Prusa-M915-into-G34 2020-10-11 09:44:41 -04:00
InsanityAutomation d42b24369f Fix rebase issues 2020-10-11 09:43:57 -04:00
Scott Lahteine 8280cfef43 Update G34_M422.cpp 2020-10-10 14:24:29 -04:00
Scott Lahteine 785da0db6c Move test 2020-10-10 14:24:29 -04:00
Scott Lahteine eaad3c451c ibid 2020-10-10 14:24:29 -04:00
Scott Lahteine fd751bd3fe Fix wrapper on G34_M422.cpp 2020-10-10 14:24:14 -04:00
Scott Lahteine 0785d312f7 Add a CI test 2020-10-10 14:24:14 -04:00
Scott Lahteine 5dc96c7324 Use MOTOR_CURRENT_COUNT 2020-10-10 14:24:13 -04:00
Scott Lahteine 2532ef1049 Update G34_M422.cpp 2020-10-10 14:24:13 -04:00
Scott Lahteine dd2d4df3dc Update Configuration_adv.h 2020-10-10 14:24:13 -04:00
InsanityAutomation a583d8998f Update Configuration_adv.h 2020-10-10 14:24:13 -04:00
InsanityAutomation 953cf6f7d6 Fix compile errors 2020-10-10 14:23:11 -04:00
Scott Lahteine fcd4fa4ab7 Clean up G34/M422 2020-10-10 14:22:41 -04:00
Scott Lahteine 123a2b28fc Stepper current refactor 2020-10-10 14:21:57 -04:00
Scott Lahteine 28261437f8 Various fixes, cleanup 2020-10-10 14:20:38 -04:00
InsanityAutomation c0a48e4fe2 DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-10-10 14:19:08 -04:00
InsanityAutomation 5b2353a2ab Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-10 14:16:11 -04:00
InsanityAutomation cafd4ff6a6 Enable Post G28 by default as its usually necessary 2020-10-10 14:13:52 -04:00
InsanityAutomation f98aff039c Prevent min move from going into overflow sending Z to 65k 2020-10-10 14:13:52 -04:00
InsanityAutomation 5e93e09c1a Update Configuration_adv.h 2020-10-10 14:13:52 -04:00
InsanityAutomation ca5c5fdd40 Fix compile errors 2020-10-10 14:13:52 -04:00
Scott Lahteine 71c1b8ca6d …and… 2020-10-10 14:13:52 -04:00
Scott Lahteine e5c2fbd6ac Fix sprintf_P call 2020-10-10 14:13:52 -04:00
Scott Lahteine 3618b9c7be helpful patch 2020-10-10 14:13:52 -04:00
Scott Lahteine 7ab7cfc96d Clean up G34/M422 2020-10-10 14:13:52 -04:00
Scott Lahteine 92db4f2d84 Provide MSG_ITERATION 2020-10-10 14:13:52 -04:00
Scott Lahteine e2ce5865c9 reorder 2020-10-10 14:13:52 -04:00
Scott Lahteine 6815edf8d6 Stepper current refactor 2020-10-10 14:13:52 -04:00
Scott Lahteine f8ff1c8d6a Various fixes, cleanup 2020-10-10 14:13:51 -04:00
InsanityAutomation 6ab5745875 Add missed lines from working branch 2020-10-10 14:13:51 -04:00
InsanityAutomation 8bb6a9b44a Update G34_M422.cpp 2020-10-10 14:13:51 -04:00
InsanityAutomation 52ec2a266f DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-10-10 14:13:51 -04:00
InsanityAutomation 33f6219f06 Sanity Checks, gcode calls 2020-10-10 14:13:51 -04:00
InsanityAutomation dd6153f317 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-10 14:13:51 -04:00
InsanityAutomation 05af0cbb55 Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x 2020-10-10 13:57:26 -04:00
Scott Lahteine ff39019034 Update G34_M422.cpp 2020-10-10 12:40:08 -05:00
Scott Lahteine a5eefa9ffa Move test 2020-10-10 12:36:35 -05:00
Scott Lahteine 109e8f88ce ibid 2020-10-10 12:34:08 -05:00
Scott Lahteine 00413994dd Fix wrapper on G34_M422.cpp 2020-10-10 12:32:19 -05:00
Scott Lahteine 8e39965b2d Add a CI test 2020-10-10 12:31:17 -05:00
Scott Lahteine 87f6e91f51 Use MOTOR_CURRENT_COUNT 2020-10-10 12:27:46 -05:00
Scott Lahteine 0cb0df6bee Update G34_M422.cpp 2020-10-10 12:17:07 -05:00
Scott Lahteine 80e2ab6ed6 Update Configuration_adv.h 2020-10-10 12:12:36 -05:00
InsanityAutomation e406791b6f set config version 2020-10-04 12:44:43 -04:00
InsanityAutomation 438eb8ebb3 Tweak env 2020-10-04 12:39:08 -04:00
InsanityAutomation 206b5ab014 Update G29.cpp 2020-10-04 12:39:08 -04:00
InsanityAutomation 2ab7fa652c Fix z-min mechanical gantry alignment 2020-10-04 12:39:08 -04:00
InsanityAutomation 87d1df38de Merge compatability fixes 2020-10-04 12:39:08 -04:00
InsanityAutomation c392cb6d9d Update Configuration_adv.h 2020-10-04 12:39:08 -04:00
InsanityAutomation 7ae0805095 Tweaks for MiniV2 broken endstop and gantry calibration position 2020-10-04 12:39:08 -04:00
InsanityAutomation a2f86e84a4 Update Configuration_adv.h 2020-10-04 12:39:08 -04:00
InsanityAutomation b8a2160f82 Bring over pro tft fixes from main branch 2020-10-04 12:39:07 -04:00
InsanityAutomation 99d49108c1 Make thermal timing more forgiving, at least until PID can be better tuned for BMG-M 2020-10-04 12:39:07 -04:00
InsanityAutomation e6671b3065 Update Configuration_adv.h 2020-10-04 12:39:07 -04:00
InsanityAutomation df82a0e497 Adjust PID and currents on tool menu 2020-10-04 12:39:07 -04:00
InsanityAutomation 1832269181 Nozzle as proble home offset application to probe points 2020-10-04 12:39:07 -04:00
InsanityAutomation 8341f282ee Allow M206 offsets to apply to z safe home move 2020-10-04 12:39:07 -04:00
InsanityAutomation 4fdf747445 Batch 1 2020-10-04 12:39:07 -04:00
InsanityAutomation 61b6a0ea9f Enable Post G28 by default as its usually necessary 2020-10-04 12:38:55 -04:00
InsanityAutomation 5006ca07be Prevent min move from going into overflow sending Z to 65k 2020-10-04 12:38:55 -04:00
InsanityAutomation 8579af67a2 Update Configuration_adv.h 2020-10-04 12:38:54 -04:00
InsanityAutomation 8f49610d3a Fix compile errors 2020-10-04 12:38:46 -04:00
Scott Lahteine 8fd08ba1f8 …and… 2020-10-04 12:38:46 -04:00
Scott Lahteine c0c4f77c36 Fix sprintf_P call 2020-10-04 12:38:46 -04:00
Scott Lahteine b6cbad224b helpful patch 2020-10-04 12:38:46 -04:00
Scott Lahteine c765c7484c Clean up G34/M422 2020-10-04 12:38:46 -04:00
Scott Lahteine 3242d3dca2 Provide MSG_ITERATION 2020-10-04 12:38:46 -04:00
Scott Lahteine 58f774e98d reorder 2020-10-04 12:38:46 -04:00
Scott Lahteine 79ff336b2b Stepper current refactor 2020-10-04 12:38:45 -04:00
Scott Lahteine 0d367432e6 Various fixes, cleanup 2020-10-04 12:38:39 -04:00
InsanityAutomation 959919bcfe Add missed lines from working branch 2020-10-04 12:38:30 -04:00
InsanityAutomation 4f7289e022 Update G34_M422.cpp 2020-10-04 12:38:30 -04:00
InsanityAutomation af8be03165 DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-10-04 12:38:30 -04:00
InsanityAutomation 88ce2c94f8 Sanity Checks, gcode calls 2020-10-04 12:36:59 -04:00
InsanityAutomation 0a52d5c032 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-04 12:36:24 -04:00
InsanityAutomation 38286d9805 Enable Post G28 by default as its usually necessary 2020-10-04 12:35:54 -04:00
InsanityAutomation 0ece75536c Prevent min move from going into overflow sending Z to 65k 2020-10-04 12:35:54 -04:00
InsanityAutomation 4b377bb032 Update Configuration_adv.h 2020-10-04 12:35:54 -04:00
InsanityAutomation 0392a56193 Fix compile errors 2020-10-04 12:35:54 -04:00
Scott Lahteine 58654b3664 …and… 2020-10-04 12:35:53 -04:00
Scott Lahteine 8b324e08d9 Fix sprintf_P call 2020-10-04 12:35:53 -04:00
Scott Lahteine 1bf3881adc helpful patch 2020-10-04 12:35:53 -04:00
Scott Lahteine e2c1ca3bca Clean up G34/M422 2020-10-04 12:35:53 -04:00
Scott Lahteine 234b15a12c Provide MSG_ITERATION 2020-10-04 12:35:53 -04:00
Scott Lahteine 80a0c3b028 reorder 2020-10-04 12:35:53 -04:00
Scott Lahteine e73644f3fe Stepper current refactor 2020-10-04 12:35:53 -04:00
Scott Lahteine 9a6d6a4405 Various fixes, cleanup 2020-10-04 12:35:52 -04:00
InsanityAutomation 777abb71b5 Add missed lines from working branch 2020-10-04 12:35:52 -04:00
InsanityAutomation ac4ffdb4e5 Update G34_M422.cpp 2020-10-04 12:35:52 -04:00
InsanityAutomation 691a297b6a DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-10-04 12:35:52 -04:00
InsanityAutomation bec97532ee Sanity Checks, gcode calls 2020-10-04 12:35:52 -04:00
InsanityAutomation 406cd0cc83 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-10-04 12:35:52 -04:00
Victor Oliveira 62af625be4 STM32F1Minor SPI fixes, systick_callback for HAL compatibility (#19565) 2020-10-01 20:52:42 -05:00
InsanityAutomation 26917ebf96 Merge branch 'Reimplement-Prusa-M915-into-G34' of https://github.com/InsanityAutomation/Marlin into Reimplement-Prusa-M915-into-G34 2020-09-23 18:53:45 -04:00
InsanityAutomation 3d8bfb036d Enable Post G28 by default as its usually necessary 2020-09-23 18:50:54 -04:00
InsanityAutomation a0f0af5da8 Prevent min move from going into overflow sending Z to 65k 2020-09-23 18:50:54 -04:00
InsanityAutomation 27c99f74ad Update Configuration_adv.h 2020-09-23 18:50:54 -04:00
InsanityAutomation 050cef7b48 Fix compile errors 2020-09-23 18:50:54 -04:00
Scott Lahteine 5d74ace99f …and… 2020-09-23 18:50:54 -04:00
Scott Lahteine 3130fd9532 Fix sprintf_P call 2020-09-23 18:50:54 -04:00
Scott Lahteine f0c531abb6 helpful patch 2020-09-23 18:50:53 -04:00
Scott Lahteine ce2874b732 Clean up G34/M422 2020-09-23 18:50:53 -04:00
Scott Lahteine a55cef1165 Provide MSG_ITERATION 2020-09-23 18:50:53 -04:00
Scott Lahteine 682b0b440d reorder 2020-09-23 18:50:53 -04:00
Scott Lahteine 7025912957 Stepper current refactor 2020-09-23 18:50:53 -04:00
Scott Lahteine bb6b23891c Various fixes, cleanup 2020-09-23 18:50:52 -04:00
InsanityAutomation 1b211947b8 Add missed lines from working branch 2020-09-23 18:50:52 -04:00
InsanityAutomation ea15d3edab Update G34_M422.cpp 2020-09-23 18:50:52 -04:00
InsanityAutomation 47c6f8a98b DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-09-23 18:50:52 -04:00
InsanityAutomation ccb2c3bb85 Sanity Checks, gcode calls 2020-09-23 18:50:52 -04:00
InsanityAutomation e74b9776e5 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-09-23 18:50:52 -04:00
InsanityAutomation e61bbe1499 Enable Post G28 by default as its usually necessary 2020-09-19 00:27:23 -04:00
InsanityAutomation ffd7062e21 Prevent min move from going into overflow sending Z to 65k 2020-09-19 00:14:10 -04:00
InsanityAutomation 7255ca0bc6 Update Configuration_adv.h 2020-09-19 00:02:06 -04:00
InsanityAutomation f7c56bc5e4 Fix compile errors 2020-09-17 11:16:01 -04:00
InsanityAutomation e4c973487b Merge branch 'bugfix-2.0.x' into Reimplement-Prusa-M915-into-G34 2020-09-17 10:40:14 -04:00
Scott Lahteine d4ab268bbf …and… 2020-09-16 16:38:01 -04:00
Scott Lahteine b4dbf606b7 Fix sprintf_P call 2020-09-16 16:38:01 -04:00
Scott Lahteine f6a1d772c2 helpful patch 2020-09-16 16:38:00 -04:00
Scott Lahteine ae208fa92f Clean up G34/M422 2020-09-16 16:38:00 -04:00
Scott Lahteine f11d496899 Provide MSG_ITERATION 2020-09-16 16:38:00 -04:00
Scott Lahteine a3d0fe53cf reorder 2020-09-16 16:38:00 -04:00
Scott Lahteine 395d11b06f Stepper current refactor 2020-09-16 16:38:00 -04:00
Scott Lahteine e79b328103 Various fixes, cleanup 2020-09-16 16:37:59 -04:00
InsanityAutomation 1c19d9a86a Add missed lines from working branch 2020-09-16 16:37:59 -04:00
InsanityAutomation 6043f88b35 Update G34_M422.cpp 2020-09-16 16:37:59 -04:00
InsanityAutomation 2087e6fbcf DIGIPOTSS in motter current array with PWM, stored to eeprom, and G34 tested 2020-09-16 16:37:59 -04:00
InsanityAutomation c67086bdba Sanity Checks, gcode calls 2020-09-16 16:37:59 -04:00
InsanityAutomation 24e6dbcf48 Add New G34 mode for current adjustable drivers
TODO : Sanity checks, Finish DAC mode, Test on Rambo
2020-09-16 16:37:58 -04:00
1845 changed files with 151550 additions and 71447 deletions
+15 -5
View File
@@ -1,19 +1,29 @@
# editorconfig.org
root = true
[*]
trim_trailing_whitespace = true
insert_final_newline = true
[{*.patch,syntax_test_*}]
trim_trailing_whitespace = false
[{*.c,*.cpp,*.h,*.ino,*.py,Makefile}]
end_of_line = lf
[{*.c,*.cpp,*.h,*.ino}]
charset = utf-8
[{*.c,*.cpp,*.h,*.ino,Makefile}]
trim_trailing_whitespace = true
insert_final_newline = true
end_of_line = lf
indent_style = space
indent_size = 2
[{Makefile}]
indent_style = tab
indent_size = 2
[*.md]
# Two spaces at the end of the line means newline in Markdown
trim_trailing_whitespace = false
[{*.py}]
indent_style = space
indent_size = 4
+9 -3
View File
@@ -1,6 +1,7 @@
name: 🪲 Report a bug
description: Create a bug report to help improve Marlin Firmware
title: "[BUG] (bug summary)"
labels: ["Bug: Potential ?"]
body:
- type: markdown
attributes:
@@ -100,7 +101,7 @@ body:
- type: input
attributes:
label: Printer model
description: Creality Ender 3, Prusa mini, or Kossel Delta?
description: Creality Ender-3, Prusa mini, or Kossel Delta?
- type: input
attributes:
@@ -109,8 +110,13 @@ body:
- type: input
attributes:
label: Add-ons
description: Please list any hardware add-ons that could be involved.
label: LCD/Controller
description: Some Marlin behaviors are determined by the controller. Describe your LCD/Controller model and version.
- type: input
attributes:
label: Other add-ons
description: Please list any other hardware add-ons that could be involved.
- type: dropdown
attributes:
+1 -1
View File
@@ -1,7 +1,7 @@
name: ✨ Request a feature
description: Request a new Marlin Firmware feature
title: "[FR] (feature summary)"
labels: 'T: Feature Request'
labels: ["T: Feature Request"]
body:
- type: markdown
attributes:
+1 -7
View File
@@ -28,15 +28,9 @@ Project maintainers are responsible for clarifying the standards of acceptable b
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at [marlinfirmware@github.com](mailto:marlinfirmware@github.com). All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by following GitHub's [reporting abuse or spam article](https://docs.github.com/en/communities/maintaining-your-safety-on-github/reporting-abuse-or-spam). All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances.
## Attribution
+5 -3
View File
@@ -26,11 +26,12 @@ The following is a set of guidelines for contributing to Marlin, hosted by the [
## Code of Conduct
This project and everyone participating in it is governed by the [Marlin Code of Conduct](code_of_conduct.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to [marlinfirmware@github.com](mailto:marlinfirmware@github.com).
This project and everyone participating in it is governed by the [Marlin Code of Conduct](code_of_conduct.md). By participating, you are expected to uphold this code. Please report unacceptable behavior by following GitHub's [reporting abuse or spam article](https://docs.github.com/en/communities/maintaining-your-safety-on-github/reporting-abuse-or-spam).
## I don't want to read this whole thing I just have a question!!!
> **Note:** Please don't file an issue to ask a question. You'll get faster results by using the resources below.
> [!NOTE]
> Please don't file an issue to ask a question. You'll get faster results by using the resources below.
We have a Message Board and a Facebook group where our knowledgable user community can provide helpful advice if you have questions.
@@ -55,7 +56,8 @@ This section guides you through submitting a Bug Report for Marlin. Following th
Before creating a Bug Report, please test the "nightly" development branch, as you might find out that you don't need to create one. When you are creating a Bug Report, please [include as many details as possible](#how-do-i-submit-a-good-bug-report). Fill out [the required template](ISSUE_TEMPLATE/bug_report.yml), the information it asks for helps us resolve issues faster.
> **Note:** Regressions can happen. If you find a **Closed** issue that seems like your issue, go ahead and open a new issue and include a link to the original issue in the body of your new one. All you need to create a link is the issue number, preceded by #. For example, #8888.
> [!NOTE]
> Regressions can happen. If you find a **Closed** issue that seems like your issue, go ahead and open a new issue and include a link to the original issue in the body of your new one. All you need to create a link is the issue number, preceded by #. For example, #8888.
#### How Do I Submit A (Good) Bug Report?
+41
View File
@@ -0,0 +1,41 @@
#
# auto-label.yml
# - Find all open issues without a label and a title containing "[BUG]".
# - Apply the label "Bug: Potential ?" to these issues.
#
name: Label Old Bugs
on:
schedule:
- cron: "30 8 * * *"
jobs:
autolabel:
name: Auto Label
if: github.repository == 'MarlinFirmware/Marlin'
runs-on: ubuntu-latest
steps:
- name: Auto Label for [BUG]
uses: actions/github-script@v7
with:
script: |
// Get all open issues in this repository
const issueList = await github.rest.issues.listForRepo({
owner: context.repo.owner,
repo: context.repo.repo,
state: 'open'
});
// Filter issues without labels that have a title containing '[BUG]'.
const matchingIssues = issueList.data.filter(
issue => issue.title.includes('[BUG]') && issue.labels.length === 0
);
// Process the first 50
for (const issue of matchingIssues.slice(0, 50)) {
await github.rest.issues.addLabels({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: issue.number,
labels: ['Bug: Potential ?']
});
}
+4 -4
View File
@@ -18,10 +18,10 @@ jobs:
steps:
- name: Check out bugfix-2.1.x
uses: actions/checkout@v2
- name: Check out bugfix-2.0.x
uses: actions/checkout@v3
with:
ref: bugfix-2.1.x
ref: bugfix-2.0.x
- name: Bump Date (bugfix-2.0.x)
run: |
@@ -39,7 +39,7 @@ jobs:
exit 0
- name: Check out bugfix-2.1.x
uses: actions/checkout@v2
uses: actions/checkout@v3
with:
ref: bugfix-2.1.x
-1
View File
@@ -12,7 +12,6 @@ on:
- 1.0.x
- 1.1.x
- 2.0.x
- 2.1.x
jobs:
bad_target:
+2 -1
View File
@@ -23,6 +23,7 @@ jobs:
- "S: Please Merge"
- "S: Please Test"
- "help wanted"
- "Bug: Potential ?"
- "Needs: Discussion"
- "Needs: Documentation"
- "Needs: More Data"
@@ -31,7 +32,7 @@ jobs:
- "Needs: Work"
steps:
- uses: actions/checkout@v2
- uses: actions/checkout@v3
- name: Remove Labels
uses: actions-ecosystem/action-remove-labels@v1
with:
+16 -4
View File
@@ -17,12 +17,24 @@ jobs:
runs-on: ubuntu-latest
steps:
- uses: actions/stale@v3
- uses: actions/stale@v8
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
stale-issue-message: 'This issue has had no activity in the last 60 days. Please add a reply if you want to keep this issue active, otherwise it will be automatically closed within 10 days.'
days-before-stale: 60
days-before-close: 10
stale-issue-message: |
Greetings from the Marlin AutoBot!
This issue has had no activity for the last 90 days.
Do you still see this issue with the latest `bugfix-2.1.x` code?
Please add a reply within 14 days or this issue will be automatically closed.
To keep a confirmed issue open we can also add a "Bug: Confirmed" tag.
Disclaimer: This is an open community project with lots of activity and limited
resources. The main project contributors will do a bug sweep ahead of the next
release, but any skilled member of the community may jump in at any time to fix
this issue. That can take a while depending on our busy lives so please be patient,
and take advantage of other resources such as the MarlinFirmware Discord to help
solve the issue.
days-before-stale: 90
days-before-close: 14
stale-issue-label: 'stale-closing-soon'
exempt-all-assignees: true
exempt-issue-labels: 'Bug: Confirmed !,T: Feature Request,Needs: More Data,Needs: Discussion,Needs: Documentation,Needs: Patch,Needs: Work,Needs: Testing,help wanted,no-locking'
+92 -63
View File
@@ -9,6 +9,7 @@ on:
pull_request:
branches:
- bugfix-2.1.x
- 2.1.x
paths-ignore:
- config/**
- data/**
@@ -17,6 +18,7 @@ on:
push:
branches:
- bugfix-2.1.x
- 2.1.x
paths-ignore:
- config/**
- data/**
@@ -33,94 +35,121 @@ jobs:
strategy:
matrix:
test-platform:
# Base Environments
- DUE
- DUE_archim
- esp32
# Native
- linux_native
# AVR
- mega2560
- at90usb1286_dfu
- teensy31
- teensy35
- teensy41
- SAMD21_minitronics20
- SAMD51_grandcentral_m4
- PANDA_PI_V29
# Extended AVR Environments
- FYSETC_F6
- mega1280
- at90usb1286_dfu
# AVR Extended
- FYSETC_F6
- melzi_optiboot
- rambo
- sanguino1284p
- sanguino644p
# STM32F1 (Maple) Environments
# SAM3X8E
- DUE
- DUE_archim
#- STM32F103RC_btt_maple
- STM32F103RC_btt_USB_maple
- STM32F103RC_fysetc_maple
- STM32F103RC_meeb_maple
- jgaurora_a5s_a1_maple
- STM32F103VE_longer_maple
#- mks_robin_maple
- mks_robin_lite_maple
- mks_robin_pro_maple
#- mks_robin_nano_v1v2_maple
#- STM32F103RE_creality_maple
- STM32F103VE_ZM3E4V2_USB_maple
# SAMD21
- SAMD51_grandcentral_m4
- SAMD21_minitronics20
# STM32 (ST) Environments
# ESP32
- esp32
- mks_tinybee
# Teensy 2
#- at90usb1286_cdc
# Teensy MK20DX256
- teensy31
# Teensy MK64FX512, MK66FX1M0
- teensy35
# Teensy IMXRT1062DVx6A
- teensy41
# STM32F0
- malyan_M300
- STM32F070CB_malyan
- STM32F070RB_malyan
# STM32F1
- chitu_f103
- mks_robin
- mks_robin_nano_v1v2
- PANDA_PI_V29
- STM32F103RC_btt
#- STM32F103RC_btt_USB
- STM32F103RC_fysetc
- STM32F103RE_btt
- STM32F103RE_btt_USB
- STM32F103RE_creality
- STM32F401RC_creality
- STM32F103VE_longer
- STM32F407VE_black
- BIGTREE_BTT002
- BIGTREE_SKR_PRO
- BIGTREE_GTR_V1_0
- mks_robin
- ARMED
- FYSETC_S6
- STM32F070CB_malyan
- STM32F070RB_malyan
- malyan_M300
- FLYF407ZG
- rumba32
- LERDGEX
- LERDGEK
- mks_robin_nano_v1v2
#- mks_robin_nano_v1v2_usbmod
#- mks_robin_mini
#- mks_robin_nano_v1_3_f4_usbmod
#- mks_robin_nano_v1v2_usbmod
#- STM32F103CB_malyan
#- STM32F103RC_btt_USB
#- STM32F103RE
# STM32F4
- ARMED
- BIGTREE_BTT002
- BIGTREE_GTR_V1_0
- BIGTREE_SKR_PRO
- FLYF407ZG
- FYSETC_S6
- LERDGEK
- LERDGEX
- mks_robin_pro2
- Opulo_Lumen_REV3
- rumba32
- STM32F401RC_creality
- STM32F407VE_black
- I3DBEEZ9_V1
# STM32F7
- NUCLEO_F767ZI
- REMRAM_V1
# STM32H7
- BTT_SKR_SE_BX
- chitu_f103
- Opulo_Lumen_REV3
- STM32H743VI_btt
# ESP32 environments
- mks_tinybee
# STM32F1 (Maple)
- jgaurora_a5s_a1_maple
- mks_robin_lite_maple
- mks_robin_pro_maple
- STM32F103RC_btt_USB_maple
- STM32F103RC_fysetc_maple
- STM32F103RC_meeb_maple
- STM32F103VE_longer_maple
- STM32F103VE_ZM3E4V2_USB_maple
#- mks_robin_maple
#- mks_robin_nano_v1v2_maple
#- STM32F103RC_btt_maple
#- STM32F103RE_creality_maple
# Put lengthy tests last
# STM32G0
- STM32G0B1RE_btt
# HC32
- HC32F460C_aquila_101
# LPC176x - Lengthy tests
- LPC1768
- LPC1769
# Non-working environment tests
#- at90usb1286_cdc
#- STM32F103CB_malyan
#- STM32F103RE
#- mks_robin_mini
steps:
- name: Check out the PR
uses: actions/checkout@v3
uses: actions/checkout@v4
- name: Cache pip
uses: actions/cache@v3
@@ -136,11 +165,11 @@ jobs:
path: ~/.platformio
key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
- name: Select Python 3.7
uses: actions/setup-python@v3
- name: Select Python 3.9
uses: actions/setup-python@v4
with:
python-version: '3.7' # Version range or exact version of a Python version to use, using semvers version range syntax.
architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
python-version: '3.9'
architecture: 'x64'
- name: Install PlatformIO
run: |
+22 -25
View File
@@ -25,32 +25,17 @@ bdf2u8g.exe
genpages.exe
marlin_config.json
mczip.h
language*.csv
out-csv/
out-language/
*.gen
*.sublime-workspace
#
# OS
#
applet/
.DS_Store
#
# Misc
#
*~
*.orig
*.rej
*.bak
*.idea
*.i
*.ii
*.swp
tags
#
# C++
#
# Compiled Object files
# Compiled C++ Object files
*.slo
*.lo
*.o
@@ -81,10 +66,7 @@ tags
*.out
*.app
#
# C
#
# Object files
# Compiled C Object files
*.o
*.ko
*.obj
@@ -144,14 +126,16 @@ vc-fileutils.settings
.vscode/*
!.vscode/extensions.json
#Simulation
# Simulation files
imgui.ini
eeprom.dat
spi_flash.bin
fs.img
#cmake
# CMake
buildroot/share/cmake/*
CMakeLists.txt
!buildroot/share/cmake/CMakeLists.txt
src/CMakeLists.txt
CMakeListsPrivate.txt
build/
@@ -171,3 +155,16 @@ __pycache__
# IOLogger logs
*_log.csv
# Misc.
*~
*.orig
*.rej
*.bak
*.idea
*.i
*.ii
*.swp
tags
*.logs
*.bak
+1
View File
@@ -6,6 +6,7 @@
"platformio.platformio-ide"
],
"unwantedRecommendations": [
"ms-vscode-remote.remote-containers",
"ms-vscode.cpptools-extension-pack"
]
}
+25 -8
View File
@@ -1,11 +1,17 @@
SCRIPTS_DIR := buildroot/share/scripts
CONTAINER_RT_BIN := docker
CONTAINER_RT_OPTS := --rm -v $(PWD):/code -v platformio-cache:/root/.platformio
CONTAINER_IMAGE := marlin-dev
help:
@echo "Tasks for local development:"
@echo "* format-pins: Reformat all pins files"
@echo "* tests-single-ci: Run a single test from inside the CI"
@echo "* tests-single-local: Run a single test locally"
@echo "* tests-single-local-docker: Run a single test locally, using docker-compose"
@echo "* tests-single-local-docker: Run a single test locally, using docker"
@echo "* tests-all-local: Run all tests locally"
@echo "* tests-all-local-docker: Run all tests locally, using docker-compose"
@echo "* setup-local-docker: Setup local docker-compose"
@echo "* tests-all-local-docker: Run all tests locally, using docker"
@echo "* setup-local-docker: Build the local docker image"
@echo ""
@echo "Options for testing:"
@echo " TEST_TARGET Set when running tests-single-*, to select the"
@@ -22,7 +28,7 @@ help:
tests-single-ci:
export GIT_RESET_HARD=true
$(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET)
$(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) PLATFORMIO_BUILD_FLAGS=-DGITHUB_ACTION
.PHONY: tests-single-ci
tests-single-local:
@@ -34,19 +40,30 @@ tests-single-local:
tests-single-local-docker:
@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local-docker" ; return 1; fi
docker-compose run --rm marlin $(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
.PHONY: tests-single-local-docker
tests-all-local:
export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
&& export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
&& for TEST_TARGET in $$(./get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; done
&& for TEST_TARGET in $$($(SCRIPTS_DIR)/get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; done
.PHONY: tests-all-local
tests-all-local-docker:
docker-compose run --rm marlin $(MAKE) tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
.PHONY: tests-all-local-docker
setup-local-docker:
docker-compose build
$(CONTAINER_RT_BIN) build -t $(CONTAINER_IMAGE) -f docker/Dockerfile .
.PHONY: setup-local-docker
PINS := $(shell find Marlin/src/pins -mindepth 2 -name '*.h')
.PHONY: $(PINS)
$(PINS): %:
@echo "Formatting $@" && node buildroot/share/scripts/pinsformat.js $@
format-pins: $(PINS)
+846 -433
View File
File diff suppressed because it is too large Load Diff
+885 -449
View File
File diff suppressed because it is too large Load Diff
+20 -20
View File
@@ -63,8 +63,8 @@ HARDWARE_MOTHERBOARD ?= 1020
ifeq ($(OS),Windows_NT)
# Windows
ARDUINO_INSTALL_DIR ?= ${HOME}/Arduino
ARDUINO_USER_DIR ?= ${HOME}/Arduino
ARDUINO_INSTALL_DIR ?= ${HOME}/AppData/Local/Arduino
ARDUINO_USER_DIR ?= ${HOME}/Documents/Arduino
else
UNAME_S := $(shell uname -s)
ifeq ($(UNAME_S),Linux)
@@ -82,11 +82,11 @@ endif
# Arduino source install directory, and version number
# On most linuxes this will be /usr/share/arduino
ARDUINO_INSTALL_DIR ?= ${HOME}/Arduino
ARDUINO_VERSION ?= 106
ARDUINO_INSTALL_DIR ?= ${HOME}/AppData/Local/Arduino # C:/Users/${USERNAME}/AppData/Local/Arduino
ARDUINO_VERSION ?= 10819
# The installed Libraries are in the User folder
ARDUINO_USER_DIR ?= ${HOME}/Arduino
ARDUINO_USER_DIR ?= ${HOME}/Documents/Arduino
# You can optionally set a path to the avr-gcc tools.
# Requires a trailing slash. For example, /usr/local/avr-gcc/bin/
@@ -656,18 +656,18 @@ ifeq ($(HARDWARE_VARIANT), $(filter $(HARDWARE_VARIANT),arduino Teensy Sanguino)
# Old libraries (avr-core 1.6.21 < / Arduino < 1.6.8)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
# New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/arduino/avr/1.8.6/libraries/SPI/src
endif
ifeq ($(IS_MCU),1)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/cores/arduino
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/arduino/avr/1.8.6/cores/arduino
# Old libraries (avr-core 1.6.21 < / Arduino < 1.6.8)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SoftwareSerial
# New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SoftwareSerial/src
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/arduino/avr/1.8.6/libraries/SPI/src
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/arduino/avr/1.8.6/libraries/SoftwareSerial/src
endif
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/LiquidCrystal/src
@@ -681,17 +681,17 @@ ifeq ($(WIRE), 1)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/utility
# New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/src
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/src/utility
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/libraries/Wire/src
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/libraries/Wire/src/utility
endif
ifeq ($(NEOPIXEL), 1)
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Adafruit_NeoPixel
endif
ifeq ($(U8GLIB), 1)
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/csrc
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/cppsrc
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/fntsrc
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib-HAL
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib-HAL/src
# VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib
# VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/src
endif
ifeq ($(TMC), 1)
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/TMCStepper/src
@@ -700,9 +700,9 @@ endif
ifeq ($(HARDWARE_VARIANT), arduino)
HARDWARE_SUB_VARIANT ?= mega
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/variants/$(HARDWARE_SUB_VARIANT)
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/variants/$(HARDWARE_SUB_VARIANT)
else ifeq ($(HARDWARE_VARIANT), Sanguino)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/marlin/avr/variants/sanguino
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/variants/sanguino
else ifeq ($(HARDWARE_VARIANT), archim)
VPATH += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/system/libsam
VPATH += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/system/CMSIS/CMSIS/Include/
@@ -718,7 +718,7 @@ else ifeq ($(HARDWARE_VARIANT), archim)
LDLIBS = $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/variants/archim/libsam_sam3x8e_gcc_rel.a
else
HARDWARE_SUB_VARIANT ?= standard
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/$(HARDWARE_VARIANT)/variants/$(HARDWARE_SUB_VARIANT)
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/avr/1.8.6/variants/$(HARDWARE_SUB_VARIANT)
endif
LIB_SRC = wiring.c \
@@ -733,7 +733,7 @@ endif
ifeq ($(HARDWARE_VARIANT), Teensy)
LIB_SRC = wiring.c
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/teensy/cores/teensy
VPATH += $(ARDUINO_INSTALL_DIR)/packages/arduino/hardware/teensy/cores/teensy
endif
LIB_CXXSRC = WMath.cpp WString.cpp Print.cpp SPI.cpp
@@ -880,7 +880,7 @@ AVRDUDE_WRITE_FLASH = -Uflash:w:$(BUILD_DIR)/$(TARGET).hex:i
ifeq ($(shell uname -s), Linux)
AVRDUDE_CONF = /etc/avrdude/avrdude.conf
else
AVRDUDE_CONF = $(ARDUINO_INSTALL_DIR)/hardware/tools/avr/etc/avrdude.conf
AVRDUDE_CONF = $(ARDUINO_INSTALL_DIR)/packages/arduino/tools/avrdude/6.3.0-arduino17/etc/avrdude.conf
endif
AVRDUDE_FLAGS = -D -C$(AVRDUDE_CONF) \
-p$(PROG_MCU) -P$(AVRDUDE_PORT) -c$(AVRDUDE_PROGRAMMER) \
+2 -2
View File
@@ -2,7 +2,7 @@
Marlin Firmware
(c) 2011-2020 MarlinFirmware
(c) 2011-2023 MarlinFirmware
Portions of Marlin are (c) by their respective authors.
All code complies with GPLv2 and/or GPLv3
@@ -27,7 +27,7 @@ Configuration
- https://github.com/MarlinFirmware/Configurations
Example configurations for several printer models.
- https://www.youtube.com/watch?v=3gwWVFtdg-4
- https://youtu.be/3gwWVFtdg-4
A good 20-minute overview of Marlin configuration by Tom Sanladerer.
(Applies to Marlin 1.0.x, so Jerk and Acceleration should be halved.)
Also... https://www.google.com/search?tbs=vid%3A1&q=configure+marlin
+1 -1
View File
@@ -41,7 +41,7 @@
* here we define this default string as the date where the latest release
* version was tagged.
*/
//#define STRING_DISTRIBUTION_DATE "2023-03-10"
//#define STRING_DISTRIBUTION_DATE "2024-01-09"
/**
* Defines a generic printer name to be output to the LCD after booting Marlin.
+103
View File
@@ -0,0 +1,103 @@
/**
* Marlin 3D Printer Firmware
* Copyright (C) 2016 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 <http://www.gnu.org/licenses/>.
*
*/
/**
* Custom Bitmap for splashscreen
*
* You may use one of the following tools to generate the C++ bitmap array from
* a black and white image:
*
* - http://www.marlinfw.org/tools/u8glib/converter.html
* - http://www.digole.com/tools/PicturetoC_Hex_converter.php
*/
#include <avr/pgmspace.h>
#define CUSTOM_BOOTSCREEN_TIMEOUT 2500
#define CUSTOM_BOOTSCREEN_BMPWIDTH 60
#define CUSTOM_BOOTSCREEN_BMPHEIGHT 64
const unsigned char custom_start_bmp[574] PROGMEM = {
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x12, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x23, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x21, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x4c, 0x80, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x5e, 0x80, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x92, 0x40, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0xa1, 0x40, 0x0, 0x0, 0x0,
0x0, 0x0, 0x1, 0x21, 0x20, 0x0, 0x0, 0x0,
0x0, 0x0, 0x2, 0x7f, 0x90, 0x0, 0x0, 0x0,
0x0, 0x0, 0x2, 0x0, 0x10, 0x0, 0x0, 0x0,
0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0,
0x0, 0x0, 0x4, 0x0, 0x8, 0x0, 0x0, 0x0,
0x0, 0x0, 0x8, 0x0, 0x4, 0x0, 0x0, 0x0,
0x0, 0x0, 0x8, 0x0, 0x6, 0x0, 0x0, 0x0,
0x0, 0x0, 0x10, 0x0, 0x2, 0x0, 0x0, 0x0,
0x0, 0x0, 0x30, 0x1e, 0x1, 0x0, 0x0, 0x0,
0x0, 0x0, 0x20, 0x7f, 0x81, 0x0, 0x0, 0x0,
0x0, 0x0, 0x41, 0xff, 0xe0, 0x80, 0x0, 0x0,
0x0, 0x0, 0x43, 0xfc, 0xf0, 0x80, 0x0, 0x0,
0x0, 0x0, 0x87, 0x3b, 0x78, 0x40, 0x0, 0x0,
0x0, 0x1, 0x8e, 0xdb, 0xfc, 0x60, 0x0, 0x0,
0x0, 0x1, 0xf, 0xeb, 0xcc, 0x20, 0x0, 0x0,
0x0, 0x2, 0x1f, 0xed, 0xb6, 0x10, 0x0, 0x0,
0x0, 0x2, 0x1f, 0xde, 0xb6, 0x10, 0x0, 0x0,
0x0, 0x4, 0x39, 0xcd, 0x7f, 0x8, 0x0, 0x0,
0x0, 0x4, 0x36, 0xe0, 0xff, 0x8, 0x0, 0x0,
0x0, 0x8, 0x7e, 0xc0, 0xbb, 0x84, 0x0, 0x0,
0x0, 0x18, 0x7f, 0x0, 0x5d, 0x86, 0x0, 0x0,
0x0, 0x10, 0x7f, 0xc0, 0xed, 0x82, 0x0, 0x0,
0x0, 0x20, 0x3c, 0xc0, 0x73, 0x1, 0x0, 0x0,
0x0, 0x20, 0x3b, 0x33, 0x7f, 0x1, 0x0, 0x0,
0x0, 0x70, 0x1b, 0xe7, 0x7e, 0x3, 0x80, 0x0,
0x0, 0xc8, 0x1d, 0xee, 0xde, 0x4, 0xc0, 0x0,
0x0, 0x88, 0xf, 0xde, 0xdc, 0x4, 0x40, 0x0,
0x1, 0x24, 0xf, 0xdf, 0x3c, 0x9, 0x20, 0x0,
0x1, 0x26, 0x7, 0xdb, 0xf8, 0x19, 0x20, 0x0,
0x2, 0x72, 0x3, 0xe7, 0xf0, 0x13, 0x90, 0x0,
0x2, 0x51, 0x1, 0xff, 0xe0, 0x22, 0x90, 0x0,
0x4, 0x89, 0x0, 0x7f, 0x80, 0x24, 0x48, 0x0,
0x9, 0x4, 0x80, 0x1e, 0x0, 0x48, 0x24, 0x0,
0xb, 0xfe, 0x40, 0x0, 0x0, 0xdf, 0xf4, 0x0,
0x10, 0x0, 0x40, 0x0, 0x0, 0x80, 0x2, 0x0,
0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x10, 0x22, 0x10, 0x3c, 0x3c, 0xe, 0x1f, 0x0,
0x10, 0x22, 0x10, 0x4, 0x22, 0x11, 0x4, 0x0,
0x10, 0x22, 0x10, 0x8, 0x22, 0x11, 0x4, 0x0,
0x10, 0x22, 0x10, 0x8, 0x3c, 0x11, 0x4, 0x0,
0x10, 0x22, 0x10, 0x10, 0x22, 0x11, 0x4, 0x0,
0x10, 0x22, 0x10, 0x20, 0x22, 0x11, 0x4, 0x0,
0x1e, 0x1c, 0x1e, 0x3c, 0x3c, 0xe, 0x4, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
};
+54 -18
View File
@@ -3,10 +3,50 @@
# config.ini - Options to apply before the build
#
[config:base]
#
# ini_use_config - A comma-separated list of actions to apply to the Configuration files.
# The actions will be applied in the listed order.
# - none
# Ignore this file and don't apply any configuration options
#
# - base
# Just apply the options in config:base to the configuration
#
# - minimal
# Just apply the options in config:minimal to the configuration
#
# - all
# Apply all 'config:*' sections in this file to the configuration
#
# - another.ini
# Load another INI file with a path relative to this config.ini file (i.e., within Marlin/)
#
# - https://me.myserver.com/path/to/configs
# Fetch configurations from any URL.
#
# - example/Creality/Ender-5 Plus @ bugfix-2.1.x
# Fetch example configuration files from the MarlinFirmware/Configurations repository
# https://raw.githubusercontent.com/MarlinFirmware/Configurations/bugfix-2.1.x/config/examples/Creality/Ender-5%20Plus/
#
# - example/default @ release-2.0.9.7
# Fetch default configuration files from the MarlinFirmware/Configurations repository
# https://raw.githubusercontent.com/MarlinFirmware/Configurations/release-2.0.9.7/config/default/
#
# - [disable]
# Comment out all #defines in both Configuration.h and Configuration_adv.h. This is useful
# to start with a clean slate before applying any config: options, so only the options explicitly
# set in config.ini will be enabled in the configuration.
#
# - [flatten] (Not yet implemented)
# Produce a flattened set of Configuration.h and Configuration_adv.h files with only the enabled
# #defines and no comments. A clean look, but context-free.
#
ini_use_config = none
# Load all config: sections in this file
;ini_use_config = all
# Disable everything and apply subsequent config:base options
;ini_use_config = [disable], base
# Load config file relative to Marlin/
;ini_use_config = another.ini
# Download configurations from GitHub
@@ -42,7 +82,7 @@ preheat_1_temp_hotend = 180
bang_max = 255
pidtemp = on
pid_k1 = 0.95
pid_max = BANG_MAX
pid_max = 255
pid_functional_range = 10
default_kp = 22.20
@@ -69,13 +109,9 @@ x_home_dir = -1
y_home_dir = -1
z_home_dir = -1
use_xmin_plug = on
use_ymin_plug = on
use_zmin_plug = on
x_min_endstop_inverting = false
y_min_endstop_inverting = false
z_min_endstop_inverting = false
x_min_endstop_hit_state = HIGH
y_min_endstop_hit_state = HIGH
z_min_endstop_hit_state = HIGH
default_axis_steps_per_unit = { 80, 80, 400, 500 }
axis_relative_modes = { false, false, false, false }
@@ -100,10 +136,10 @@ step_state_x = HIGH
step_state_y = HIGH
step_state_z = HIGH
disable_x = false
disable_y = false
disable_z = false
disable_e = false
disable_x = off
disable_y = off
disable_z = off
disable_e = off
proportional_font_ratio = 1.0
default_nominal_filament_dia = 1.75
@@ -127,7 +163,7 @@ busy_while_heating = on
default_ejerk = 5.0
default_keepalive_interval = 2
default_leveling_fade_height = 0.0
disable_inactive_extruder = on
disable_other_extruders = on
display_charset_hd44780 = JAPANESE
eeprom_boot_silent = on
eeprom_chitchat = on
@@ -176,12 +212,12 @@ auto_report_temperatures = on
autotemp = on
autotemp_oldweight = 0.98
bed_check_interval = 5000
default_stepper_deactive_time = 120
default_stepper_timeout_sec = 120
default_volumetric_extruder_limit = 0.00
disable_inactive_extruder = true
disable_inactive_x = true
disable_inactive_y = true
disable_inactive_z = true
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
+25 -8
View File
@@ -61,23 +61,40 @@ void save_reset_reason() {
wdt_disable();
}
#include "registers.h"
MarlinHAL::MarlinHAL() {
TERN_(HAL_AVR_DIRTY_INIT, _ATmega_resetperipherals()); // Clean-wipe the device state.
}
void MarlinHAL::init() {
// Init Servo Pins
#define INIT_SERVO(N) OUT_WRITE(SERVO##N##_PIN, LOW)
#if HAS_SERVO_0
INIT_SERVO(0);
OUT_WRITE(SERVO0_PIN, LOW);
#endif
#if HAS_SERVO_1
INIT_SERVO(1);
OUT_WRITE(SERVO1_PIN, LOW);
#endif
#if HAS_SERVO_2
INIT_SERVO(2);
OUT_WRITE(SERVO2_PIN, LOW);
#endif
#if HAS_SERVO_3
INIT_SERVO(3);
OUT_WRITE(SERVO3_PIN, LOW);
#endif
init_pwm_timers(); // Init user timers to default frequency - 1000HZ
#if PIN_EXISTS(BEEPER) && ENABLED(HAL_AVR_DIRTY_INIT) && DISABLED(ATMEGA_NO_BEEPFIX)
// Make sure no alternative is locked onto the BEEPER.
// This fixes the issue where the ATmega is constantly beeping.
// Might disable other peripherals using the pin; to circumvent that please undefine one of the above things!
// The true culprit is the AVR ArduinoCore that enables peripherals redundantly.
// (USART1 on the GeeeTech GT2560)
// https://www.youtube.com/watch?v=jMgCvRXkexk
_ATmega_savePinAlternate(BEEPER_PIN);
OUT_WRITE(BEEPER_PIN, LOW);
#endif
}
void MarlinHAL::reboot() {
@@ -145,12 +162,12 @@ void MarlinHAL::reboot() {
// Free Memory Accessor
// ------------------------
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
#include "../../sd/SdFatUtil.h"
int freeMemory() { return SdFatUtil::FreeRam(); }
#else // !SDSUPPORT
#else // !HAS_MEDIA
extern "C" {
extern char __bss_end;
@@ -167,6 +184,6 @@ void MarlinHAL::reboot() {
}
}
#endif // !SDSUPPORT
#endif // !HAS_MEDIA
#endif // __AVR__
+7 -5
View File
@@ -1,7 +1,9 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
*
* 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
@@ -140,15 +142,15 @@ typedef Servo hal_servo_t;
#endif
#define LCD_SERIAL lcdSerial
#if HAS_DGUS_LCD
#define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
#define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
#endif
#endif
//
// ADC
//
#define HAL_ADC_VREF 5.0
#define HAL_ADC_RESOLUTION 10
#define HAL_ADC_VREF_MV 5000
#define HAL_ADC_RESOLUTION 10
//
// Pin Mapping for M42, M43, M226
@@ -187,7 +189,7 @@ class MarlinHAL {
public:
// Earliest possible init, before setup()
MarlinHAL() {}
MarlinHAL();
// Watchdog
static void watchdog_init() IF_DISABLED(USE_WATCHDOG, {});
+2 -2
View File
@@ -198,7 +198,7 @@ void spiBegin() {
// output pin high - like sending 0xFF
WRITE(SD_MOSI_PIN, HIGH);
LOOP_L_N(i, 8) {
for (uint8_t i = 0; i < 8; ++i) {
WRITE(SD_SCK_PIN, HIGH);
nop; // adjust so SCK is nice
@@ -225,7 +225,7 @@ void spiBegin() {
void spiSend(uint8_t data) {
// no interrupts during byte send - about 8µs
cli();
LOOP_L_N(i, 8) {
for (uint8_t i = 0; i < 8; ++i) {
WRITE(SD_SCK_PIN, LOW);
WRITE(SD_MOSI_PIN, data & 0x80);
data <<= 1;
+1 -5
View File
@@ -37,10 +37,6 @@
#include "../../core/types.h"
#include "../../core/serial_hook.h"
#ifndef SERIAL_PORT
#define SERIAL_PORT 0
#endif
#ifndef USBCON
// The presence of the UBRRH register is used to detect a UART.
@@ -280,7 +276,7 @@
static constexpr bool DROPPED_RX = false;
static constexpr bool RX_FRAMING_ERRORS = false;
static constexpr bool MAX_RX_QUEUED = false;
static constexpr bool RX_OVERRUNS = BOTH(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
static constexpr bool RX_OVERRUNS = ALL(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
};
typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialLCD;
+1 -1
View File
@@ -23,7 +23,7 @@
#include "../../inc/MarlinConfig.h"
#if EITHER(EEPROM_SETTINGS, SD_FIRMWARE_UPDATE)
#if ANY(EEPROM_SETTINGS, SD_FIRMWARE_UPDATE)
/**
* PersistentStore for Arduino-style EEPROM interface
+41 -41
View File
@@ -120,7 +120,7 @@ void pciSetup(const int8_t pin) {
void setup_endstop_interrupts() {
#define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
#if HAS_X_MAX
#if USE_X_MAX
#if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(X_MAX_PIN);
#else
@@ -128,7 +128,7 @@ void setup_endstop_interrupts() {
pciSetup(X_MAX_PIN);
#endif
#endif
#if HAS_X_MIN
#if USE_X_MIN
#if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(X_MIN_PIN);
#else
@@ -136,7 +136,7 @@ void setup_endstop_interrupts() {
pciSetup(X_MIN_PIN);
#endif
#endif
#if HAS_Y_MAX
#if USE_Y_MAX
#if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Y_MAX_PIN);
#else
@@ -144,7 +144,7 @@ void setup_endstop_interrupts() {
pciSetup(Y_MAX_PIN);
#endif
#endif
#if HAS_Y_MIN
#if USE_Y_MIN
#if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Y_MIN_PIN);
#else
@@ -152,7 +152,7 @@ void setup_endstop_interrupts() {
pciSetup(Y_MIN_PIN);
#endif
#endif
#if HAS_Z_MAX
#if USE_Z_MAX
#if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z_MAX_PIN);
#else
@@ -160,7 +160,7 @@ void setup_endstop_interrupts() {
pciSetup(Z_MAX_PIN);
#endif
#endif
#if HAS_Z_MIN
#if USE_Z_MIN
#if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z_MIN_PIN);
#else
@@ -168,97 +168,97 @@ void setup_endstop_interrupts() {
pciSetup(Z_MIN_PIN);
#endif
#endif
#if HAS_I_MAX
#if USE_I_MAX
#if (digitalPinToInterrupt(I_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(I_MAX_PIN);
#else
static_assert(digitalPinHasPCICR(I_MAX_PIN), "I_MAX_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(I_MAX_PIN), "I_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(I_MAX_PIN);
#endif
#elif HAS_I_MIN
#elif USE_I_MIN
#if (digitalPinToInterrupt(I_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(I_MIN_PIN);
#else
static_assert(digitalPinHasPCICR(I_MIN_PIN), "I_MIN_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(I_MIN_PIN), "I_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(I_MIN_PIN);
#endif
#endif
#if HAS_J_MAX
#if USE_J_MAX
#if (digitalPinToInterrupt(J_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(J_MAX_PIN);
#else
static_assert(digitalPinHasPCICR(J_MAX_PIN), "J_MAX_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(J_MAX_PIN), "J_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(J_MAX_PIN);
#endif
#elif HAS_J_MIN
#elif USE_J_MIN
#if (digitalPinToInterrupt(J_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(J_MIN_PIN);
#else
static_assert(digitalPinHasPCICR(J_MIN_PIN), "J_MIN_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(J_MIN_PIN), "J_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(J_MIN_PIN);
#endif
#endif
#if HAS_K_MAX
#if USE_K_MAX
#if (digitalPinToInterrupt(K_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(K_MAX_PIN);
#else
static_assert(digitalPinHasPCICR(K_MAX_PIN), "K_MAX_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(K_MAX_PIN), "K_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(K_MAX_PIN);
#endif
#elif HAS_K_MIN
#elif USE_K_MIN
#if (digitalPinToInterrupt(K_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(K_MIN_PIN);
#else
static_assert(digitalPinHasPCICR(K_MIN_PIN), "K_MIN_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(K_MIN_PIN), "K_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(K_MIN_PIN);
#endif
#endif
#if HAS_U_MAX
#if USE_U_MAX
#if (digitalPinToInterrupt(U_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(U_MAX_PIN);
#else
static_assert(digitalPinHasPCICR(U_MAX_PIN), "U_MAX_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(U_MAX_PIN), "U_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(U_MAX_PIN);
#endif
#elif HAS_U_MIN
#elif USE_U_MIN
#if (digitalPinToInterrupt(U_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(U_MIN_PIN);
#else
static_assert(digitalPinHasPCICR(U_MIN_PIN), "U_MIN_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(U_MIN_PIN), "U_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(U_MIN_PIN);
#endif
#endif
#if HAS_V_MAX
#if USE_V_MAX
#if (digitalPinToInterrupt(V_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(V_MAX_PIN);
#else
static_assert(digitalPinHasPCICR(V_MAX_PIN), "V_MAX_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(V_MAX_PIN), "V_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(V_MAX_PIN);
#endif
#elif HAS_V_MIN
#elif USE_V_MIN
#if (digitalPinToInterrupt(V_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(V_MIN_PIN);
#else
static_assert(digitalPinHasPCICR(V_MIN_PIN), "V_MIN_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(V_MIN_PIN), "V_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(V_MIN_PIN);
#endif
#endif
#if HAS_W_MAX
#if USE_W_MAX
#if (digitalPinToInterrupt(W_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(W_MAX_PIN);
#else
static_assert(digitalPinHasPCICR(W_MAX_PIN), "W_MAX_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(W_MAX_PIN), "W_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(W_MAX_PIN);
#endif
#elif HAS_W_MIN
#elif USE_W_MIN
#if (digitalPinToInterrupt(W_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(W_MIN_PIN);
#else
static_assert(digitalPinHasPCICR(W_MIN_PIN), "W_MIN_PIN is not interrupt-capable");
static_assert(digitalPinHasPCICR(W_MIN_PIN), "W_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
pciSetup(W_MIN_PIN);
#endif
#endif
#if HAS_X2_MAX
#if USE_X2_MAX
#if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(X2_MAX_PIN);
#else
@@ -266,7 +266,7 @@ void setup_endstop_interrupts() {
pciSetup(X2_MAX_PIN);
#endif
#endif
#if HAS_X2_MIN
#if USE_X2_MIN
#if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(X2_MIN_PIN);
#else
@@ -274,7 +274,7 @@ void setup_endstop_interrupts() {
pciSetup(X2_MIN_PIN);
#endif
#endif
#if HAS_Y2_MAX
#if USE_Y2_MAX
#if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Y2_MAX_PIN);
#else
@@ -282,7 +282,7 @@ void setup_endstop_interrupts() {
pciSetup(Y2_MAX_PIN);
#endif
#endif
#if HAS_Y2_MIN
#if USE_Y2_MIN
#if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Y2_MIN_PIN);
#else
@@ -290,7 +290,7 @@ void setup_endstop_interrupts() {
pciSetup(Y2_MIN_PIN);
#endif
#endif
#if HAS_Z2_MAX
#if USE_Z2_MAX
#if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z2_MAX_PIN);
#else
@@ -298,7 +298,7 @@ void setup_endstop_interrupts() {
pciSetup(Z2_MAX_PIN);
#endif
#endif
#if HAS_Z2_MIN
#if USE_Z2_MIN
#if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z2_MIN_PIN);
#else
@@ -306,7 +306,7 @@ void setup_endstop_interrupts() {
pciSetup(Z2_MIN_PIN);
#endif
#endif
#if HAS_Z3_MAX
#if USE_Z3_MAX
#if (digitalPinToInterrupt(Z3_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z3_MAX_PIN);
#else
@@ -314,7 +314,7 @@ void setup_endstop_interrupts() {
pciSetup(Z3_MAX_PIN);
#endif
#endif
#if HAS_Z3_MIN
#if USE_Z3_MIN
#if (digitalPinToInterrupt(Z3_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z3_MIN_PIN);
#else
@@ -322,7 +322,7 @@ void setup_endstop_interrupts() {
pciSetup(Z3_MIN_PIN);
#endif
#endif
#if HAS_Z4_MAX
#if USE_Z4_MAX
#if (digitalPinToInterrupt(Z4_MAX_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z4_MAX_PIN);
#else
@@ -330,7 +330,7 @@ void setup_endstop_interrupts() {
pciSetup(Z4_MAX_PIN);
#endif
#endif
#if HAS_Z4_MIN
#if USE_Z4_MIN
#if (digitalPinToInterrupt(Z4_MIN_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z4_MIN_PIN);
#else
@@ -338,7 +338,7 @@ void setup_endstop_interrupts() {
pciSetup(Z4_MIN_PIN);
#endif
#endif
#if HAS_Z_MIN_PROBE_PIN
#if USE_Z_MIN_PROBE
#if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
_ATTACH(Z_MIN_PROBE_PIN);
#else
+2 -2
View File
@@ -132,7 +132,7 @@ void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
DEBUG_ECHOLNPGM("f=", f);
DEBUG_ECHOLNPGM("(prescaler loop)");
LOOP_L_N(i, COUNT(prescaler)) { // Loop through all prescaler values
for (uint8_t i = 0; i < COUNT(prescaler); ++i) { // Loop through all prescaler values
const uint32_t p = prescaler[i]; // Extend to 32 bits for calculations
DEBUG_ECHOLNPGM("prescaler[", i, "]=", p);
uint16_t res_fast_temp, res_pc_temp;
@@ -232,7 +232,7 @@ void MarlinHAL::init_pwm_timers() {
#endif
};
LOOP_L_N(i, COUNT(pwm_pin))
for (uint8_t i = 0; i < COUNT(pwm_pin); ++i)
set_pwm_frequency(pwm_pin[i], 1000);
}
-78
View File
@@ -255,84 +255,6 @@ enum ClockSource2 : uint8_t {
#define SET_FOCB(T,V) SET_FOC(T,B,V)
#define SET_FOCC(T,V) SET_FOC(T,C,V)
#if 0
/**
* PWM availability macros
*/
// Determine which hardware PWMs are already in use
#define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN || P == COOLER_AUTO_FAN_PIN)
#if PIN_EXISTS(CONTROLLER_FAN)
#define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)
#else
#define PWM_CHK_FAN_B(P) _PWM_CHK_FAN_B(P)
#endif
#if ANY_PIN(FAN, FAN1, FAN2, FAN3, FAN4, FAN5, FAN6, FAN7)
#if PIN_EXISTS(FAN7)
#define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN || P == FAN6_PIN || P == FAN7_PIN)
#elif PIN_EXISTS(FAN6)
#define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN || P == FAN6_PIN)
#elif PIN_EXISTS(FAN5)
#define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN)
#elif PIN_EXISTS(FAN4)
#define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN)
#elif PIN_EXISTS(FAN3)
#define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN)
#elif PIN_EXISTS(FAN2)
#define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN)
#elif PIN_EXISTS(FAN1)
#define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN)
#else
#define PWM_CHK_FAN_A(P) (P == FAN0_PIN)
#endif
#else
#define PWM_CHK_FAN_A(P) false
#endif
#if HAS_MOTOR_CURRENT_PWM
#if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
#define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E_PIN || P == MOTOR_CURRENT_PWM_E0_PIN || P == MOTOR_CURRENT_PWM_E1_PIN || P == MOTOR_CURRENT_PWM_Z_PIN || P == MOTOR_CURRENT_PWM_XY_PIN)
#elif PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
#define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E_PIN || P == MOTOR_CURRENT_PWM_E0_PIN || P == MOTOR_CURRENT_PWM_E1_PIN || P == MOTOR_CURRENT_PWM_Z_PIN)
#else
#define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E_PIN || P == MOTOR_CURRENT_PWM_E0_PIN || P == MOTOR_CURRENT_PWM_E1_PIN)
#endif
#else
#define PWM_CHK_MOTOR_CURRENT(P) false
#endif
#ifdef NUM_SERVOS
#if AVR_ATmega2560_FAMILY
#define PWM_CHK_SERVO(P) (P == 5 || (NUM_SERVOS > 12 && P == 6) || (NUM_SERVOS > 24 && P == 46)) // PWMS 3A, 4A & 5A
#elif AVR_ATmega2561_FAMILY
#define PWM_CHK_SERVO(P) (P == 5) // PWM3A
#elif AVR_ATmega1284_FAMILY
#define PWM_CHK_SERVO(P) false
#elif AVR_AT90USB1286_FAMILY
#define PWM_CHK_SERVO(P) (P == 16) // PWM3A
#elif AVR_ATmega328_FAMILY
#define PWM_CHK_SERVO(P) false
#endif
#else
#define PWM_CHK_SERVO(P) false
#endif
#if ENABLED(BARICUDA)
#if HAS_HEATER_1 && HAS_HEATER_2
#define PWM_CHK_HEATER(P) (P == HEATER_1_PIN || P == HEATER_2_PIN)
#elif HAS_HEATER_1
#define PWM_CHK_HEATER(P) (P == HEATER_1_PIN)
#endif
#else
#define PWM_CHK_HEATER(P) false
#endif
#define PWM_CHK(P) (PWM_CHK_HEATER(P) || PWM_CHK_SERVO(P) || PWM_CHK_MOTOR_CURRENT(P) || PWM_CHK_FAN_A(P) || PWM_CHK_FAN_B(P))
#endif // PWM_CHK is not used in Marlin
// define which hardware PWMs are available for the current CPU
// all timer 1 PWMS deleted from this list because they are never available
#if AVR_ATmega2560_FAMILY
+27 -26
View File
@@ -27,43 +27,44 @@
* Hardware Pin : 02 03 06 07 01 05 15 16 17 18 23 24 25 26 64 63 13 12 46 45 44 43 78 77 76 75 74 73 72 71 60 59 58 57 56 55 54 53 50 70 52 51 42 41 40 39 38 37 36 35 22 21 20 19 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 | 04 08 09 10 11 14 27 28 29 30 31 32 33 34 47 48 49 61 62 65 66 67 68 69 79 80 81 98 99 100
* 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"
// change for your board
#define DEBUG_LED DIO21
// UART
#define RXD DIO0
#define TXD DIO1
#define RXD 0
#define TXD 1
// SPI
#define SCK DIO52
#define MISO DIO50
#define MOSI DIO51
#define SS DIO53
#define MISO 50
#define MOSI 51
#define SCK 52
#define SS 53
// TWI (I2C)
#define SCL DIO21
#define SDA DIO20
#define SCL 21
#define SDA 20
// Timers and PWM
#define OC0A DIO13
#define OC0B DIO4
#define OC1A DIO11
#define OC1B DIO12
#define OC2A DIO10
#define OC2B DIO9
#define OC3A DIO5
#define OC3B DIO2
#define OC3C DIO3
#define OC4A DIO6
#define OC4B DIO7
#define OC4C DIO8
#define OC5A DIO46
#define OC5B DIO45
#define OC5C DIO44
#define OC0A 13
#define OC0B 4
#define OC1A 11
#define OC1B 12
#define OC2A 10
#define OC2B 9
#define OC3A 5
#define OC3B 2
#define OC3C 3
#define OC4A 6
#define OC4B 7
#define OC4C 8
#define OC5A 46
#define OC5B 45
#define OC5C 44
// Digital I/O
+19 -19
View File
@@ -26,36 +26,36 @@
*
* 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"
// change for your board
#define DEBUG_LED DIO46
// UART
#define RXD DIO0
#define TXD DIO1
#define RXD 0
#define TXD 1
// SPI
#define SCK DIO10
#define MISO DIO12
#define MOSI DIO11
#define SS DIO16
#define SCK 10
#define MISO 12
#define MOSI 11
#define SS 16
// TWI (I2C)
#define SCL DIO17
#define SDA DIO18
#define SCL 17
#define SDA 18
// Timers and PWM
#define OC0A DIO9
#define OC0B DIO4
#define OC1A DIO7
#define OC1B DIO8
#define OC2A DIO6
#define OC3A DIO5
#define OC3B DIO2
#define OC3C DIO3
#define OC0A 9
#define OC0B 4
#define OC1A 7
#define OC1B 8
#define OC2A 6
#define OC3A 5
#define OC3B 2
#define OC3C 3
// Digital I/O
+15 -14
View File
@@ -26,33 +26,34 @@
*
* 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"
#define DEBUG_LED AIO5
// UART
#define RXD DIO0
#define TXD DIO1
#define RXD 0
#define TXD 1
// SPI
#define SCK DIO13
#define MISO DIO12
#define MOSI DIO11
#define SS DIO10
#define SS 10
#define MOSI 11
#define MISO 12
#define SCK 13
// TWI (I2C)
#define SCL AIO5
#define SDA AIO4
// Timers and PWM
#define OC0A DIO6
#define OC0B DIO5
#define OC1A DIO9
#define OC1B DIO10
#define OC2A DIO11
#define OC2B DIO3
#define OC0A 6
#define OC0B 5
#define OC1A 9
#define OC1B 10
#define OC2A 11
#define OC2B 3
// Digital I/O
+21 -20
View File
@@ -26,6 +26,9 @@
*
* 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
@@ -56,34 +59,32 @@
#include "../fastio.h"
#define DEBUG_LED DIO0
// UART
#define RXD DIO8
#define TXD DIO9
#define RXD0 DIO8
#define TXD0 DIO9
#define RXD 8
#define TXD 9
#define RXD0 8
#define TXD0 9
#define RXD1 DIO10
#define TXD1 DIO11
#define RXD1 10
#define TXD1 11
// SPI
#define SCK DIO7
#define MISO DIO6
#define MOSI DIO5
#define SS DIO4
#define SS 4
#define MOSI 5
#define MISO 6
#define SCK 7
// TWI (I2C)
#define SCL DIO16
#define SDA DIO17
#define SCL 16
#define SDA 17
// Timers and PWM
#define OC0A DIO3
#define OC0B DIO4
#define OC1A DIO13
#define OC1B DIO12
#define OC2A DIO15
#define OC2B DIO14
#define OC0A 3
#define OC0B 4
#define OC1A 13
#define OC1B 12
#define OC2A 15
#define OC2B 14
// Digital I/O
+7 -7
View File
@@ -27,18 +27,18 @@
* 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
*/
#include "../fastio.h"
// change for your board
#define DEBUG_LED DIO31 /* led D5 red */
// SPI
#define SCK DIO21 // 9
#define MISO DIO23 // 11
#define MOSI DIO22 // 10
#define SS DIO20 // 8
#define SS 20 // 8
#define SCK 21 // 9
#define MOSI 22 // 10
#define MISO 23 // 11
// Digital I/O
+2 -2
View File
@@ -21,6 +21,6 @@
*/
#pragma once
#if HAS_SPI_TFT || HAS_FSMC_TFT
#error "Sorry! TFT displays are not available for HAL/AVR."
#ifndef SERIAL_PORT
#define SERIAL_PORT 0
#endif
+15 -11
View File
@@ -25,17 +25,21 @@
* Test AVR-specific configuration values for errors at compile-time.
*/
#if HAS_SPI_TFT || HAS_FSMC_TFT
#error "Sorry! TFT displays are not available for HAL/AVR."
#endif
/**
* Check for common serial pin conflicts
*/
#define CHECK_SERIAL_PIN(N) ( \
X_STOP_PIN == N || Y_STOP_PIN == N || Z_STOP_PIN == N \
|| X_MIN_PIN == N || Y_MIN_PIN == N || Z_MIN_PIN == N \
|| X_MAX_PIN == N || Y_MAX_PIN == N || Z_MAX_PIN == N \
|| X_STEP_PIN == N || Y_STEP_PIN == N || Z_STEP_PIN == N \
|| X_DIR_PIN == N || Y_DIR_PIN == N || Z_DIR_PIN == N \
|| X_ENA_PIN == N || Y_ENA_PIN == N || Z_ENA_PIN == N \
|| BTN_EN1 == N || BTN_EN2 == N \
X_STOP_PIN == N || Y_STOP_PIN == N || Z_STOP_PIN == N \
|| X_MIN_PIN == N || Y_MIN_PIN == N || Z_MIN_PIN == N \
|| X_MAX_PIN == N || Y_MAX_PIN == N || Z_MAX_PIN == N \
|| X_STEP_PIN == N || Y_STEP_PIN == N || Z_STEP_PIN == N \
|| X_DIR_PIN == N || Y_DIR_PIN == N || Z_DIR_PIN == N \
|| X_ENA_PIN == N || Y_ENA_PIN == N || Z_ENA_PIN == N \
|| BTN_EN1 == N || BTN_EN2 == N || LCD_PINS_EN == N \
)
#if SERIAL_IN_USE(0)
// D0-D1. No known conflicts.
@@ -69,8 +73,8 @@
/**
* Checks for SOFT PWM
*/
#if HAS_FAN0 && FAN_PIN == 9 && DISABLED(FAN_SOFT_PWM) && ENABLED(SPEAKER)
#error "FAN_PIN 9 Hardware PWM uses Timer 2 which conflicts with Arduino AVR Tone Timer (for SPEAKER)."
#if HAS_FAN0 && FAN0_PIN == 9 && DISABLED(FAN_SOFT_PWM) && ENABLED(SPEAKER)
#error "FAN0_PIN 9 Hardware PWM uses Timer 2 which conflicts with Arduino AVR Tone Timer (for SPEAKER)."
#error "Disable SPEAKER or enable FAN_SOFT_PWM."
#endif
@@ -91,11 +95,11 @@
/**
* The Trinamic library includes SoftwareSerial.h, leading to a compile error.
*/
#if BOTH(HAS_TRINAMIC_CONFIG, ENDSTOP_INTERRUPTS_FEATURE)
#if ALL(HAS_TRINAMIC_CONFIG, ENDSTOP_INTERRUPTS_FEATURE)
#error "TMCStepper includes SoftwareSerial.h which is incompatible with ENDSTOP_INTERRUPTS_FEATURE. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
#endif
#if BOTH(HAS_TMC_SW_SERIAL, MONITOR_DRIVER_STATUS)
#if ALL(HAS_TMC_SW_SERIAL, MONITOR_DRIVER_STATUS)
#error "MONITOR_DRIVER_STATUS causes performance issues when used with SoftwareSerial-connected drivers. Disable MONITOR_DRIVER_STATUS or use hardware serial to continue."
#endif
+14 -20
View File
@@ -84,32 +84,26 @@ FORCE_INLINE static uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2
return intRes;
}
// intRes = intIn1 * intIn2 >> 8
// charRes = charIn1 * charIn2 >> 8
// uses:
// r1, r0 for the result of mul. After the second mul, r0 holds bits 0-7 of the 24 bit result and
// the top bit of r0 is used for rounding.
// [tmp] to store 0.
// [intRes] (A B) is bits 8-15 and is the returned value.
// r1, r0 for the result of mul. After the mul, r0 holds bits 0-7 of the 16 bit result,
// and the top bit of r0 is used for rounding.
// [charRes] is bits 8-15 and is the returned value.
// [charIn1] is an 8 bit parameter.
// [intIn2] (B A) is a 16 bit parameter.
// [charIn2] is an 8 bit parameter.
//
FORCE_INLINE static uint16_t MultiU8X16toH16(uint8_t charIn1, uint16_t intIn2) {
uint8_t tmp;
uint16_t intRes;
FORCE_INLINE static uint8_t MultiU8X8toH8(uint8_t charIn1, uint8_t charIn2) {
uint8_t charRes;
__asm__ __volatile__ (
A("clr %[tmp]")
A("mul %[charIn1], %B[intIn2]")
A("movw %A[intRes], r0")
A("mul %[charIn1], %A[intIn2]")
A("lsl r0")
A("adc %A[intRes], r1")
A("adc %B[intRes], %[tmp]")
A("mul %[charIn1], %[charIn2]")
A("mov %[charRes], r1")
A("clr r1")
: [intRes] "=&r" (intRes),
[tmp] "=&r" (tmp)
A("lsl r0")
A("adc %[charRes], r1")
: [charRes] "=&r" (charRes)
: [charIn1] "d" (charIn1),
[intIn2] "d" (intIn2)
[charIn2] "d" (charIn2)
: "cc"
);
return intRes;
return charRes;
}
+40 -45
View File
@@ -64,23 +64,25 @@
#define VALID_PIN(pin) (pin >= 0 && pin < NUM_DIGITAL_PINS ? 1 : 0)
#if AVR_ATmega1284_FAMILY
#define DIGITAL_PIN_TO_ANALOG_PIN(P) int(analogInputToDigitalPin(0) - (P))
#define IS_ANALOG(P) ((P) >= analogInputToDigitalPin(7) && (P) <= analogInputToDigitalPin(0))
#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)
#else
#define DIGITAL_PIN_TO_ANALOG_PIN(P) int((P) - analogInputToDigitalPin(0))
#define IS_ANALOG(P) ((P) >= analogInputToDigitalPin(0) && ((P) <= analogInputToDigitalPin(15) || (P) <= analogInputToDigitalPin(7)))
#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)
#endif
#define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].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);
LOOP_L_N(y, MAX_NAME_LENGTH) {
for (uint8_t y = 0; y < MAX_NAME_LENGTH; ++y) {
char temp_char = pgm_read_byte(name_mem_pointer + y);
if (temp_char != 0)
SERIAL_CHAR(temp_char);
else {
LOOP_L_N(i, MAX_NAME_LENGTH - y) SERIAL_CHAR(' ');
for (uint8_t i = 0; i < MAX_NAME_LENGTH - y; ++i) SERIAL_CHAR(' ');
break;
}
}
@@ -88,7 +90,6 @@ void PRINT_ARRAY_NAME(uint8_t x) {
#define GET_ARRAY_IS_DIGITAL(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
#define NUM_DIGITAL_PINS 32 // set to digital only + digital/analog
@@ -108,7 +109,7 @@ void PRINT_ARRAY_NAME(uint8_t x) {
* Print a pin's PWM status.
* Return true if it's currently a PWM pin.
*/
static bool pwm_status(uint8_t pin) {
bool pwm_status(uint8_t pin) {
char buffer[20]; // for the sprintf statements
switch (digitalPinToTimer_DEBUG(pin)) {
@@ -231,12 +232,12 @@ const volatile uint8_t* const PWM_OCR[][3] PROGMEM = {
#define OCR_VAL(T, L) pgm_read_word(&PWM_OCR[T][L])
static void err_is_counter() { SERIAL_ECHOPGM(" non-standard PWM mode"); }
static void err_is_interrupt() { SERIAL_ECHOPGM(" compare interrupt enabled"); }
static void err_prob_interrupt() { SERIAL_ECHOPGM(" overflow interrupt enabled"); }
static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin"); SERIAL_ECHO_SP(14); }
void err_is_counter() { SERIAL_ECHOPGM(" non-standard PWM mode"); }
void err_is_interrupt() { SERIAL_ECHOPGM(" compare interrupt enabled"); }
void err_prob_interrupt() { SERIAL_ECHOPGM(" overflow interrupt enabled"); }
void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin"); SERIAL_ECHO_SP(14); }
inline void com_print(const uint8_t N, const uint8_t Z) {
void com_print(const uint8_t N, const uint8_t Z) {
const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
SERIAL_ECHOPGM(" COM", AS_DIGIT(N));
SERIAL_CHAR(Z);
@@ -278,7 +279,7 @@ void timer_prefix(uint8_t T, char L, uint8_t N) { // T - timer L - pwm N -
if (TEST(*TMSK, TOIE)) err_prob_interrupt();
}
static void pwm_details(uint8_t pin) {
void pwm_details(uint8_t pin) {
switch (digitalPinToTimer_DEBUG(pin)) {
#if ABTEST(0)
@@ -352,47 +353,41 @@ static void pwm_details(uint8_t pin) {
} // pwm_details
#ifndef digitalRead_mod // Use Teensyduino's version of digitalRead - it doesn't disable the PWMs
int digitalRead_mod(const int8_t pin) { // same as digitalRead except the PWM stop section has been removed
int digitalRead_mod(const pin_t pin) { // same as digitalRead except the PWM stop section has been removed
const uint8_t port = digitalPinToPort_DEBUG(pin);
return (port != NOT_A_PIN) && (*portInputRegister(port) & digitalPinToBitMask_DEBUG(pin)) ? HIGH : LOW;
}
#endif
#ifndef PRINT_PORT
void print_port(const pin_t pin) { // print port number
#ifdef digitalPinToPort_DEBUG
uint8_t x;
SERIAL_ECHOPGM(" Port: ");
#if AVR_AT90USB1286_FAMILY
x = (pin == 46 || pin == 47) ? 'E' : digitalPinToPort_DEBUG(pin) + 64;
#else
x = digitalPinToPort_DEBUG(pin) + 64;
#endif
SERIAL_CHAR(x);
void print_port(int8_t pin) { // print port number
#ifdef digitalPinToPort_DEBUG
uint8_t x;
SERIAL_ECHOPGM(" Port: ");
#if AVR_AT90USB1286_FAMILY
x = (pin == 46 || pin == 47) ? 'E' : digitalPinToPort_DEBUG(pin) + 64;
#else
x = digitalPinToPort_DEBUG(pin) + 64;
#endif
SERIAL_CHAR(x);
#if AVR_AT90USB1286_FAMILY
if (pin == 46)
x = '2';
else if (pin == 47)
x = '3';
else {
uint8_t temp = digitalPinToBitMask_DEBUG(pin);
for (x = '0'; x < '9' && temp != 1; x++) temp >>= 1;
}
#else
#if AVR_AT90USB1286_FAMILY
if (pin == 46)
x = '2';
else if (pin == 47)
x = '3';
else {
uint8_t temp = digitalPinToBitMask_DEBUG(pin);
for (x = '0'; x < '9' && temp != 1; x++) temp >>= 1;
#endif
SERIAL_CHAR(x);
}
#else
SERIAL_ECHO_SP(10);
uint8_t temp = digitalPinToBitMask_DEBUG(pin);
for (x = '0'; x < '9' && temp != 1; x++) temp >>= 1;
#endif
}
#define PRINT_PORT(p) print_port(p)
#endif
SERIAL_CHAR(x);
#else
SERIAL_ECHO_SP(10);
#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)
+3 -6
View File
@@ -22,11 +22,10 @@
#pragma once
//
// some of the pin mapping functions of the Teensduino extension to the Arduino IDE
// do not function the same as the other Arduino extensions
// Some of the pin mapping functions of the Arduino IDE Teensduino extension
// function differently from other Arduino extensions.
//
#define TEENSYDUINO_IDE
//digitalPinToTimer(pin) function works like Arduino but Timers are not defined
@@ -48,8 +47,6 @@
#define PE 5
#define PF 6
#undef digitalPinToPort
const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
PD, // 0 - PD0 - INT0 - PWM
PD, // 1 - PD1 - INT1 - PWM
@@ -101,7 +98,7 @@ const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
PE, // 47 - PE3 (not defined in teensyduino)
};
#define digitalPinToPort(P) ( pgm_read_byte( digital_pin_to_port_PGM + (P) ) )
#define digitalPinToPort(P) pgm_read_byte(digital_pin_to_port_PGM[P])
// digitalPinToBitMask(pin) is OK
-1
View File
@@ -231,7 +231,6 @@ const uint8_t PROGMEM digital_pin_to_bit_mask_PGM_plus_70[] = {
#define digitalPinToBitMask_plus_70(P) ( pgm_read_byte( digital_pin_to_bit_mask_PGM_plus_70 + (P) ) )
const uint8_t PROGMEM digital_pin_to_timer_PGM_plus_70[] = {
// TIMERS
// ------------------------
+979
View File
@@ -0,0 +1,979 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 __AVR__
#include "../../inc/MarlinConfigPre.h"
#if ENABLED(HAL_AVR_DIRTY_INIT)
#include "registers.h"
// Since the compiler could be creating multiple copies of function code-graphs for each header inline-inclusion,
// we want to off-load the function definitions that define static memory into this solitary compilation unit.
// This way the ROM is NOT bloated (who knows if the compiler is optimizing same-content constant objects into one?)
ATmegaPinFunctions _ATmega_getPinFunctions(int pin) {
if (pin < 0) return {};
ATmegaPinInfo info = _ATmega_getPinInfo((unsigned int)pin);
#ifdef __AVR_TRM01__
if (info.port == eATmegaPort::PORT_A) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD0 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_B) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC0A, eATmegaPinFunc::TOC1C, eATmegaPinFunc::PCI7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1B, eATmegaPinFunc::PCI6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::PCI3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::PCI2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::PCI1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::PCI0 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_C) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD15 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD14 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD13 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD12 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD11 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD10 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD9 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD8 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_D) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER0_CLKI };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_CLKI };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART1_CLK };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT3, eATmegaPinFunc::USART1_TXD };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT2, eATmegaPinFunc::USART1_RXD };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::TWI_SDA };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::TWI_CLK };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_E) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT7, eATmegaPinFunc::TIMER3_ICP, eATmegaPinFunc::CLKO };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT6, eATmegaPinFunc::TIMER3_CLKI };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT5, eATmegaPinFunc::TOC3C };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT4, eATmegaPinFunc::TOC3B };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN1, eATmegaPinFunc::TOC3A };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN0, eATmegaPinFunc::USART0_CLK };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PDO, eATmegaPinFunc::USART0_TXD };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PDI, eATmegaPinFunc::USART0_RXD, eATmegaPinFunc::PCI8 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_F) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC0 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_G) {
if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC0B };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3 ) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_ALE };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_RD };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_WR };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_H) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER4_CLKI };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2B };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC4C };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC4B };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC4A };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART2_CLK };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART2_TXD };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART2_RXD };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_J) {
if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI15 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI14 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI13 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI12 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART3_CLK, eATmegaPinFunc::PCI11 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART3_TXD, eATmegaPinFunc::PCI10 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART3_RXD, eATmegaPinFunc::PCI9 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_K) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC15, eATmegaPinFunc::PCI23 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC14, eATmegaPinFunc::PCI22 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC13, eATmegaPinFunc::PCI21 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC12, eATmegaPinFunc::PCI20 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC11, eATmegaPinFunc::PCI19 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC10, eATmegaPinFunc::PCI18 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC9, eATmegaPinFunc::PCI17 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC8, eATmegaPinFunc::PCI16 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_L) {
if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC5C };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC5B };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC5A };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER5_CLKI };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER5_ICP };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER4_ICP };
return { funcs, countof(funcs) };
}
}
#elif defined(__AVR_TRM02__)
if (info.port == eATmegaPort::PORT_A) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI7, eATmegaPinFunc::ADC7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI6, eATmegaPinFunc::ADC6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI5, eATmegaPinFunc::ADC5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI4, eATmegaPinFunc::ADC4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI3, eATmegaPinFunc::ADC3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI2, eATmegaPinFunc::ADC2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI1, eATmegaPinFunc::ADC1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI0, eATmegaPinFunc::ADC0 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_B) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::TOC3B, eATmegaPinFunc::PCI15 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::TOC3A, eATmegaPinFunc::PCI14 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::TIMER3_ICP, eATmegaPinFunc::PCI13 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::TOC0B, eATmegaPinFunc::PCI12 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN1, eATmegaPinFunc::TOC0A, eATmegaPinFunc::PCI11 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN0, eATmegaPinFunc::EINT2, eATmegaPinFunc::PCI10 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ECI, eATmegaPinFunc::CLKO, eATmegaPinFunc::PCI9 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER0_ECI, eATmegaPinFunc::USART0_CLK, eATmegaPinFunc::PCI8 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_C) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC2, eATmegaPinFunc::PCI23 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC1, eATmegaPinFunc::PCI22 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI21 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI20 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI19 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI18 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI17, eATmegaPinFunc::TWI_SDA };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TWI_CLK, eATmegaPinFunc::PCI16 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_D) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI31 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP, eATmegaPinFunc::TOC2B, eATmegaPinFunc::PCI30 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI29 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1B, eATmegaPinFunc::USART1_CLK, eATmegaPinFunc::PCI28 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::USART1_TXD, eATmegaPinFunc::PCI27 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::USART1_RXD, eATmegaPinFunc::PCI26 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART0_TXD, eATmegaPinFunc::PCI25 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART0_TXD, eATmegaPinFunc::PCI24, eATmegaPinFunc::TIMER3_ECI };
return { funcs, countof(funcs) };
}
}
#elif defined(__AVR_TRM03__)
if (info.port == eATmegaPort::PORT_B) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::XTAL2, eATmegaPinFunc::TOSC2, eATmegaPinFunc::PCI7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::XTAL1, eATmegaPinFunc::TOSC1, eATmegaPinFunc::PCI6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::PCI5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::PCI4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::TOC1B, eATmegaPinFunc::PCI2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP, eATmegaPinFunc::CLKO, eATmegaPinFunc::PCI0 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_C) {
if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI14 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC5, eATmegaPinFunc::TWI_CLK, eATmegaPinFunc::PCI13 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC4, eATmegaPinFunc::TWI_SDA, eATmegaPinFunc::PCI12 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC3, eATmegaPinFunc::PCI11 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC2, eATmegaPinFunc::PCI10 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC1, eATmegaPinFunc::PCI9 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC0, eATmegaPinFunc::PCI8 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_D) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN1, eATmegaPinFunc::PCI23 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN0, eATmegaPinFunc::TOC0A, eATmegaPinFunc::PCI22 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ECI, eATmegaPinFunc::TOC0B, eATmegaPinFunc::PCI21 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART_CLK, eATmegaPinFunc::TIMER0_ECI, eATmegaPinFunc::PCI20 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::TOC2B, eATmegaPinFunc::PCI19 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::PCI18 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART_TXD, eATmegaPinFunc::PCI17 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART_RXD, eATmegaPinFunc::PCI16 };
return { funcs, countof(funcs) };
}
}
#elif defined(__AVR_TRM04__)
if (info.port == eATmegaPort::PORT_A) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD0 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_B) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC0A, eATmegaPinFunc::TOC1C, eATmegaPinFunc::PCI7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1B, eATmegaPinFunc::PCI6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PDO, eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::PCI3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PDI, eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::PCI2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::PCI1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::PCI0 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_C) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD15, eATmegaPinFunc::TIMER3_ICP, eATmegaPinFunc::CLKO };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD14, eATmegaPinFunc::TOC3A };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD13, eATmegaPinFunc::TOC3B };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD12, eATmegaPinFunc::TOC3C };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD11, eATmegaPinFunc::TIMER3_CLKI };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD10 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD9 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_AD8 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_D) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER0_CLKI };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_CLKI };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART1_CLK };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT3, eATmegaPinFunc::USART1_TXD };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT2, eATmegaPinFunc::USART1_RXD };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::TWI_SDA, eATmegaPinFunc::TOC2B };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::TWI_CLK, eATmegaPinFunc::TOC0B };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_E) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT7, eATmegaPinFunc::AIN1, eATmegaPinFunc::UVCON };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT6, eATmegaPinFunc::AIN0 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT5, eATmegaPinFunc::TOSC2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT4, eATmegaPinFunc::TOSC2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::UID };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_ALE };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_RD };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EXTMEM_WR };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_F) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC0 };
return { funcs, countof(funcs) };
}
}
#elif defined(__AVR_TRM05__)
if (info.port == eATmegaPort::PORT_A) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC7, eATmegaPinFunc::PCI7 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC6, eATmegaPinFunc::PCI6 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC5, eATmegaPinFunc::PCI5 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC4, eATmegaPinFunc::PCI4 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC3, eATmegaPinFunc::PCI3 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC2, eATmegaPinFunc::PCI2 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC1, eATmegaPinFunc::PCI1 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::ADC0, eATmegaPinFunc::PCI0 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_B) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_SCK, eATmegaPinFunc::PCI15 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MISO, eATmegaPinFunc::PCI14 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_MOSI, eATmegaPinFunc::PCI13 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::SPI_CS, eATmegaPinFunc::TOC0B, eATmegaPinFunc::PCI12 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN1, eATmegaPinFunc::TOC0A, eATmegaPinFunc::PCI11 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::AIN0, eATmegaPinFunc::EINT2, eATmegaPinFunc::PCI10 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ECI, eATmegaPinFunc::CLKO, eATmegaPinFunc::PCI9 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER0_ECI, eATmegaPinFunc::USART0_CLK, eATmegaPinFunc::PCI8 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_C) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC2, eATmegaPinFunc::PCI23 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOSC1, eATmegaPinFunc::PCI22 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI21 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI20 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI19 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::PCI18 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TWI_SDA, eATmegaPinFunc::PCI17 };
return { funcs, countof(funcs) };
}
else if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TWI_CLK, eATmegaPinFunc::PCI16 };
return { funcs, countof(funcs) };
}
}
else if (info.port == eATmegaPort::PORT_D) {
if (info.pinidx == 7) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC2A, eATmegaPinFunc::PCI31 };
return { funcs, countof(funcs) };
}
if (info.pinidx == 6) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TIMER1_ICP, eATmegaPinFunc::TOC2B, eATmegaPinFunc::PCI30 };
return { funcs, countof(funcs) };
}
if (info.pinidx == 5) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1A, eATmegaPinFunc::PCI29 };
return { funcs, countof(funcs) };
}
if (info.pinidx == 4) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::TOC1B, eATmegaPinFunc::USART1_CLK, eATmegaPinFunc::PCI28 };
return { funcs, countof(funcs) };
}
if (info.pinidx == 3) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT1, eATmegaPinFunc::USART1_TXD, eATmegaPinFunc::PCI27 };
return { funcs, countof(funcs) };
}
if (info.pinidx == 2) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::EINT0, eATmegaPinFunc::USART1_RXD, eATmegaPinFunc::PCI26 };
return { funcs, countof(funcs) };
}
if (info.pinidx == 1) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART0_TXD, eATmegaPinFunc::PCI25 };
return { funcs, countof(funcs) };
}
if (info.pinidx == 0) {
static const eATmegaPinFunc funcs[] = { eATmegaPinFunc::USART0_RXD, eATmegaPinFunc::PCI24 };
return { funcs, countof(funcs) };
}
}
#endif
return ATmegaPinFunctions(); // default and empty.
}
#endif // HAL_AVR_DIRTY_INIT
#endif // __AVR__
File diff suppressed because it is too large Load Diff
+7 -5
View File
@@ -1,7 +1,9 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
*
* 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
@@ -44,14 +46,14 @@ typedef uint16_t hal_timer_t;
#define MF_TIMER_TEMP 0
#endif
#define TEMP_TIMER_FREQUENCY ((F_CPU) / 64.0 / 256.0)
#define TEMP_TIMER_FREQUENCY (((F_CPU) + 0x2000) / 0x4000)
#define STEPPER_TIMER_RATE HAL_TIMER_RATE
#define STEPPER_TIMER_PRESCALE 8
#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // Cannot be of type double
#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000)
#define PULSE_TIMER_RATE STEPPER_TIMER_RATE // frequency of pulse timer
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_RATE STEPPER_TIMER_RATE
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() SBI(TIMSK1, OCIE1A)
+29
View File
@@ -0,0 +1,29 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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
/**
* AVR LCD-specific defines
*/
uint8_t u8g_com_HAL_AVR_sw_sp_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
#define U8G_COM_HAL_SW_SPI_FN u8g_com_HAL_AVR_sw_sp_fn
@@ -88,7 +88,7 @@ void u8g_spiSend_sw_AVR_mode_0(uint8_t val) {
volatile uint8_t *outData = u8g_outData,
*outClock = u8g_outClock;
U8G_ATOMIC_START();
LOOP_L_N(i, 8) {
for (uint8_t i = 0; i < 8; ++i) {
if (val & 0x80)
*outData |= bitData;
else
@@ -108,7 +108,7 @@ void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
volatile uint8_t *outData = u8g_outData,
*outClock = u8g_outClock;
U8G_ATOMIC_START();
LOOP_L_N(i, 8) {
for (uint8_t i = 0; i < 8; ++i) {
*outClock &= bitNotClock;
if (val & 0x80)
*outData |= bitData;
+4 -2
View File
@@ -1,7 +1,9 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
*
* 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
@@ -45,7 +47,7 @@ uint16_t MarlinHAL::adc_result;
#endif
void MarlinHAL::init() {
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
OUT_WRITE(SDSS, HIGH); // Try to set SDSS inactive before any other SPI users start up
#endif
usb_task_init(); // Initialize the USB stack
+4 -4
View File
@@ -1,9 +1,9 @@
/**
* 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
*
* 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
@@ -123,7 +123,7 @@ typedef Servo hal_servo_t;
//
// ADC
//
#define HAL_ADC_VREF 3.3
#define HAL_ADC_VREF_MV 3300
#define HAL_ADC_RESOLUTION 10
#ifndef analogInputToDigitalPin
+1 -1
View File
@@ -42,7 +42,7 @@
// Public functions
// ------------------------
#if EITHER(DUE_SOFTWARE_SPI, FORCE_SOFT_SPI)
#if ANY(DUE_SOFTWARE_SPI, FORCE_SOFT_SPI)
// ------------------------
// Software SPI
+11 -11
View File
@@ -73,18 +73,18 @@ void install_min_serial() {
}
#if DISABLED(DYNAMIC_VECTORTABLE)
extern "C" {
__attribute__((naked)) void JumpHandler_ASM() {
__asm__ __volatile__ (
"b CommonHandler_ASM\n"
);
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();
}
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
+3 -4
View File
@@ -1,10 +1,9 @@
/**
* 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
* Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
*
* 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
+3 -4
View File
@@ -1,10 +1,9 @@
/**
* 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
* Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
*
* 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
+29 -29
View File
@@ -47,33 +47,33 @@ void endstop_ISR() { endstops.update(); }
void setup_endstop_interrupts() {
#define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
TERN_(HAS_X_MAX, _ATTACH(X_MAX_PIN));
TERN_(HAS_X_MIN, _ATTACH(X_MIN_PIN));
TERN_(HAS_Y_MAX, _ATTACH(Y_MAX_PIN));
TERN_(HAS_Y_MIN, _ATTACH(Y_MIN_PIN));
TERN_(HAS_Z_MAX, _ATTACH(Z_MAX_PIN));
TERN_(HAS_Z_MIN, _ATTACH(Z_MIN_PIN));
TERN_(HAS_X2_MAX, _ATTACH(X2_MAX_PIN));
TERN_(HAS_X2_MIN, _ATTACH(X2_MIN_PIN));
TERN_(HAS_Y2_MAX, _ATTACH(Y2_MAX_PIN));
TERN_(HAS_Y2_MIN, _ATTACH(Y2_MIN_PIN));
TERN_(HAS_Z2_MAX, _ATTACH(Z2_MAX_PIN));
TERN_(HAS_Z2_MIN, _ATTACH(Z2_MIN_PIN));
TERN_(HAS_Z3_MAX, _ATTACH(Z3_MAX_PIN));
TERN_(HAS_Z3_MIN, _ATTACH(Z3_MIN_PIN));
TERN_(HAS_Z4_MAX, _ATTACH(Z4_MAX_PIN));
TERN_(HAS_Z4_MIN, _ATTACH(Z4_MIN_PIN));
TERN_(HAS_Z_MIN_PROBE_PIN, _ATTACH(Z_MIN_PROBE_PIN));
TERN_(HAS_I_MAX, _ATTACH(I_MAX_PIN));
TERN_(HAS_I_MIN, _ATTACH(I_MIN_PIN));
TERN_(HAS_J_MAX, _ATTACH(J_MAX_PIN));
TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
TERN_(USE_X_MAX, _ATTACH(X_MAX_PIN));
TERN_(USE_X_MIN, _ATTACH(X_MIN_PIN));
TERN_(USE_Y_MAX, _ATTACH(Y_MAX_PIN));
TERN_(USE_Y_MIN, _ATTACH(Y_MIN_PIN));
TERN_(USE_Z_MAX, _ATTACH(Z_MAX_PIN));
TERN_(USE_Z_MIN, _ATTACH(Z_MIN_PIN));
TERN_(USE_X2_MAX, _ATTACH(X2_MAX_PIN));
TERN_(USE_X2_MIN, _ATTACH(X2_MIN_PIN));
TERN_(USE_Y2_MAX, _ATTACH(Y2_MAX_PIN));
TERN_(USE_Y2_MIN, _ATTACH(Y2_MIN_PIN));
TERN_(USE_Z2_MAX, _ATTACH(Z2_MAX_PIN));
TERN_(USE_Z2_MIN, _ATTACH(Z2_MIN_PIN));
TERN_(USE_Z3_MAX, _ATTACH(Z3_MAX_PIN));
TERN_(USE_Z3_MIN, _ATTACH(Z3_MIN_PIN));
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_I_MAX, _ATTACH(I_MAX_PIN));
TERN_(USE_I_MIN, _ATTACH(I_MIN_PIN));
TERN_(USE_J_MAX, _ATTACH(J_MAX_PIN));
TERN_(USE_J_MIN, _ATTACH(J_MIN_PIN));
TERN_(USE_K_MAX, _ATTACH(K_MAX_PIN));
TERN_(USE_K_MIN, _ATTACH(K_MIN_PIN));
TERN_(USE_U_MAX, _ATTACH(U_MAX_PIN));
TERN_(USE_U_MIN, _ATTACH(U_MIN_PIN));
TERN_(USE_V_MAX, _ATTACH(V_MAX_PIN));
TERN_(USE_V_MIN, _ATTACH(V_MIN_PIN));
TERN_(USE_W_MAX, _ATTACH(W_MAX_PIN));
TERN_(USE_W_MIN, _ATTACH(W_MIN_PIN));
}
+4 -4
View File
@@ -189,12 +189,12 @@
*/
// UART
#define RXD DIO0
#define TXD DIO1
#define RXD 0
#define TXD 1
// TWI (I2C)
#define SCL DIO21
#define SDA DIO20
#define SCL 21
#define SDA 20
/**
* pins
+1 -1
View File
@@ -63,7 +63,7 @@ extern PWM_map ISR_table[NUM_PWMS];
extern uint32_t motor_current_setting[3];
#define IR_BIT(p) (WITHIN(p, 0, 3) ? (p) : (p) + 4)
#define COPY_ACTIVE_TABLE() do{ LOOP_L_N(i, 6) work_table[i] = active_table[i]; }while(0)
#define COPY_ACTIVE_TABLE() do{ for (uint8_t i = 0; i < 6; ++i) work_table[i] = active_table[i]; }while(0)
#define PWM_MR0 19999 // base repetition rate minus one count - 20mS
#define PWM_PR 24 // prescaler value - prescaler divide by 24 + 1 - 1 MHz output
@@ -20,7 +20,3 @@
*
*/
#pragma once
#if HAS_SPI_TFT || HAS_FSMC_TFT
#error "Sorry! TFT displays are not available for HAL/DUE."
#endif
+1 -1
View File
@@ -23,6 +23,6 @@
#if USE_FALLBACK_EEPROM
#define FLASH_EEPROM_EMULATION
#elif EITHER(I2C_EEPROM, SPI_EEPROM)
#elif ANY(I2C_EEPROM, SPI_EEPROM)
#define USE_SHARED_EEPROM 1
#endif
+7 -3
View File
@@ -25,6 +25,10 @@
* Test Arduino Due specific configuration values for errors at compile-time.
*/
#if HAS_SPI_TFT || HAS_FSMC_TFT
#error "Sorry! TFT displays are not available for HAL/DUE."
#endif
/**
* Check for common serial pin conflicts
*/
@@ -64,9 +68,9 @@
* 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_SW_##P) && (TMC_SW_##P == SD_MOSI_PIN || TMC_SW_##P == SD_MISO_PIN || TMC_SW_##P == SD_SCK_PIN))
#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 ENABLED(SDSUPPORT) && HAS_DRIVER(TMC2130)
#if HAS_MEDIA && HAS_DRIVER(TMC2130)
#if ENABLED(TMC_USE_SW_SPI)
#if DISABLED(DUE_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."
@@ -77,7 +81,7 @@
#endif
#if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_FREQUENCY
#error "Features requiring Hardware PWM (FAST_PWM_FAN, SPINDLE_LASER_FREQUENCY) are not yet supported on DUE."
#error "Features requiring Hardware PWM (FAST_PWM_FAN, SPINDLE_LASER_FREQUENCY) are not yet supported for HAL/DUE."
#endif
#if HAS_TMC_SW_SERIAL
+2 -1
View File
@@ -64,7 +64,6 @@
#define NUMBER_PINS_TOTAL PINS_COUNT
#define digitalRead_mod(p) extDigitalRead(p) // AVR digitalRead disabled PWM before it read the pin
#define 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 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)
@@ -93,6 +92,8 @@ void pwm_details(int32_t pin) {
}
}
void print_port(const pin_t) {}
/**
* DUE Board pin | PORT | Label
* ----------------+--------+-------
+3 -3
View File
@@ -1,9 +1,9 @@
/**
* 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
*
* 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
+3 -2
View File
@@ -1,8 +1,9 @@
/**
* Marlin 3D Printer Firmware
*
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
*
* 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
+34
View File
@@ -0,0 +1,34 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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
/**
* DUE (SAM3X8E) LCD-specific defines
*/
uint8_t u8g_com_HAL_DUE_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
uint8_t u8g_com_HAL_DUE_shared_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
#define U8G_COM_HAL_SW_SPI_FN u8g_com_HAL_DUE_sw_spi_fn
#define U8G_COM_HAL_HW_SPI_FN u8g_com_HAL_DUE_shared_hw_spi_fn
#define U8G_COM_ST7920_HAL_SW_SPI u8g_com_HAL_DUE_ST7920_sw_spi_fn
@@ -81,7 +81,7 @@ Pio *SCK_pPio, *MOSI_pPio;
uint32_t SCK_dwMask, MOSI_dwMask;
void u8g_spiSend_sw_DUE_mode_0(uint8_t val) { // 3MHz
LOOP_L_N(i, 8) {
for (uint8_t i = 0; i < 8; ++i) {
if (val & 0x80)
MOSI_pPio->PIO_SODR = MOSI_dwMask;
else
@@ -95,7 +95,7 @@ void u8g_spiSend_sw_DUE_mode_0(uint8_t val) { // 3MHz
}
void u8g_spiSend_sw_DUE_mode_3(uint8_t val) { // 3.5MHz
LOOP_L_N(i, 8) {
for (uint8_t i = 0; i < 8; ++i) {
SCK_pPio->PIO_CODR = SCK_dwMask;
DELAY_NS(50);
if (val & 0x80)
+29
View File
@@ -0,0 +1,29 @@
# USB Files Source Documentation
## Source
We sourced the USB files in Marlin from the Atmel ASF (Advanced Software Framework). The framework provides a variety of examples which were utilized in this project.
Atmel doesn't provide these files in a source repository but they can be extracted from ASF, which can be downloaded from Atmel.
[Advanced Software Framework](https://www.microchip.com/en-us/tools-resources/develop/libraries/advanced-software-framework)
## Modifications
The files are mostly unmodified except for minor cosmetic changes but some more significant changes were needed.
The changes that prompted the addition of this README file are listed below. Other changes may have been made prior to this.
1. Modified `uotghs_device_due.c` to resolve race conditions that could leave interrupts asserted when freezing the peripheral clock, resulting in hangs and watchdog resets due to the ensuing interrupt storm.
## Version Information
We don't know the exact version of ASF used as the source. However, the copyright information in the files indicates they are from 2015.
## Upgrade Considerations
We looked at the ASF 3.52.0 files released in 2022 but saw no immediate benefits to justify an upgrade. It's important to note that the files in Marlin don't follow the same folder structure as the files in ASF, which complicates the process of comparing and applying updated files.
When these files are updated it's important to carefully compare them to Marlin's versions so any improvements in the Marlin sources are brought forward.
It would be best to make Marlin's directory structure align with ASF or at least document the source of each file to ease future updates.
+2 -2
View File
@@ -101,7 +101,7 @@
#define USB_DEVICE_SPECIFIC_REQUEST() usb_task_other_requests()
//@}
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
/**
* USB Device low level configuration
* When only one interface is used, these configurations are defined by the class module.
@@ -185,7 +185,7 @@
//! Enable id string of interface to add an extra USB string
#define UDI_CDC_IAD_STRING_ID 4
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
/**
* USB CDC low level configuration
* In standalone these configurations are defined by the CDC module.
+125 -139
View File
@@ -74,17 +74,17 @@ extern "C" {
//@{
enum genclk_source {
GENCLK_PCK_SRC_SLCK_RC = 0, //!< Internal 32kHz RC oscillator as PCK source clock
GENCLK_PCK_SRC_SLCK_XTAL = 1, //!< External 32kHz crystal oscillator as PCK source clock
GENCLK_PCK_SRC_SLCK_BYPASS = 2, //!< External 32kHz bypass oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_4M_RC = 3, //!< Internal 4MHz RC oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_8M_RC = 4, //!< Internal 8MHz RC oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_12M_RC = 5, //!< Internal 12MHz RC oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_XTAL = 6, //!< External crystal oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_BYPASS = 7, //!< External bypass oscillator as PCK source clock
GENCLK_PCK_SRC_PLLACK = 8, //!< Use PLLACK as PCK source clock
GENCLK_PCK_SRC_PLLBCK = 9, //!< Use PLLBCK as PCK source clock
GENCLK_PCK_SRC_MCK = 10, //!< Use Master Clk as PCK source clock
GENCLK_PCK_SRC_SLCK_RC = 0, //!< Internal 32kHz RC oscillator as PCK source clock
GENCLK_PCK_SRC_SLCK_XTAL = 1, //!< External 32kHz crystal oscillator as PCK source clock
GENCLK_PCK_SRC_SLCK_BYPASS = 2, //!< External 32kHz bypass oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_4M_RC = 3, //!< Internal 4MHz RC oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_8M_RC = 4, //!< Internal 8MHz RC oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_12M_RC = 5, //!< Internal 12MHz RC oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_XTAL = 6, //!< External crystal oscillator as PCK source clock
GENCLK_PCK_SRC_MAINCK_BYPASS = 7, //!< External bypass oscillator as PCK source clock
GENCLK_PCK_SRC_PLLACK = 8, //!< Use PLLACK as PCK source clock
GENCLK_PCK_SRC_PLLBCK = 9, //!< Use PLLBCK as PCK source clock
GENCLK_PCK_SRC_MCK = 10, //!< Use Master Clk as PCK source clock
};
//@}
@@ -93,176 +93,162 @@ enum genclk_source {
//@{
enum genclk_divider {
GENCLK_PCK_PRES_1 = PMC_PCK_PRES_CLK_1, //!< Set PCK clock prescaler to 1
GENCLK_PCK_PRES_2 = PMC_PCK_PRES_CLK_2, //!< Set PCK clock prescaler to 2
GENCLK_PCK_PRES_4 = PMC_PCK_PRES_CLK_4, //!< Set PCK clock prescaler to 4
GENCLK_PCK_PRES_8 = PMC_PCK_PRES_CLK_8, //!< Set PCK clock prescaler to 8
GENCLK_PCK_PRES_16 = PMC_PCK_PRES_CLK_16, //!< Set PCK clock prescaler to 16
GENCLK_PCK_PRES_32 = PMC_PCK_PRES_CLK_32, //!< Set PCK clock prescaler to 32
GENCLK_PCK_PRES_64 = PMC_PCK_PRES_CLK_64, //!< Set PCK clock prescaler to 64
GENCLK_PCK_PRES_1 = PMC_PCK_PRES_CLK_1, //!< Set PCK clock prescaler to 1
GENCLK_PCK_PRES_2 = PMC_PCK_PRES_CLK_2, //!< Set PCK clock prescaler to 2
GENCLK_PCK_PRES_4 = PMC_PCK_PRES_CLK_4, //!< Set PCK clock prescaler to 4
GENCLK_PCK_PRES_8 = PMC_PCK_PRES_CLK_8, //!< Set PCK clock prescaler to 8
GENCLK_PCK_PRES_16 = PMC_PCK_PRES_CLK_16, //!< Set PCK clock prescaler to 16
GENCLK_PCK_PRES_32 = PMC_PCK_PRES_CLK_32, //!< Set PCK clock prescaler to 32
GENCLK_PCK_PRES_64 = PMC_PCK_PRES_CLK_64, //!< Set PCK clock prescaler to 64
};
//@}
struct genclk_config {
uint32_t ctrl;
uint32_t ctrl;
};
static inline void genclk_config_defaults(struct genclk_config *p_cfg,
uint32_t ul_id)
{
ul_id = ul_id;
p_cfg->ctrl = 0;
static inline void genclk_config_defaults(struct genclk_config *p_cfg, uint32_t ul_id) {
ul_id = ul_id;
p_cfg->ctrl = 0;
}
static inline void genclk_config_read(struct genclk_config *p_cfg,
uint32_t ul_id)
{
p_cfg->ctrl = PMC->PMC_PCK[ul_id];
static inline void genclk_config_read(struct genclk_config *p_cfg, uint32_t ul_id) {
p_cfg->ctrl = PMC->PMC_PCK[ul_id];
}
static inline void genclk_config_write(const struct genclk_config *p_cfg,
uint32_t ul_id)
{
PMC->PMC_PCK[ul_id] = p_cfg->ctrl;
static inline void genclk_config_write(const struct genclk_config *p_cfg, uint32_t ul_id) {
PMC->PMC_PCK[ul_id] = p_cfg->ctrl;
}
//! \name Programmable Clock Source and Prescaler configuration
//@{
static inline void genclk_config_set_source(struct genclk_config *p_cfg,
enum genclk_source e_src)
{
p_cfg->ctrl &= (~PMC_PCK_CSS_Msk);
static inline void genclk_config_set_source(struct genclk_config *p_cfg, enum genclk_source e_src) {
p_cfg->ctrl &= (~PMC_PCK_CSS_Msk);
switch (e_src) {
case GENCLK_PCK_SRC_SLCK_RC:
case GENCLK_PCK_SRC_SLCK_XTAL:
case GENCLK_PCK_SRC_SLCK_BYPASS:
p_cfg->ctrl |= (PMC_PCK_CSS_SLOW_CLK);
break;
switch (e_src) {
case GENCLK_PCK_SRC_SLCK_RC:
case GENCLK_PCK_SRC_SLCK_XTAL:
case GENCLK_PCK_SRC_SLCK_BYPASS:
p_cfg->ctrl |= (PMC_PCK_CSS_SLOW_CLK);
break;
case GENCLK_PCK_SRC_MAINCK_4M_RC:
case GENCLK_PCK_SRC_MAINCK_8M_RC:
case GENCLK_PCK_SRC_MAINCK_12M_RC:
case GENCLK_PCK_SRC_MAINCK_XTAL:
case GENCLK_PCK_SRC_MAINCK_BYPASS:
p_cfg->ctrl |= (PMC_PCK_CSS_MAIN_CLK);
break;
case GENCLK_PCK_SRC_MAINCK_4M_RC:
case GENCLK_PCK_SRC_MAINCK_8M_RC:
case GENCLK_PCK_SRC_MAINCK_12M_RC:
case GENCLK_PCK_SRC_MAINCK_XTAL:
case GENCLK_PCK_SRC_MAINCK_BYPASS:
p_cfg->ctrl |= (PMC_PCK_CSS_MAIN_CLK);
break;
case GENCLK_PCK_SRC_PLLACK:
p_cfg->ctrl |= (PMC_PCK_CSS_PLLA_CLK);
break;
case GENCLK_PCK_SRC_PLLACK:
p_cfg->ctrl |= (PMC_PCK_CSS_PLLA_CLK);
break;
case GENCLK_PCK_SRC_PLLBCK:
p_cfg->ctrl |= (PMC_PCK_CSS_UPLL_CLK);
break;
case GENCLK_PCK_SRC_PLLBCK:
p_cfg->ctrl |= (PMC_PCK_CSS_UPLL_CLK);
break;
case GENCLK_PCK_SRC_MCK:
p_cfg->ctrl |= (PMC_PCK_CSS_MCK);
break;
}
case GENCLK_PCK_SRC_MCK:
p_cfg->ctrl |= (PMC_PCK_CSS_MCK);
break;
}
}
static inline void genclk_config_set_divider(struct genclk_config *p_cfg,
uint32_t e_divider)
{
p_cfg->ctrl &= ~PMC_PCK_PRES_Msk;
p_cfg->ctrl |= e_divider;
static inline void genclk_config_set_divider(struct genclk_config *p_cfg, uint32_t e_divider) {
p_cfg->ctrl &= ~PMC_PCK_PRES_Msk;
p_cfg->ctrl |= e_divider;
}
//@}
static inline void genclk_enable(const struct genclk_config *p_cfg,
uint32_t ul_id)
{
PMC->PMC_PCK[ul_id] = p_cfg->ctrl;
pmc_enable_pck(ul_id);
static inline void genclk_enable(const struct genclk_config *p_cfg, uint32_t ul_id) {
PMC->PMC_PCK[ul_id] = p_cfg->ctrl;
pmc_enable_pck(ul_id);
}
static inline void genclk_disable(uint32_t ul_id)
{
pmc_disable_pck(ul_id);
static inline void genclk_disable(uint32_t ul_id) {
pmc_disable_pck(ul_id);
}
static inline void genclk_enable_source(enum genclk_source e_src)
{
switch (e_src) {
case GENCLK_PCK_SRC_SLCK_RC:
if (!osc_is_ready(OSC_SLCK_32K_RC)) {
osc_enable(OSC_SLCK_32K_RC);
osc_wait_ready(OSC_SLCK_32K_RC);
}
break;
static inline void genclk_enable_source(enum genclk_source e_src) {
switch (e_src) {
case GENCLK_PCK_SRC_SLCK_RC:
if (!osc_is_ready(OSC_SLCK_32K_RC)) {
osc_enable(OSC_SLCK_32K_RC);
osc_wait_ready(OSC_SLCK_32K_RC);
}
break;
case GENCLK_PCK_SRC_SLCK_XTAL:
if (!osc_is_ready(OSC_SLCK_32K_XTAL)) {
osc_enable(OSC_SLCK_32K_XTAL);
osc_wait_ready(OSC_SLCK_32K_XTAL);
}
break;
case GENCLK_PCK_SRC_SLCK_XTAL:
if (!osc_is_ready(OSC_SLCK_32K_XTAL)) {
osc_enable(OSC_SLCK_32K_XTAL);
osc_wait_ready(OSC_SLCK_32K_XTAL);
}
break;
case GENCLK_PCK_SRC_SLCK_BYPASS:
if (!osc_is_ready(OSC_SLCK_32K_BYPASS)) {
osc_enable(OSC_SLCK_32K_BYPASS);
osc_wait_ready(OSC_SLCK_32K_BYPASS);
}
break;
case GENCLK_PCK_SRC_SLCK_BYPASS:
if (!osc_is_ready(OSC_SLCK_32K_BYPASS)) {
osc_enable(OSC_SLCK_32K_BYPASS);
osc_wait_ready(OSC_SLCK_32K_BYPASS);
}
break;
case GENCLK_PCK_SRC_MAINCK_4M_RC:
if (!osc_is_ready(OSC_MAINCK_4M_RC)) {
osc_enable(OSC_MAINCK_4M_RC);
osc_wait_ready(OSC_MAINCK_4M_RC);
}
break;
case GENCLK_PCK_SRC_MAINCK_4M_RC:
if (!osc_is_ready(OSC_MAINCK_4M_RC)) {
osc_enable(OSC_MAINCK_4M_RC);
osc_wait_ready(OSC_MAINCK_4M_RC);
}
break;
case GENCLK_PCK_SRC_MAINCK_8M_RC:
if (!osc_is_ready(OSC_MAINCK_8M_RC)) {
osc_enable(OSC_MAINCK_8M_RC);
osc_wait_ready(OSC_MAINCK_8M_RC);
}
break;
case GENCLK_PCK_SRC_MAINCK_8M_RC:
if (!osc_is_ready(OSC_MAINCK_8M_RC)) {
osc_enable(OSC_MAINCK_8M_RC);
osc_wait_ready(OSC_MAINCK_8M_RC);
}
break;
case GENCLK_PCK_SRC_MAINCK_12M_RC:
if (!osc_is_ready(OSC_MAINCK_12M_RC)) {
osc_enable(OSC_MAINCK_12M_RC);
osc_wait_ready(OSC_MAINCK_12M_RC);
}
break;
case GENCLK_PCK_SRC_MAINCK_12M_RC:
if (!osc_is_ready(OSC_MAINCK_12M_RC)) {
osc_enable(OSC_MAINCK_12M_RC);
osc_wait_ready(OSC_MAINCK_12M_RC);
}
break;
case GENCLK_PCK_SRC_MAINCK_XTAL:
if (!osc_is_ready(OSC_MAINCK_XTAL)) {
osc_enable(OSC_MAINCK_XTAL);
osc_wait_ready(OSC_MAINCK_XTAL);
}
break;
case GENCLK_PCK_SRC_MAINCK_XTAL:
if (!osc_is_ready(OSC_MAINCK_XTAL)) {
osc_enable(OSC_MAINCK_XTAL);
osc_wait_ready(OSC_MAINCK_XTAL);
}
break;
case GENCLK_PCK_SRC_MAINCK_BYPASS:
if (!osc_is_ready(OSC_MAINCK_BYPASS)) {
osc_enable(OSC_MAINCK_BYPASS);
osc_wait_ready(OSC_MAINCK_BYPASS);
}
break;
case GENCLK_PCK_SRC_MAINCK_BYPASS:
if (!osc_is_ready(OSC_MAINCK_BYPASS)) {
osc_enable(OSC_MAINCK_BYPASS);
osc_wait_ready(OSC_MAINCK_BYPASS);
}
break;
#ifdef CONFIG_PLL0_SOURCE
case GENCLK_PCK_SRC_PLLACK:
pll_enable_config_defaults(0);
break;
#endif
#ifdef CONFIG_PLL0_SOURCE
case GENCLK_PCK_SRC_PLLACK:
pll_enable_config_defaults(0);
break;
#endif
#ifdef CONFIG_PLL1_SOURCE
case GENCLK_PCK_SRC_PLLBCK:
pll_enable_config_defaults(1);
break;
#endif
#ifdef CONFIG_PLL1_SOURCE
case GENCLK_PCK_SRC_PLLBCK:
pll_enable_config_defaults(1);
break;
#endif
case GENCLK_PCK_SRC_MCK:
break;
case GENCLK_PCK_SRC_MCK:
break;
default:
Assert(false);
break;
}
default:
Assert(false);
break;
}
}
//! @}
+97 -102
View File
@@ -62,28 +62,28 @@ extern "C" {
* should be defined by the board code, otherwise default value are used.
*/
#ifndef BOARD_FREQ_SLCK_XTAL
# warning The board slow clock xtal frequency has not been defined.
# define BOARD_FREQ_SLCK_XTAL (32768UL)
#warning The board slow clock xtal frequency has not been defined.
#define BOARD_FREQ_SLCK_XTAL (32768UL)
#endif
#ifndef BOARD_FREQ_SLCK_BYPASS
# warning The board slow clock bypass frequency has not been defined.
# define BOARD_FREQ_SLCK_BYPASS (32768UL)
#warning The board slow clock bypass frequency has not been defined.
#define BOARD_FREQ_SLCK_BYPASS (32768UL)
#endif
#ifndef BOARD_FREQ_MAINCK_XTAL
# warning The board main clock xtal frequency has not been defined.
# define BOARD_FREQ_MAINCK_XTAL (12000000UL)
#warning The board main clock xtal frequency has not been defined.
#define BOARD_FREQ_MAINCK_XTAL (12000000UL)
#endif
#ifndef BOARD_FREQ_MAINCK_BYPASS
# warning The board main clock bypass frequency has not been defined.
# define BOARD_FREQ_MAINCK_BYPASS (12000000UL)
#warning The board main clock bypass frequency has not been defined.
#define BOARD_FREQ_MAINCK_BYPASS (12000000UL)
#endif
#ifndef BOARD_OSC_STARTUP_US
# warning The board main clock xtal startup time has not been defined.
# define BOARD_OSC_STARTUP_US (15625UL)
#warning The board main clock xtal startup time has not been defined.
#define BOARD_OSC_STARTUP_US (15625UL)
#endif
/**
@@ -115,122 +115,118 @@ extern "C" {
#define OSC_MAINCK_BYPASS_HZ BOARD_FREQ_MAINCK_BYPASS //!< External bypass oscillator.
//@}
static inline void osc_enable(uint32_t ul_id)
{
switch (ul_id) {
case OSC_SLCK_32K_RC:
break;
static inline void osc_enable(uint32_t ul_id) {
switch (ul_id) {
case OSC_SLCK_32K_RC:
break;
case OSC_SLCK_32K_XTAL:
pmc_switch_sclk_to_32kxtal(PMC_OSC_XTAL);
break;
case OSC_SLCK_32K_XTAL:
pmc_switch_sclk_to_32kxtal(PMC_OSC_XTAL);
break;
case OSC_SLCK_32K_BYPASS:
pmc_switch_sclk_to_32kxtal(PMC_OSC_BYPASS);
break;
case OSC_SLCK_32K_BYPASS:
pmc_switch_sclk_to_32kxtal(PMC_OSC_BYPASS);
break;
case OSC_MAINCK_4M_RC:
pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_4_MHz);
break;
case OSC_MAINCK_4M_RC:
pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_4_MHz);
break;
case OSC_MAINCK_8M_RC:
pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_8_MHz);
break;
case OSC_MAINCK_8M_RC:
pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_8_MHz);
break;
case OSC_MAINCK_12M_RC:
pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_12_MHz);
break;
case OSC_MAINCK_12M_RC:
pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_12_MHz);
break;
case OSC_MAINCK_XTAL:
pmc_switch_mainck_to_xtal(PMC_OSC_XTAL/*,
pmc_us_to_moscxtst(BOARD_OSC_STARTUP_US,
OSC_SLCK_32K_RC_HZ)*/);
break;
case OSC_MAINCK_XTAL:
pmc_switch_mainck_to_xtal(PMC_OSC_XTAL/*,
pmc_us_to_moscxtst(BOARD_OSC_STARTUP_US,
OSC_SLCK_32K_RC_HZ)*/);
break;
case OSC_MAINCK_BYPASS:
pmc_switch_mainck_to_xtal(PMC_OSC_BYPASS/*,
pmc_us_to_moscxtst(BOARD_OSC_STARTUP_US,
OSC_SLCK_32K_RC_HZ)*/);
break;
}
case OSC_MAINCK_BYPASS:
pmc_switch_mainck_to_xtal(PMC_OSC_BYPASS/*,
pmc_us_to_moscxtst(BOARD_OSC_STARTUP_US,
OSC_SLCK_32K_RC_HZ)*/);
break;
}
}
static inline void osc_disable(uint32_t ul_id)
{
switch (ul_id) {
case OSC_SLCK_32K_RC:
case OSC_SLCK_32K_XTAL:
case OSC_SLCK_32K_BYPASS:
break;
static inline void osc_disable(uint32_t ul_id) {
switch (ul_id) {
case OSC_SLCK_32K_RC:
case OSC_SLCK_32K_XTAL:
case OSC_SLCK_32K_BYPASS:
break;
case OSC_MAINCK_4M_RC:
case OSC_MAINCK_8M_RC:
case OSC_MAINCK_12M_RC:
pmc_osc_disable_fastrc();
break;
case OSC_MAINCK_4M_RC:
case OSC_MAINCK_8M_RC:
case OSC_MAINCK_12M_RC:
pmc_osc_disable_fastrc();
break;
case OSC_MAINCK_XTAL:
pmc_osc_disable_xtal(PMC_OSC_XTAL);
break;
case OSC_MAINCK_XTAL:
pmc_osc_disable_xtal(PMC_OSC_XTAL);
break;
case OSC_MAINCK_BYPASS:
pmc_osc_disable_xtal(PMC_OSC_BYPASS);
break;
}
case OSC_MAINCK_BYPASS:
pmc_osc_disable_xtal(PMC_OSC_BYPASS);
break;
}
}
static inline bool osc_is_ready(uint32_t ul_id)
{
switch (ul_id) {
case OSC_SLCK_32K_RC:
return 1;
static inline bool osc_is_ready(uint32_t ul_id) {
switch (ul_id) {
case OSC_SLCK_32K_RC:
return 1;
case OSC_SLCK_32K_XTAL:
case OSC_SLCK_32K_BYPASS:
return pmc_osc_is_ready_32kxtal();
case OSC_SLCK_32K_XTAL:
case OSC_SLCK_32K_BYPASS:
return pmc_osc_is_ready_32kxtal();
case OSC_MAINCK_4M_RC:
case OSC_MAINCK_8M_RC:
case OSC_MAINCK_12M_RC:
case OSC_MAINCK_XTAL:
case OSC_MAINCK_BYPASS:
return pmc_osc_is_ready_mainck();
}
case OSC_MAINCK_4M_RC:
case OSC_MAINCK_8M_RC:
case OSC_MAINCK_12M_RC:
case OSC_MAINCK_XTAL:
case OSC_MAINCK_BYPASS:
return pmc_osc_is_ready_mainck();
}
return 0;
return 0;
}
static inline uint32_t osc_get_rate(uint32_t ul_id)
{
switch (ul_id) {
case OSC_SLCK_32K_RC:
return OSC_SLCK_32K_RC_HZ;
static inline uint32_t osc_get_rate(uint32_t ul_id) {
switch (ul_id) {
case OSC_SLCK_32K_RC:
return OSC_SLCK_32K_RC_HZ;
case OSC_SLCK_32K_XTAL:
return BOARD_FREQ_SLCK_XTAL;
case OSC_SLCK_32K_XTAL:
return BOARD_FREQ_SLCK_XTAL;
case OSC_SLCK_32K_BYPASS:
return BOARD_FREQ_SLCK_BYPASS;
case OSC_SLCK_32K_BYPASS:
return BOARD_FREQ_SLCK_BYPASS;
case OSC_MAINCK_4M_RC:
return OSC_MAINCK_4M_RC_HZ;
case OSC_MAINCK_4M_RC:
return OSC_MAINCK_4M_RC_HZ;
case OSC_MAINCK_8M_RC:
return OSC_MAINCK_8M_RC_HZ;
case OSC_MAINCK_8M_RC:
return OSC_MAINCK_8M_RC_HZ;
case OSC_MAINCK_12M_RC:
return OSC_MAINCK_12M_RC_HZ;
case OSC_MAINCK_12M_RC:
return OSC_MAINCK_12M_RC_HZ;
case OSC_MAINCK_XTAL:
return BOARD_FREQ_MAINCK_XTAL;
case OSC_MAINCK_XTAL:
return BOARD_FREQ_MAINCK_XTAL;
case OSC_MAINCK_BYPASS:
return BOARD_FREQ_MAINCK_BYPASS;
}
case OSC_MAINCK_BYPASS:
return BOARD_FREQ_MAINCK_BYPASS;
}
return 0;
return 0;
}
/**
@@ -241,11 +237,10 @@ static inline uint32_t osc_get_rate(uint32_t ul_id)
*
* \param id A number identifying the oscillator to wait for.
*/
static inline void osc_wait_ready(uint8_t id)
{
while (!osc_is_ready(id)) {
/* Do nothing */
}
static inline void osc_wait_ready(uint8_t id) {
while (!osc_is_ready(id)) {
/* Do nothing */
}
}
//! @}
+110 -128
View File
@@ -77,22 +77,22 @@ extern "C" {
#define PLL_COUNT 0x3FU
enum pll_source {
PLL_SRC_MAINCK_4M_RC = OSC_MAINCK_4M_RC, //!< Internal 4MHz RC oscillator.
PLL_SRC_MAINCK_8M_RC = OSC_MAINCK_8M_RC, //!< Internal 8MHz RC oscillator.
PLL_SRC_MAINCK_12M_RC = OSC_MAINCK_12M_RC, //!< Internal 12MHz RC oscillator.
PLL_SRC_MAINCK_XTAL = OSC_MAINCK_XTAL, //!< External crystal oscillator.
PLL_SRC_MAINCK_BYPASS = OSC_MAINCK_BYPASS, //!< External bypass oscillator.
PLL_NR_SOURCES, //!< Number of PLL sources.
PLL_SRC_MAINCK_4M_RC = OSC_MAINCK_4M_RC, //!< Internal 4MHz RC oscillator.
PLL_SRC_MAINCK_8M_RC = OSC_MAINCK_8M_RC, //!< Internal 8MHz RC oscillator.
PLL_SRC_MAINCK_12M_RC = OSC_MAINCK_12M_RC, //!< Internal 12MHz RC oscillator.
PLL_SRC_MAINCK_XTAL = OSC_MAINCK_XTAL, //!< External crystal oscillator.
PLL_SRC_MAINCK_BYPASS = OSC_MAINCK_BYPASS, //!< External bypass oscillator.
PLL_NR_SOURCES, //!< Number of PLL sources.
};
struct pll_config {
uint32_t ctrl;
uint32_t ctrl;
};
#define pll_get_default_rate(pll_id) \
((osc_get_rate(CONFIG_PLL##pll_id##_SOURCE) \
* CONFIG_PLL##pll_id##_MUL) \
/ CONFIG_PLL##pll_id##_DIV)
((osc_get_rate(CONFIG_PLL##pll_id##_SOURCE) \
* CONFIG_PLL##pll_id##_MUL) \
/ CONFIG_PLL##pll_id##_DIV)
/* Force UTMI PLL parameters (Hardware defined) */
#ifdef CONFIG_PLL1_SOURCE
@@ -113,145 +113,130 @@ struct pll_config {
* is hidden in this implementation. Use mul as mul effective value.
*/
static inline void pll_config_init(struct pll_config *p_cfg,
enum pll_source e_src, uint32_t ul_div, uint32_t ul_mul)
{
uint32_t vco_hz;
enum pll_source e_src, uint32_t ul_div, uint32_t ul_mul) {
uint32_t vco_hz;
Assert(e_src < PLL_NR_SOURCES);
Assert(e_src < PLL_NR_SOURCES);
if (ul_div == 0 && ul_mul == 0) { /* Must only be true for UTMI PLL */
p_cfg->ctrl = CKGR_UCKR_UPLLCOUNT(PLL_COUNT);
} else { /* PLLA */
/* Calculate internal VCO frequency */
vco_hz = osc_get_rate(e_src) / ul_div;
Assert(vco_hz >= PLL_INPUT_MIN_HZ);
Assert(vco_hz <= PLL_INPUT_MAX_HZ);
if (ul_div == 0 && ul_mul == 0) { /* Must only be true for UTMI PLL */
p_cfg->ctrl = CKGR_UCKR_UPLLCOUNT(PLL_COUNT);
}
else { /* PLLA */
/* Calculate internal VCO frequency */
vco_hz = osc_get_rate(e_src) / ul_div;
Assert(vco_hz >= PLL_INPUT_MIN_HZ);
Assert(vco_hz <= PLL_INPUT_MAX_HZ);
vco_hz *= ul_mul;
Assert(vco_hz >= PLL_OUTPUT_MIN_HZ);
Assert(vco_hz <= PLL_OUTPUT_MAX_HZ);
vco_hz *= ul_mul;
Assert(vco_hz >= PLL_OUTPUT_MIN_HZ);
Assert(vco_hz <= PLL_OUTPUT_MAX_HZ);
/* PMC hardware will automatically make it mul+1 */
p_cfg->ctrl = CKGR_PLLAR_MULA(ul_mul - 1) | CKGR_PLLAR_DIVA(ul_div) | CKGR_PLLAR_PLLACOUNT(PLL_COUNT);
}
/* PMC hardware will automatically make it mul+1 */
p_cfg->ctrl = CKGR_PLLAR_MULA(ul_mul - 1) | CKGR_PLLAR_DIVA(ul_div) | CKGR_PLLAR_PLLACOUNT(PLL_COUNT);
}
}
#define pll_config_defaults(cfg, pll_id) \
pll_config_init(cfg, \
CONFIG_PLL##pll_id##_SOURCE, \
CONFIG_PLL##pll_id##_DIV, \
CONFIG_PLL##pll_id##_MUL)
#define pll_config_defaults(cfg, pll_id) \
pll_config_init(cfg, \
CONFIG_PLL##pll_id##_SOURCE, \
CONFIG_PLL##pll_id##_DIV, \
CONFIG_PLL##pll_id##_MUL)
static inline void pll_config_read(struct pll_config *p_cfg, uint32_t ul_pll_id)
{
Assert(ul_pll_id < NR_PLLS);
if (ul_pll_id == PLLA_ID) {
p_cfg->ctrl = PMC->CKGR_PLLAR;
} else {
p_cfg->ctrl = PMC->CKGR_UCKR;
}
static inline void pll_config_read(struct pll_config *p_cfg, uint32_t ul_pll_id) {
Assert(ul_pll_id < NR_PLLS);
p_cfg->ctrl = ul_pll_id == PLLA_ID ? PMC->CKGR_PLLAR : PMC->CKGR_UCKR;
}
static inline void pll_config_write(const struct pll_config *p_cfg, uint32_t ul_pll_id)
{
Assert(ul_pll_id < NR_PLLS);
static inline void pll_config_write(const struct pll_config *p_cfg, uint32_t ul_pll_id) {
Assert(ul_pll_id < NR_PLLS);
if (ul_pll_id == PLLA_ID) {
pmc_disable_pllack(); // Always stop PLL first!
PMC->CKGR_PLLAR = CKGR_PLLAR_ONE | p_cfg->ctrl;
} else {
PMC->CKGR_UCKR = p_cfg->ctrl;
}
if (ul_pll_id == PLLA_ID) {
pmc_disable_pllack(); // Always stop PLL first!
PMC->CKGR_PLLAR = CKGR_PLLAR_ONE | p_cfg->ctrl;
}
else
PMC->CKGR_UCKR = p_cfg->ctrl;
}
static inline void pll_enable(const struct pll_config *p_cfg, uint32_t ul_pll_id)
{
Assert(ul_pll_id < NR_PLLS);
static inline void pll_enable(const struct pll_config *p_cfg, uint32_t ul_pll_id) {
Assert(ul_pll_id < NR_PLLS);
if (ul_pll_id == PLLA_ID) {
pmc_disable_pllack(); // Always stop PLL first!
PMC->CKGR_PLLAR = CKGR_PLLAR_ONE | p_cfg->ctrl;
} else {
PMC->CKGR_UCKR = p_cfg->ctrl | CKGR_UCKR_UPLLEN;
}
if (ul_pll_id == PLLA_ID) {
pmc_disable_pllack(); // Always stop PLL first!
PMC->CKGR_PLLAR = CKGR_PLLAR_ONE | p_cfg->ctrl;
}
else
PMC->CKGR_UCKR = p_cfg->ctrl | CKGR_UCKR_UPLLEN;
}
/**
* \note This will only disable the selected PLL, not the underlying oscillator (mainck).
*/
static inline void pll_disable(uint32_t ul_pll_id)
{
Assert(ul_pll_id < NR_PLLS);
static inline void pll_disable(uint32_t ul_pll_id) {
Assert(ul_pll_id < NR_PLLS);
if (ul_pll_id == PLLA_ID) {
pmc_disable_pllack();
} else {
PMC->CKGR_UCKR &= ~CKGR_UCKR_UPLLEN;
}
if (ul_pll_id == PLLA_ID)
pmc_disable_pllack();
else
PMC->CKGR_UCKR &= ~CKGR_UCKR_UPLLEN;
}
static inline uint32_t pll_is_locked(uint32_t ul_pll_id)
{
Assert(ul_pll_id < NR_PLLS);
static inline uint32_t pll_is_locked(uint32_t ul_pll_id) {
Assert(ul_pll_id < NR_PLLS);
if (ul_pll_id == PLLA_ID) {
return pmc_is_locked_pllack();
} else {
return pmc_is_locked_upll();
}
if (ul_pll_id == PLLA_ID)
return pmc_is_locked_pllack();
else
return pmc_is_locked_upll();
}
static inline void pll_enable_source(enum pll_source e_src)
{
switch (e_src) {
case PLL_SRC_MAINCK_4M_RC:
case PLL_SRC_MAINCK_8M_RC:
case PLL_SRC_MAINCK_12M_RC:
case PLL_SRC_MAINCK_XTAL:
case PLL_SRC_MAINCK_BYPASS:
osc_enable(e_src);
osc_wait_ready(e_src);
break;
static inline void pll_enable_source(enum pll_source e_src) {
switch (e_src) {
case PLL_SRC_MAINCK_4M_RC:
case PLL_SRC_MAINCK_8M_RC:
case PLL_SRC_MAINCK_12M_RC:
case PLL_SRC_MAINCK_XTAL:
case PLL_SRC_MAINCK_BYPASS:
osc_enable(e_src);
osc_wait_ready(e_src);
break;
default:
Assert(false);
break;
}
default:
Assert(false);
break;
}
}
static inline void pll_enable_config_defaults(unsigned int ul_pll_id)
{
struct pll_config pllcfg;
static inline void pll_enable_config_defaults(unsigned int ul_pll_id) {
struct pll_config pllcfg;
if (pll_is_locked(ul_pll_id)) {
return; // Pll already running
}
switch (ul_pll_id) {
#ifdef CONFIG_PLL0_SOURCE
case 0:
pll_enable_source(CONFIG_PLL0_SOURCE);
pll_config_init(&pllcfg,
CONFIG_PLL0_SOURCE,
CONFIG_PLL0_DIV,
CONFIG_PLL0_MUL);
break;
#endif
#ifdef CONFIG_PLL1_SOURCE
case 1:
pll_enable_source(CONFIG_PLL1_SOURCE);
pll_config_init(&pllcfg,
CONFIG_PLL1_SOURCE,
CONFIG_PLL1_DIV,
CONFIG_PLL1_MUL);
break;
#endif
default:
Assert(false);
break;
}
pll_enable(&pllcfg, ul_pll_id);
while (!pll_is_locked(ul_pll_id));
if (pll_is_locked(ul_pll_id)) return; // Pll already running
switch (ul_pll_id) {
#ifdef CONFIG_PLL0_SOURCE
case 0:
pll_enable_source(CONFIG_PLL0_SOURCE);
pll_config_init(&pllcfg,
CONFIG_PLL0_SOURCE,
CONFIG_PLL0_DIV,
CONFIG_PLL0_MUL);
break;
#endif
#ifdef CONFIG_PLL1_SOURCE
case 1:
pll_enable_source(CONFIG_PLL1_SOURCE);
pll_config_init(&pllcfg,
CONFIG_PLL1_SOURCE,
CONFIG_PLL1_DIV,
CONFIG_PLL1_MUL);
break;
#endif
default:
Assert(false);
break;
}
pll_enable(&pllcfg, ul_pll_id);
while (!pll_is_locked(ul_pll_id));
}
/**
@@ -264,15 +249,12 @@ static inline void pll_enable_config_defaults(unsigned int ul_pll_id)
* \retval STATUS_OK The PLL is now locked.
* \retval ERR_TIMEOUT Timed out waiting for PLL to become locked.
*/
static inline int pll_wait_for_lock(unsigned int pll_id)
{
Assert(pll_id < NR_PLLS);
static inline int pll_wait_for_lock(unsigned int pll_id) {
Assert(pll_id < NR_PLLS);
while (!pll_is_locked(pll_id)) {
/* Do nothing */
}
while (!pll_is_locked(pll_id)) { /* Do nothing */ }
return 0;
return 0;
}
//! @}
+55 -56
View File
@@ -57,7 +57,6 @@
#ifndef _SBC_PROTOCOL_H_
#define _SBC_PROTOCOL_H_
/**
* \ingroup usb_msc_protocol
* \defgroup usb_sbc_protocol SCSI Block Commands protocol definitions
@@ -81,82 +80,82 @@
//@{
enum scsi_sbc_mode {
SCSI_MS_MODE_RW_ERR_RECOV = 0x01, //!< Read-Write Error Recovery mode page
SCSI_MS_MODE_FORMAT_DEVICE = 0x03, //!< Format Device mode page
SCSI_MS_MODE_FLEXIBLE_DISK = 0x05, //!< Flexible Disk mode page
SCSI_MS_MODE_CACHING = 0x08, //!< Caching mode page
SCSI_MS_MODE_RW_ERR_RECOV = 0x01, //!< Read-Write Error Recovery mode page
SCSI_MS_MODE_FORMAT_DEVICE = 0x03, //!< Format Device mode page
SCSI_MS_MODE_FLEXIBLE_DISK = 0x05, //!< Flexible Disk mode page
SCSI_MS_MODE_CACHING = 0x08, //!< Caching mode page
};
//! \name SBC-2 Device-Specific Parameter
//@{
#define SCSI_MS_SBC_WP 0x80 //!< Write Protected
#define SCSI_MS_SBC_DPOFUA 0x10 //!< DPO and FUA supported
#define SCSI_MS_SBC_WP 0x80 //!< Write Protected
#define SCSI_MS_SBC_DPOFUA 0x10 //!< DPO and FUA supported
//@}
/**
* \brief SBC-2 Short LBA mode parameter block descriptor
*/
struct sbc_slba_block_desc {
be32_t nr_blocks; //!< Number of Blocks
be32_t block_len; //!< Block Length
#define SBC_SLBA_BLOCK_LEN_MASK 0x00FFFFFFU //!< Mask reserved bits
be32_t nr_blocks; //!< Number of Blocks
be32_t block_len; //!< Block Length
#define SBC_SLBA_BLOCK_LEN_MASK 0x00FFFFFFU //!< Mask reserved bits
};
/**
* \brief SBC-2 Caching mode page
*/
struct sbc_caching_mode_page {
uint8_t page_code;
uint8_t page_length;
uint8_t flags2;
#define SBC_MP_CACHE_IC (1 << 7) //!< Initiator Control
#define SBC_MP_CACHE_ABPF (1 << 6) //!< Abort Pre-Fetch
#define SBC_MP_CACHE_CAP (1 << 5) //!< Catching Analysis Permitted
#define SBC_MP_CACHE_DISC (1 << 4) //!< Discontinuity
#define SBC_MP_CACHE_SIZE (1 << 3) //!< Size enable
#define SBC_MP_CACHE_WCE (1 << 2) //!< Write back Cache Enable
#define SBC_MP_CACHE_MF (1 << 1) //!< Multiplication Factor
#define SBC_MP_CACHE_RCD (1 << 0) //!< Read Cache Disable
uint8_t retention;
be16_t dis_pf_transfer_len;
be16_t min_prefetch;
be16_t max_prefetch;
be16_t max_prefetch_ceil;
uint8_t flags12;
#define SBC_MP_CACHE_FSW (1 << 7) //!< Force Sequential Write
#define SBC_MP_CACHE_LBCSS (1 << 6) //!< Logical Blk Cache Seg Sz
#define SBC_MP_CACHE_DRA (1 << 5) //!< Disable Read-Ahead
#define SBC_MP_CACHE_NV_DIS (1 << 0) //!< Non-Volatile Cache Disable
uint8_t nr_cache_segments;
be16_t cache_segment_size;
uint8_t reserved[4];
uint8_t page_code;
uint8_t page_length;
uint8_t flags2;
#define SBC_MP_CACHE_IC (1 << 7) //!< Initiator Control
#define SBC_MP_CACHE_ABPF (1 << 6) //!< Abort Pre-Fetch
#define SBC_MP_CACHE_CAP (1 << 5) //!< Catching Analysis Permitted
#define SBC_MP_CACHE_DISC (1 << 4) //!< Discontinuity
#define SBC_MP_CACHE_SIZE (1 << 3) //!< Size enable
#define SBC_MP_CACHE_WCE (1 << 2) //!< Write back Cache Enable
#define SBC_MP_CACHE_MF (1 << 1) //!< Multiplication Factor
#define SBC_MP_CACHE_RCD (1 << 0) //!< Read Cache Disable
uint8_t retention;
be16_t dis_pf_transfer_len;
be16_t min_prefetch;
be16_t max_prefetch;
be16_t max_prefetch_ceil;
uint8_t flags12;
#define SBC_MP_CACHE_FSW (1 << 7) //!< Force Sequential Write
#define SBC_MP_CACHE_LBCSS (1 << 6) //!< Logical Blk Cache Seg Sz
#define SBC_MP_CACHE_DRA (1 << 5) //!< Disable Read-Ahead
#define SBC_MP_CACHE_NV_DIS (1 << 0) //!< Non-Volatile Cache Disable
uint8_t nr_cache_segments;
be16_t cache_segment_size;
uint8_t reserved[4];
};
/**
* \brief SBC-2 Read-Write Error Recovery mode page
*/
struct sbc_rdwr_error_recovery_mode_page {
uint8_t page_code;
uint8_t page_length;
#define SPC_MP_RW_ERR_RECOV_PAGE_LENGTH 0x0A
uint8_t flags1;
#define SBC_MP_RW_ERR_RECOV_AWRE (1 << 7)
#define SBC_MP_RW_ERR_RECOV_ARRE (1 << 6)
#define SBC_MP_RW_ERR_RECOV_TB (1 << 5)
#define SBC_MP_RW_ERR_RECOV_RC (1 << 4)
#define SBC_MP_RW_ERR_RECOV_ERR (1 << 3)
#define SBC_MP_RW_ERR_RECOV_PER (1 << 2)
#define SBC_MP_RW_ERR_RECOV_DTE (1 << 1)
#define SBC_MP_RW_ERR_RECOV_DCR (1 << 0)
uint8_t read_retry_count;
uint8_t correction_span;
uint8_t head_offset_count;
uint8_t data_strobe_offset_count;
uint8_t flags2;
uint8_t write_retry_count;
uint8_t flags3;
be16_t recovery_time_limit;
uint8_t page_code;
uint8_t page_length;
#define SPC_MP_RW_ERR_RECOV_PAGE_LENGTH 0x0A
uint8_t flags1;
#define SBC_MP_RW_ERR_RECOV_AWRE (1 << 7)
#define SBC_MP_RW_ERR_RECOV_ARRE (1 << 6)
#define SBC_MP_RW_ERR_RECOV_TB (1 << 5)
#define SBC_MP_RW_ERR_RECOV_RC (1 << 4)
#define SBC_MP_RW_ERR_RECOV_ERR (1 << 3)
#define SBC_MP_RW_ERR_RECOV_PER (1 << 2)
#define SBC_MP_RW_ERR_RECOV_DTE (1 << 1)
#define SBC_MP_RW_ERR_RECOV_DCR (1 << 0)
uint8_t read_retry_count;
uint8_t correction_span;
uint8_t head_offset_count;
uint8_t data_strobe_offset_count;
uint8_t flags2;
uint8_t write_retry_count;
uint8_t flags3;
be16_t recovery_time_limit;
};
//@}
@@ -164,8 +163,8 @@ struct sbc_rdwr_error_recovery_mode_page {
* \brief SBC-2 READ CAPACITY (10) parameter data
*/
struct sbc_read_capacity10_data {
be32_t max_lba; //!< LBA of last logical block
be32_t block_len; //!< Number of bytes in the last logical block
be32_t max_lba; //!< LBA of last logical block
be32_t block_len; //!< Number of bytes in the last logical block
};
//@}
+2 -2
View File
@@ -6,7 +6,7 @@
#include "../../../inc/MarlinConfig.h"
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
#include "../../../sd/cardreader.h"
extern "C" {
@@ -138,5 +138,5 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
#endif // ACCESS_USB == true
#endif // SDSUPPORT
#endif // HAS_MEDIA
#endif // ARDUINO_ARCH_SAM
+166 -173
View File
@@ -59,23 +59,23 @@
//! \name SCSI commands defined by SPC-2
//@{
#define SPC_TEST_UNIT_READY 0x00
#define SPC_REQUEST_SENSE 0x03
#define SPC_INQUIRY 0x12
#define SPC_MODE_SELECT6 0x15
#define SPC_MODE_SENSE6 0x1A
#define SPC_SEND_DIAGNOSTIC 0x1D
#define SPC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1E
#define SPC_MODE_SENSE10 0x5A
#define SPC_REPORT_LUNS 0xA0
#define SPC_TEST_UNIT_READY 0x00
#define SPC_REQUEST_SENSE 0x03
#define SPC_INQUIRY 0x12
#define SPC_MODE_SELECT6 0x15
#define SPC_MODE_SENSE6 0x1A
#define SPC_SEND_DIAGNOSTIC 0x1D
#define SPC_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1E
#define SPC_MODE_SENSE10 0x5A
#define SPC_REPORT_LUNS 0xA0
//@}
//! \brief May be set in byte 0 of the INQUIRY CDB
//@{
//! Enable Vital Product Data
#define SCSI_INQ_REQ_EVPD 0x01
#define SCSI_INQ_REQ_EVPD 0x01
//! Command Support Data specified by the PAGE OR OPERATION CODE field
#define SCSI_INQ_REQ_CMDT 0x02
#define SCSI_INQ_REQ_CMDT 0x02
//@}
COMPILER_PACK_SET(1)
@@ -84,110 +84,110 @@ COMPILER_PACK_SET(1)
* \brief SCSI Standard Inquiry data structure
*/
struct scsi_inquiry_data {
uint8_t pq_pdt; //!< Peripheral Qual / Peripheral Dev Type
#define SCSI_INQ_PQ_CONNECTED 0x00 //!< Peripheral connected
#define SCSI_INQ_PQ_NOT_CONN 0x20 //!< Peripheral not connected
#define SCSI_INQ_PQ_NOT_SUPP 0x60 //!< Peripheral not supported
#define SCSI_INQ_DT_DIR_ACCESS 0x00 //!< Direct Access (SBC)
#define SCSI_INQ_DT_SEQ_ACCESS 0x01 //!< Sequential Access
#define SCSI_INQ_DT_PRINTER 0x02 //!< Printer
#define SCSI_INQ_DT_PROCESSOR 0x03 //!< Processor device
#define SCSI_INQ_DT_WRITE_ONCE 0x04 //!< Write-once device
#define SCSI_INQ_DT_CD_DVD 0x05 //!< CD/DVD device
#define SCSI_INQ_DT_OPTICAL 0x07 //!< Optical Memory
#define SCSI_INQ_DT_MC 0x08 //!< Medium Changer
#define SCSI_INQ_DT_ARRAY 0x0C //!< Storage Array Controller
#define SCSI_INQ_DT_ENCLOSURE 0x0D //!< Enclosure Services
#define SCSI_INQ_DT_RBC 0x0E //!< Simplified Direct Access
#define SCSI_INQ_DT_OCRW 0x0F //!< Optical card reader/writer
#define SCSI_INQ_DT_BCC 0x10 //!< Bridge Controller Commands
#define SCSI_INQ_DT_OSD 0x11 //!< Object-based Storage
#define SCSI_INQ_DT_NONE 0x1F //!< No Peripheral
uint8_t flags1; //!< Flags (byte 1)
#define SCSI_INQ_RMB 0x80 //!< Removable Medium
uint8_t version; //!< Version
#define SCSI_INQ_VER_NONE 0x00 //!< No standards conformance
#define SCSI_INQ_VER_SPC 0x03 //!< SCSI Primary Commands (link to SBC)
#define SCSI_INQ_VER_SPC2 0x04 //!< SCSI Primary Commands - 2 (link to SBC-2)
#define SCSI_INQ_VER_SPC3 0x05 //!< SCSI Primary Commands - 3 (link to SBC-2)
#define SCSI_INQ_VER_SPC4 0x06 //!< SCSI Primary Commands - 4 (link to SBC-3)
uint8_t flags3; //!< Flags (byte 3)
#define SCSI_INQ_NORMACA 0x20 //!< Normal ACA Supported
#define SCSI_INQ_HISUP 0x10 //!< Hierarchal LUN addressing
#define SCSI_INQ_RSP_SPC2 0x02 //!< SPC-2 / SPC-3 response format
uint8_t addl_len; //!< Additional Length (n-4)
#define SCSI_INQ_ADDL_LEN(tot) ((tot)-5) //!< Total length is \a tot
uint8_t flags5; //!< Flags (byte 5)
#define SCSI_INQ_SCCS 0x80
uint8_t flags6; //!< Flags (byte 6)
#define SCSI_INQ_BQUE 0x80
#define SCSI_INQ_ENCSERV 0x40
#define SCSI_INQ_MULTIP 0x10
#define SCSI_INQ_MCHGR 0x08
#define SCSI_INQ_ADDR16 0x01
uint8_t flags7; //!< Flags (byte 7)
#define SCSI_INQ_WBUS16 0x20
#define SCSI_INQ_SYNC 0x10
#define SCSI_INQ_LINKED 0x08
#define SCSI_INQ_CMDQUE 0x02
uint8_t vendor_id[8]; //!< T10 Vendor Identification
uint8_t product_id[16]; //!< Product Identification
uint8_t product_rev[4]; //!< Product Revision Level
uint8_t pq_pdt; //!< Peripheral Qual / Peripheral Dev Type
#define SCSI_INQ_PQ_CONNECTED 0x00 //!< Peripheral connected
#define SCSI_INQ_PQ_NOT_CONN 0x20 //!< Peripheral not connected
#define SCSI_INQ_PQ_NOT_SUPP 0x60 //!< Peripheral not supported
#define SCSI_INQ_DT_DIR_ACCESS 0x00 //!< Direct Access (SBC)
#define SCSI_INQ_DT_SEQ_ACCESS 0x01 //!< Sequential Access
#define SCSI_INQ_DT_PRINTER 0x02 //!< Printer
#define SCSI_INQ_DT_PROCESSOR 0x03 //!< Processor device
#define SCSI_INQ_DT_WRITE_ONCE 0x04 //!< Write-once device
#define SCSI_INQ_DT_CD_DVD 0x05 //!< CD/DVD device
#define SCSI_INQ_DT_OPTICAL 0x07 //!< Optical Memory
#define SCSI_INQ_DT_MC 0x08 //!< Medium Changer
#define SCSI_INQ_DT_ARRAY 0x0C //!< Storage Array Controller
#define SCSI_INQ_DT_ENCLOSURE 0x0D //!< Enclosure Services
#define SCSI_INQ_DT_RBC 0x0E //!< Simplified Direct Access
#define SCSI_INQ_DT_OCRW 0x0F //!< Optical card reader/writer
#define SCSI_INQ_DT_BCC 0x10 //!< Bridge Controller Commands
#define SCSI_INQ_DT_OSD 0x11 //!< Object-based Storage
#define SCSI_INQ_DT_NONE 0x1F //!< No Peripheral
uint8_t flags1; //!< Flags (byte 1)
#define SCSI_INQ_RMB 0x80 //!< Removable Medium
uint8_t version; //!< Version
#define SCSI_INQ_VER_NONE 0x00 //!< No standards conformance
#define SCSI_INQ_VER_SPC 0x03 //!< SCSI Primary Commands (link to SBC)
#define SCSI_INQ_VER_SPC2 0x04 //!< SCSI Primary Commands - 2 (link to SBC-2)
#define SCSI_INQ_VER_SPC3 0x05 //!< SCSI Primary Commands - 3 (link to SBC-2)
#define SCSI_INQ_VER_SPC4 0x06 //!< SCSI Primary Commands - 4 (link to SBC-3)
uint8_t flags3; //!< Flags (byte 3)
#define SCSI_INQ_NORMACA 0x20 //!< Normal ACA Supported
#define SCSI_INQ_HISUP 0x10 //!< Hierarchal LUN addressing
#define SCSI_INQ_RSP_SPC2 0x02 //!< SPC-2 / SPC-3 response format
uint8_t addl_len; //!< Additional Length (n-4)
#define SCSI_INQ_ADDL_LEN(tot) ((tot)-5) //!< Total length is \a tot
uint8_t flags5; //!< Flags (byte 5)
#define SCSI_INQ_SCCS 0x80
uint8_t flags6; //!< Flags (byte 6)
#define SCSI_INQ_BQUE 0x80
#define SCSI_INQ_ENCSERV 0x40
#define SCSI_INQ_MULTIP 0x10
#define SCSI_INQ_MCHGR 0x08
#define SCSI_INQ_ADDR16 0x01
uint8_t flags7; //!< Flags (byte 7)
#define SCSI_INQ_WBUS16 0x20
#define SCSI_INQ_SYNC 0x10
#define SCSI_INQ_LINKED 0x08
#define SCSI_INQ_CMDQUE 0x02
uint8_t vendor_id[8]; //!< T10 Vendor Identification
uint8_t product_id[16]; //!< Product Identification
uint8_t product_rev[4]; //!< Product Revision Level
};
/**
* \brief SCSI Standard Request sense data structure
*/
struct scsi_request_sense_data {
/* 1st byte: REQUEST SENSE response flags*/
uint8_t valid_reponse_code;
#define SCSI_SENSE_VALID 0x80 //!< Indicates the INFORMATION field contains valid information
#define SCSI_SENSE_RESPONSE_CODE_MASK 0x7F
#define SCSI_SENSE_CURRENT 0x70 //!< Response code 70h (current errors)
#define SCSI_SENSE_DEFERRED 0x71
/* 1st byte: REQUEST SENSE response flags*/
uint8_t valid_reponse_code;
#define SCSI_SENSE_VALID 0x80 //!< Indicates the INFORMATION field contains valid information
#define SCSI_SENSE_RESPONSE_CODE_MASK 0x7F
#define SCSI_SENSE_CURRENT 0x70 //!< Response code 70h (current errors)
#define SCSI_SENSE_DEFERRED 0x71
/* 2nd byte */
uint8_t obsolete;
/* 2nd byte */
uint8_t obsolete;
/* 3rd byte */
uint8_t sense_flag_key;
#define SCSI_SENSE_FILEMARK 0x80 //!< Indicates that the current command has read a filemark or setmark.
#define SCSI_SENSE_EOM 0x40 //!< Indicates that an end-of-medium condition exists.
#define SCSI_SENSE_ILI 0x20 //!< Indicates that the requested logical block length did not match the logical block length of the data on the medium.
#define SCSI_SENSE_RESERVED 0x10 //!< Reserved
#define SCSI_SENSE_KEY(x) (x&0x0F) //!< Sense Key
/* 3rd byte */
uint8_t sense_flag_key;
#define SCSI_SENSE_FILEMARK 0x80 //!< Indicates that the current command has read a filemark or setmark.
#define SCSI_SENSE_EOM 0x40 //!< Indicates that an end-of-medium condition exists.
#define SCSI_SENSE_ILI 0x20 //!< Indicates that the requested logical block length did not match the logical block length of the data on the medium.
#define SCSI_SENSE_RESERVED 0x10 //!< Reserved
#define SCSI_SENSE_KEY(x) (x&0x0F) //!< Sense Key
/* 4th to 7th bytes - INFORMATION field */
uint8_t information[4];
/* 4th to 7th bytes - INFORMATION field */
uint8_t information[4];
/* 8th byte - ADDITIONAL SENSE LENGTH field */
uint8_t AddSenseLen;
#define SCSI_SENSE_ADDL_LEN(total_len) ((total_len) - 8)
/* 8th byte - ADDITIONAL SENSE LENGTH field */
uint8_t AddSenseLen;
#define SCSI_SENSE_ADDL_LEN(total_len) ((total_len) - 8)
/* 9th to 12th byte - COMMAND-SPECIFIC INFORMATION field */
uint8_t CmdSpecINFO[4];
/* 9th to 12th byte - COMMAND-SPECIFIC INFORMATION field */
uint8_t CmdSpecINFO[4];
/* 13th byte - ADDITIONAL SENSE CODE field */
uint8_t AddSenseCode;
/* 13th byte - ADDITIONAL SENSE CODE field */
uint8_t AddSenseCode;
/* 14th byte - ADDITIONAL SENSE CODE QUALIFIER field */
uint8_t AddSnsCodeQlfr;
/* 14th byte - ADDITIONAL SENSE CODE QUALIFIER field */
uint8_t AddSnsCodeQlfr;
/* 15th byte - FIELD REPLACEABLE UNIT CODE field */
uint8_t FldReplUnitCode;
/* 15th byte - FIELD REPLACEABLE UNIT CODE field */
uint8_t FldReplUnitCode;
/* 16th byte */
uint8_t SenseKeySpec[3];
#define SCSI_SENSE_SKSV 0x80 //!< Indicates the SENSE-KEY SPECIFIC field contains valid information
/* 16th byte */
uint8_t SenseKeySpec[3];
#define SCSI_SENSE_SKSV 0x80 //!< Indicates the SENSE-KEY SPECIFIC field contains valid information
};
COMPILER_PACK_RESET()
/* Vital Product Data page codes */
enum scsi_vpd_page_code {
SCSI_VPD_SUPPORTED_PAGES = 0x00,
SCSI_VPD_UNIT_SERIAL_NUMBER = 0x80,
SCSI_VPD_DEVICE_IDENTIFICATION = 0x83,
SCSI_VPD_SUPPORTED_PAGES = 0x00,
SCSI_VPD_UNIT_SERIAL_NUMBER = 0x80,
SCSI_VPD_DEVICE_IDENTIFICATION = 0x83,
};
#define SCSI_VPD_HEADER_SIZE 4
@@ -200,37 +200,36 @@ enum scsi_vpd_page_code {
#define SCSI_VPD_ID_TYPE_T10 1
/* Sense keys */
enum scsi_sense_key {
SCSI_SK_NO_SENSE = 0x0,
SCSI_SK_RECOVERED_ERROR = 0x1,
SCSI_SK_NOT_READY = 0x2,
SCSI_SK_MEDIUM_ERROR = 0x3,
SCSI_SK_HARDWARE_ERROR = 0x4,
SCSI_SK_ILLEGAL_REQUEST = 0x5,
SCSI_SK_UNIT_ATTENTION = 0x6,
SCSI_SK_DATA_PROTECT = 0x7,
SCSI_SK_BLANK_CHECK = 0x8,
SCSI_SK_VENDOR_SPECIFIC = 0x9,
SCSI_SK_COPY_ABORTED = 0xA,
SCSI_SK_ABORTED_COMMAND = 0xB,
SCSI_SK_VOLUME_OVERFLOW = 0xD,
SCSI_SK_MISCOMPARE = 0xE,
SCSI_SK_NO_SENSE = 0x0,
SCSI_SK_RECOVERED_ERROR = 0x1,
SCSI_SK_NOT_READY = 0x2,
SCSI_SK_MEDIUM_ERROR = 0x3,
SCSI_SK_HARDWARE_ERROR = 0x4,
SCSI_SK_ILLEGAL_REQUEST = 0x5,
SCSI_SK_UNIT_ATTENTION = 0x6,
SCSI_SK_DATA_PROTECT = 0x7,
SCSI_SK_BLANK_CHECK = 0x8,
SCSI_SK_VENDOR_SPECIFIC = 0x9,
SCSI_SK_COPY_ABORTED = 0xA,
SCSI_SK_ABORTED_COMMAND = 0xB,
SCSI_SK_VOLUME_OVERFLOW = 0xD,
SCSI_SK_MISCOMPARE = 0xE,
};
/* Additional Sense Code / Additional Sense Code Qualifier pairs */
enum scsi_asc_ascq {
SCSI_ASC_NO_ADDITIONAL_SENSE_INFO = 0x0000,
SCSI_ASC_LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405,
SCSI_ASC_WRITE_ERROR = 0x0C00,
SCSI_ASC_UNRECOVERED_READ_ERROR = 0x1100,
SCSI_ASC_INVALID_COMMAND_OPERATION_CODE = 0x2000,
SCSI_ASC_INVALID_FIELD_IN_CDB = 0x2400,
SCSI_ASC_WRITE_PROTECTED = 0x2700,
SCSI_ASC_NOT_READY_TO_READY_CHANGE = 0x2800,
SCSI_ASC_MEDIUM_NOT_PRESENT = 0x3A00,
SCSI_ASC_INTERNAL_TARGET_FAILURE = 0x4400,
SCSI_ASC_NO_ADDITIONAL_SENSE_INFO = 0x0000,
SCSI_ASC_LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405,
SCSI_ASC_WRITE_ERROR = 0x0C00,
SCSI_ASC_UNRECOVERED_READ_ERROR = 0x1100,
SCSI_ASC_INVALID_COMMAND_OPERATION_CODE = 0x2000,
SCSI_ASC_INVALID_FIELD_IN_CDB = 0x2400,
SCSI_ASC_WRITE_PROTECTED = 0x2700,
SCSI_ASC_NOT_READY_TO_READY_CHANGE = 0x2800,
SCSI_ASC_MEDIUM_NOT_PRESENT = 0x3A00,
SCSI_ASC_INTERNAL_TARGET_FAILURE = 0x4400,
};
/**
@@ -240,9 +239,9 @@ enum scsi_asc_ascq {
* that are applicable to all SCSI devices.
*/
enum scsi_spc_mode {
SCSI_MS_MODE_VENDOR_SPEC = 0x00,
SCSI_MS_MODE_INFEXP = 0x1C, // Informational exceptions control page
SCSI_MS_MODE_ALL = 0x3F,
SCSI_MS_MODE_VENDOR_SPEC = 0x00,
SCSI_MS_MODE_INFEXP = 0x1C, // Informational exceptions control page
SCSI_MS_MODE_ALL = 0x3F,
};
/**
@@ -250,51 +249,45 @@ enum scsi_spc_mode {
* See chapter 8.3.8
*/
struct spc_control_page_info_execpt {
uint8_t page_code;
uint8_t page_length;
#define SPC_MP_INFEXP_PAGE_LENGTH 0x0A
uint8_t flags1;
#define SPC_MP_INFEXP_PERF (1<<7) //!< Initiator Control
#define SPC_MP_INFEXP_EBF (1<<5) //!< Caching Analysis Permitted
#define SPC_MP_INFEXP_EWASC (1<<4) //!< Discontinuity
#define SPC_MP_INFEXP_DEXCPT (1<<3) //!< Size enable
#define SPC_MP_INFEXP_TEST (1<<2) //!< Writeback Cache Enable
#define SPC_MP_INFEXP_LOGERR (1<<0) //!< Log errors bit
uint8_t mrie;
#define SPC_MP_INFEXP_MRIE_NO_REPORT 0x00
#define SPC_MP_INFEXP_MRIE_ASYNC_EVENT 0x01
#define SPC_MP_INFEXP_MRIE_GEN_UNIT 0x02
#define SPC_MP_INFEXP_MRIE_COND_RECOV_ERROR 0x03
#define SPC_MP_INFEXP_MRIE_UNCOND_RECOV_ERROR 0x04
#define SPC_MP_INFEXP_MRIE_NO_SENSE 0x05
#define SPC_MP_INFEXP_MRIE_ONLY_REPORT 0x06
be32_t interval_timer;
be32_t report_count;
uint8_t page_code;
uint8_t page_length;
#define SPC_MP_INFEXP_PAGE_LENGTH 0x0A
uint8_t flags1;
#define SPC_MP_INFEXP_PERF (1<<7) //!< Initiator Control
#define SPC_MP_INFEXP_EBF (1<<5) //!< Caching Analysis Permitted
#define SPC_MP_INFEXP_EWASC (1<<4) //!< Discontinuity
#define SPC_MP_INFEXP_DEXCPT (1<<3) //!< Size enable
#define SPC_MP_INFEXP_TEST (1<<2) //!< Writeback Cache Enable
#define SPC_MP_INFEXP_LOGERR (1<<0) //!< Log errors bit
uint8_t mrie;
#define SPC_MP_INFEXP_MRIE_NO_REPORT 0x00
#define SPC_MP_INFEXP_MRIE_ASYNC_EVENT 0x01
#define SPC_MP_INFEXP_MRIE_GEN_UNIT 0x02
#define SPC_MP_INFEXP_MRIE_COND_RECOV_ERROR 0x03
#define SPC_MP_INFEXP_MRIE_UNCOND_RECOV_ERROR 0x04
#define SPC_MP_INFEXP_MRIE_NO_SENSE 0x05
#define SPC_MP_INFEXP_MRIE_ONLY_REPORT 0x06
be32_t interval_timer;
be32_t report_count;
};
enum scsi_spc_mode_sense_pc {
SCSI_MS_SENSE_PC_CURRENT = 0,
SCSI_MS_SENSE_PC_CHANGEABLE = 1,
SCSI_MS_SENSE_PC_DEFAULT = 2,
SCSI_MS_SENSE_PC_SAVED = 3,
SCSI_MS_SENSE_PC_CURRENT = 0,
SCSI_MS_SENSE_PC_CHANGEABLE = 1,
SCSI_MS_SENSE_PC_DEFAULT = 2,
SCSI_MS_SENSE_PC_SAVED = 3,
};
static inline bool scsi_mode_sense_dbd_is_set(const uint8_t * cdb)
{
return (cdb[1] >> 3) & 1;
static inline bool scsi_mode_sense_dbd_is_set(const uint8_t * cdb) {
return (cdb[1] >> 3) & 1;
}
static inline uint8_t scsi_mode_sense_get_page_code(const uint8_t * cdb)
{
return cdb[2] & 0x3F;
static inline uint8_t scsi_mode_sense_get_page_code(const uint8_t * cdb) {
return cdb[2] & 0x3F;
}
static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb)
{
return cdb[2] >> 6;
static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb) {
return cdb[2] >> 6;
}
/**
@@ -302,10 +295,10 @@ static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb)
* SENSE(6)
*/
struct scsi_mode_param_header6 {
uint8_t mode_data_length; //!< Number of bytes after this
uint8_t medium_type; //!< Medium Type
uint8_t device_specific_parameter; //!< Defined by command set
uint8_t block_descriptor_length; //!< Length of block descriptors
uint8_t mode_data_length; //!< Number of bytes after this
uint8_t medium_type; //!< Medium Type
uint8_t device_specific_parameter; //!< Defined by command set
uint8_t block_descriptor_length; //!< Length of block descriptors
};
/**
@@ -313,23 +306,23 @@ struct scsi_mode_param_header6 {
* SENSE(10)
*/
struct scsi_mode_param_header10 {
be16_t mode_data_length; //!< Number of bytes after this
uint8_t medium_type; //!< Medium Type
uint8_t device_specific_parameter; //!< Defined by command set
uint8_t flags4; //!< LONGLBA in bit 0
uint8_t reserved;
be16_t block_descriptor_length; //!< Length of block descriptors
be16_t mode_data_length; //!< Number of bytes after this
uint8_t medium_type; //!< Medium Type
uint8_t device_specific_parameter; //!< Defined by command set
uint8_t flags4; //!< LONGLBA in bit 0
uint8_t reserved;
be16_t block_descriptor_length; //!< Length of block descriptors
};
/**
* \brief SCSI Page_0 Mode Page header (SPF not set)
*/
struct scsi_mode_page_0_header {
uint8_t page_code;
#define SCSI_PAGE_CODE_PS (1 << 7) //!< Parameters Saveable
#define SCSI_PAGE_CODE_SPF (1 << 6) //!< SubPage Format
uint8_t page_length; //!< Number of bytes after this
#define SCSI_MS_PAGE_LEN(total) ((total) - 2)
uint8_t page_code;
#define SCSI_PAGE_CODE_PS (1 << 7) //!< Parameters Saveable
#define SCSI_PAGE_CODE_SPF (1 << 6) //!< SubPage Format
uint8_t page_length; //!< Number of bytes after this
#define SCSI_MS_PAGE_LEN(total) ((total) - 2)
};
//@}
+15 -15
View File
@@ -71,7 +71,7 @@
* \subsection sysclk_quickstart_use_case_1_setup_steps Initialization code
* Add to the application initialization code:
* \code
sysclk_init();
sysclk_init();
\endcode
*
* \subsection sysclk_quickstart_use_case_1_setup_steps_workflow Workflow
@@ -82,15 +82,15 @@
* Add or uncomment the following in your conf_clock.h header file, commenting out all other
* definitions of the same symbol(s):
* \code
#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_PLLACK
#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_PLLACK
// Fpll0 = (Fclk * PLL_mul) / PLL_div
#define CONFIG_PLL0_SOURCE PLL_SRC_MAINCK_XTAL
#define CONFIG_PLL0_MUL (84000000UL / BOARD_FREQ_MAINCK_XTAL)
#define CONFIG_PLL0_DIV 1
// Fpll0 = (Fclk * PLL_mul) / PLL_div
#define CONFIG_PLL0_SOURCE PLL_SRC_MAINCK_XTAL
#define CONFIG_PLL0_MUL (84000000UL / BOARD_FREQ_MAINCK_XTAL)
#define CONFIG_PLL0_DIV 1
// Fbus = Fsys / BUS_div
#define CONFIG_SYSCLK_PRES SYSCLK_PRES_1
// Fbus = Fsys / BUS_div
#define CONFIG_SYSCLK_PRES SYSCLK_PRES_1
\endcode
*
* \subsection sysclk_quickstart_use_case_1_example_workflow Workflow
@@ -100,14 +100,14 @@
* \code #define CONFIG_PLL0_SOURCE PLL_SRC_MAINCK_XTAL \endcode
* -# Configure the PLL module to multiply the external fast crystal oscillator frequency up to 84MHz:
* \code
#define CONFIG_PLL0_MUL (84000000UL / BOARD_FREQ_MAINCK_XTAL)
#define CONFIG_PLL0_DIV 1
#define CONFIG_PLL0_MUL (84000000UL / BOARD_FREQ_MAINCK_XTAL)
#define CONFIG_PLL0_DIV 1
\endcode
* \note For user boards, \c BOARD_FREQ_MAINCK_XTAL should be defined in the board \c conf_board.h configuration
* file as the frequency of the fast crystal attached to the microcontroller.
* -# Configure the main clock to run at the full 84MHz, disable scaling of the main system clock speed:
* \code
#define CONFIG_SYSCLK_PRES SYSCLK_PRES_1
#define CONFIG_SYSCLK_PRES SYSCLK_PRES_1
\endcode
* \note Some dividers are powers of two, while others are integer division factors. Refer to the
* formulas in the conf_clock.h template commented above each division define.
@@ -136,7 +136,7 @@ extern "C" {
* initialization.
*/
#ifndef CONFIG_SYSCLK_SOURCE
# define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_MAINCK_4M_RC
#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_MAINCK_4M_RC
#endif
/**
* \def CONFIG_SYSCLK_PRES
@@ -149,7 +149,7 @@ extern "C" {
* after initialization.
*/
#ifndef CONFIG_SYSCLK_PRES
# define CONFIG_SYSCLK_PRES 0
#define CONFIG_SYSCLK_PRES 0
#endif
//@}
@@ -197,7 +197,7 @@ extern "C" {
* USB is not required.
*/
#ifdef __DOXYGEN__
# define CONFIG_USBCLK_SOURCE
#define CONFIG_USBCLK_SOURCE
#endif
/**
@@ -209,7 +209,7 @@ extern "C" {
* defined.
*/
#ifdef __DOXYGEN__
# define CONFIG_USBCLK_DIV
#define CONFIG_USBCLK_DIV
#endif
+197 -204
View File
@@ -144,15 +144,15 @@ extern "C" {
* \code #define USB_DEVICE_ATTACH_AUTO_DISABLE \endcode
* User C file contains:
* \code
// Authorize VBUS monitoring
if (!udc_include_vbus_monitoring()) {
// Implement custom VBUS monitoring via GPIO or other
}
Event_VBUS_present() // VBUS interrupt or GPIO interrupt or other
{
// Attach USB Device
udc_attach();
}
// Authorize VBUS monitoring
if (!udc_include_vbus_monitoring()) {
// Implement custom VBUS monitoring via GPIO or other
}
Event_VBUS_present() // VBUS interrupt or GPIO interrupt or other
{
// Attach USB Device
udc_attach();
}
\endcode
*
* - Case of battery charging. conf_usb.h file contains define
@@ -160,21 +160,20 @@ extern "C" {
* \code #define USB_DEVICE_ATTACH_AUTO_DISABLE \endcode
* User C file contains:
* \code
Event VBUS present() // VBUS interrupt or GPIO interrupt or ..
{
// Authorize battery charging, but wait key press to start USB.
}
Event Key press()
{
// Stop batteries charging
// Start USB
udc_attach();
}
Event VBUS present() // VBUS interrupt or GPIO interrupt or ..
{
// Authorize battery charging, but wait key press to start USB.
}
Event Key press()
{
// Stop batteries charging
// Start USB
udc_attach();
}
\endcode
*/
static inline bool udc_include_vbus_monitoring(void)
{
return udd_include_vbus_monitoring();
static inline bool udc_include_vbus_monitoring(void) {
return udd_include_vbus_monitoring();
}
/*! \brief Start the USB Device stack
@@ -192,32 +191,26 @@ void udc_stop(void);
* then it will attach device when an acceptable Vbus
* level from the host is detected.
*/
static inline void udc_attach(void)
{
udd_attach();
static inline void udc_attach(void) {
udd_attach();
}
/**
* \brief Detaches the device from the bus
*
* The driver must remove pull-up on USB line D- or D+.
*/
static inline void udc_detach(void)
{
udd_detach();
static inline void udc_detach(void) {
udd_detach();
}
/*! \brief The USB driver sends a resume signal called \e "Upstream Resume"
* This is authorized only when the remote wakeup feature is enabled by host.
*/
static inline void udc_remotewakeup(void)
{
udd_send_remotewakeup();
static inline void udc_remotewakeup(void) {
udd_send_remotewakeup();
}
/**
* \brief Returns a pointer on the current interface descriptor
*
@@ -296,23 +289,23 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
*
* for AVR and SAM3/4 devices, add to the initialization code:
* \code
sysclk_init();
irq_initialize_vectors();
cpu_irq_enable();
board_init();
sleepmgr_init(); // Optional
sysclk_init();
irq_initialize_vectors();
cpu_irq_enable();
board_init();
sleepmgr_init(); // Optional
\endcode
*
* For SAMD devices, add to the initialization code:
* \code
system_init();
irq_initialize_vectors();
cpu_irq_enable();
sleepmgr_init(); // Optional
system_init();
irq_initialize_vectors();
cpu_irq_enable();
sleepmgr_init(); // Optional
\endcode
* Add to the main IDLE loop:
* \code
sleepmgr_enter_sleep(); // Optional
sleepmgr_enter_sleep(); // Optional
\endcode
*
*/
@@ -324,20 +317,20 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
*
* Content of conf_usb.h:
* \code
#define USB_DEVICE_VENDOR_ID 0x03EB
#define USB_DEVICE_PRODUCT_ID 0xXXXX
#define USB_DEVICE_MAJOR_VERSION 1
#define USB_DEVICE_MINOR_VERSION 0
#define USB_DEVICE_POWER 100
#define USB_DEVICE_ATTR USB_CONFIG_ATTR_BUS_POWERED
#define USB_DEVICE_VENDOR_ID 0x03EB
#define USB_DEVICE_PRODUCT_ID 0xXXXX
#define USB_DEVICE_MAJOR_VERSION 1
#define USB_DEVICE_MINOR_VERSION 0
#define USB_DEVICE_POWER 100
#define USB_DEVICE_ATTR USB_CONFIG_ATTR_BUS_POWERED
\endcode
*
* Add to application C-file:
* \code
void usb_init(void)
{
udc_start();
}
void usb_init(void)
{
udc_start();
}
\endcode
*/
@@ -349,17 +342,17 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
* -# Ensure that conf_usb.h is available and contains the following configuration
* which is the main USB device configuration:
* - \code // Vendor ID provided by USB org (ATMEL 0x03EB)
#define USB_DEVICE_VENDOR_ID 0x03EB // Type Word
// Product ID (Atmel PID referenced in usb_atmel.h)
#define USB_DEVICE_PRODUCT_ID 0xXXXX // Type Word
// Major version of the device
#define USB_DEVICE_MAJOR_VERSION 1 // Type Byte
// Minor version of the device
#define USB_DEVICE_MINOR_VERSION 0 // Type Byte
// Maximum device power (mA)
#define USB_DEVICE_POWER 100 // Type 9-bits
// USB attributes to enable features
#define USB_DEVICE_ATTR USB_CONFIG_ATTR_BUS_POWERED // Flags \endcode
#define USB_DEVICE_VENDOR_ID 0x03EB // Type Word
// Product ID (Atmel PID referenced in usb_atmel.h)
#define USB_DEVICE_PRODUCT_ID 0xXXXX // Type Word
// Major version of the device
#define USB_DEVICE_MAJOR_VERSION 1 // Type Byte
// Minor version of the device
#define USB_DEVICE_MINOR_VERSION 0 // Type Byte
// Maximum device power (mA)
#define USB_DEVICE_POWER 100 // Type 9-bits
// USB attributes to enable features
#define USB_DEVICE_ATTR USB_CONFIG_ATTR_BUS_POWERED // Flags \endcode
* -# Call the USB device stack start function to enable stack and start USB:
* - \code udc_start(); \endcode
* \note In case of USB dual roles (Device and Host) managed through USB OTG connector
@@ -372,90 +365,90 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
*
* Content of XMEGA conf_clock.h:
* \code
// Configuration based on internal RC:
// USB clock need of 48Mhz
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_RCOSC
#define CONFIG_OSC_RC32_CAL 48000000UL
#define CONFIG_OSC_AUTOCAL_RC32MHZ_REF_OSC OSC_ID_USBSOF
// CPU clock need of clock > 12MHz to run with USB (Here 24MHz)
#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_RC32MHZ
#define CONFIG_SYSCLK_PSADIV SYSCLK_PSADIV_2
#define CONFIG_SYSCLK_PSBCDIV SYSCLK_PSBCDIV_1_1
// Configuration based on internal RC:
// USB clock need of 48Mhz
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_RCOSC
#define CONFIG_OSC_RC32_CAL 48000000UL
#define CONFIG_OSC_AUTOCAL_RC32MHZ_REF_OSC OSC_ID_USBSOF
// CPU clock need of clock > 12MHz to run with USB (Here 24MHz)
#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_RC32MHZ
#define CONFIG_SYSCLK_PSADIV SYSCLK_PSADIV_2
#define CONFIG_SYSCLK_PSBCDIV SYSCLK_PSBCDIV_1_1
\endcode
*
* Content of conf_clock.h for AT32UC3A0, AT32UC3A1, AT32UC3B devices (USBB):
* \code
// Configuration based on 12MHz external OSC:
#define CONFIG_PLL1_SOURCE PLL_SRC_OSC0
#define CONFIG_PLL1_MUL 8
#define CONFIG_PLL1_DIV 2
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_PLL1
#define CONFIG_USBCLK_DIV 1 // Fusb = Fsys/(2 ^ USB_div)
// Configuration based on 12MHz external OSC:
#define CONFIG_PLL1_SOURCE PLL_SRC_OSC0
#define CONFIG_PLL1_MUL 8
#define CONFIG_PLL1_DIV 2
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_PLL1
#define CONFIG_USBCLK_DIV 1 // Fusb = Fsys/(2 ^ USB_div)
\endcode
*
* Content of conf_clock.h for AT32UC3A3, AT32UC3A4 devices (USBB with high speed support):
* \code
// Configuration based on 12MHz external OSC:
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_OSC0
#define CONFIG_USBCLK_DIV 1 // Fusb = Fsys/(2 ^ USB_div)
// Configuration based on 12MHz external OSC:
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_OSC0
#define CONFIG_USBCLK_DIV 1 // Fusb = Fsys/(2 ^ USB_div)
\endcode
*
* Content of conf_clock.h for AT32UC3C, ATUCXXD, ATUCXXL3U, ATUCXXL4U devices (USBC):
* \code
// Configuration based on 12MHz external OSC:
#define CONFIG_PLL1_SOURCE PLL_SRC_OSC0
#define CONFIG_PLL1_MUL 8
#define CONFIG_PLL1_DIV 2
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_PLL1
#define CONFIG_USBCLK_DIV 1 // Fusb = Fsys/(2 ^ USB_div)
// CPU clock need of clock > 25MHz to run with USBC
#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_PLL1
// Configuration based on 12MHz external OSC:
#define CONFIG_PLL1_SOURCE PLL_SRC_OSC0
#define CONFIG_PLL1_MUL 8
#define CONFIG_PLL1_DIV 2
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_PLL1
#define CONFIG_USBCLK_DIV 1 // Fusb = Fsys/(2 ^ USB_div)
// CPU clock need of clock > 25MHz to run with USBC
#define CONFIG_SYSCLK_SOURCE SYSCLK_SRC_PLL1
\endcode
*
* Content of conf_clock.h for SAM3S, SAM3SD, SAM4S devices (UPD: USB Peripheral Device):
* \code
// PLL1 (B) Options (Fpll = (Fclk * PLL_mul) / PLL_div)
#define CONFIG_PLL1_SOURCE PLL_SRC_MAINCK_XTAL
#define CONFIG_PLL1_MUL 16
#define CONFIG_PLL1_DIV 2
// USB Clock Source Options (Fusb = FpllX / USB_div)
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_PLL1
#define CONFIG_USBCLK_DIV 2
// PLL1 (B) Options (Fpll = (Fclk * PLL_mul) / PLL_div)
#define CONFIG_PLL1_SOURCE PLL_SRC_MAINCK_XTAL
#define CONFIG_PLL1_MUL 16
#define CONFIG_PLL1_DIV 2
// USB Clock Source Options (Fusb = FpllX / USB_div)
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_PLL1
#define CONFIG_USBCLK_DIV 2
\endcode
*
* Content of conf_clock.h for SAM3U device (UPDHS: USB Peripheral Device High Speed):
* \code
// USB Clock Source fixed at UPLL.
// USB Clock Source fixed at UPLL.
\endcode
*
* Content of conf_clock.h for SAM3X, SAM3A devices (UOTGHS: USB OTG High Speed):
* \code
// USB Clock Source fixed at UPLL.
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_UPLL
#define CONFIG_USBCLK_DIV 1
// USB Clock Source fixed at UPLL.
#define CONFIG_USBCLK_SOURCE USBCLK_SRC_UPLL
#define CONFIG_USBCLK_DIV 1
\endcode
*
* Content of conf_clocks.h for SAMD devices (USB):
* \code
// System clock bus configuration
# define CONF_CLOCK_FLASH_WAIT_STATES 2
// System clock bus configuration
# define CONF_CLOCK_FLASH_WAIT_STATES 2
// USB Clock Source fixed at DFLL.
// SYSTEM_CLOCK_SOURCE_DFLL configuration - Digital Frequency Locked Loop
# define CONF_CLOCK_DFLL_ENABLE true
# define CONF_CLOCK_DFLL_LOOP_MODE SYSTEM_CLOCK_DFLL_LOOP_MODE_USB_RECOVERY
# define CONF_CLOCK_DFLL_ON_DEMAND true
// USB Clock Source fixed at DFLL.
// SYSTEM_CLOCK_SOURCE_DFLL configuration - Digital Frequency Locked Loop
# define CONF_CLOCK_DFLL_ENABLE true
# define CONF_CLOCK_DFLL_LOOP_MODE SYSTEM_CLOCK_DFLL_LOOP_MODE_USB_RECOVERY
# define CONF_CLOCK_DFLL_ON_DEMAND true
// Set this to true to configure the GCLK when running clocks_init.
// If set to false, none of the GCLK generators will be configured in clocks_init().
# define CONF_CLOCK_CONFIGURE_GCLK true
// Set this to true to configure the GCLK when running clocks_init.
// If set to false, none of the GCLK generators will be configured in clocks_init().
# define CONF_CLOCK_CONFIGURE_GCLK true
// Configure GCLK generator 0 (Main Clock)
# define CONF_CLOCK_GCLK_0_ENABLE true
# define CONF_CLOCK_GCLK_0_RUN_IN_STANDBY true
# define CONF_CLOCK_GCLK_0_CLOCK_SOURCE SYSTEM_CLOCK_SOURCE_DFLL
# define CONF_CLOCK_GCLK_0_PRESCALER 1
# define CONF_CLOCK_GCLK_0_OUTPUT_ENABLE false
// Configure GCLK generator 0 (Main Clock)
# define CONF_CLOCK_GCLK_0_ENABLE true
# define CONF_CLOCK_GCLK_0_RUN_IN_STANDBY true
# define CONF_CLOCK_GCLK_0_CLOCK_SOURCE SYSTEM_CLOCK_SOURCE_DFLL
# define CONF_CLOCK_GCLK_0_PRESCALER 1
# define CONF_CLOCK_GCLK_0_OUTPUT_ENABLE false
\endcode
*/
@@ -474,34 +467,34 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
* \subsection udc_use_case_1_usage_code Example code
* Content of conf_usb.h:
* \code
#if // Low speed
#define USB_DEVICE_LOW_SPEED
// #define USB_DEVICE_HS_SUPPORT
#if // Low speed
#define USB_DEVICE_LOW_SPEED
// #define USB_DEVICE_HS_SUPPORT
#elif // Full speed
// #define USB_DEVICE_LOW_SPEED
// #define USB_DEVICE_HS_SUPPORT
#elif // Full speed
// #define USB_DEVICE_LOW_SPEED
// #define USB_DEVICE_HS_SUPPORT
#elif // High speed
// #define USB_DEVICE_LOW_SPEED
#define USB_DEVICE_HS_SUPPORT
#elif // High speed
// #define USB_DEVICE_LOW_SPEED
#define USB_DEVICE_HS_SUPPORT
#endif
#endif
\endcode
*
* \subsection udc_use_case_1_usage_flow Workflow
* -# Ensure that conf_usb.h is available and contains the following parameters
* required for a USB device low speed (1.5Mbit/s):
* - \code #define USB_DEVICE_LOW_SPEED
//#define USB_DEVICE_HS_SUPPORT \endcode
//#define USB_DEVICE_HS_SUPPORT \endcode
* -# Ensure that conf_usb.h contains the following parameters
* required for a USB device full speed (12Mbit/s):
* - \code //#define USB_DEVICE_LOW_SPEED
//#define USB_DEVICE_HS_SUPPORT \endcode
//#define USB_DEVICE_HS_SUPPORT \endcode
* -# Ensure that conf_usb.h contains the following parameters
* required for a USB device high speed (480Mbit/s):
* - \code //#define USB_DEVICE_LOW_SPEED
#define USB_DEVICE_HS_SUPPORT \endcode
#define USB_DEVICE_HS_SUPPORT \endcode
*/
/**
@@ -518,20 +511,20 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
* \subsection udc_use_case_2_usage_code Example code
* Content of conf_usb.h:
* \code
#define USB_DEVICE_MANUFACTURE_NAME "Manufacture name"
#define USB_DEVICE_PRODUCT_NAME "Product name"
#define USB_DEVICE_SERIAL_NAME "12...EF"
#define USB_DEVICE_MANUFACTURE_NAME "Manufacture name"
#define USB_DEVICE_PRODUCT_NAME "Product name"
#define USB_DEVICE_SERIAL_NAME "12...EF"
\endcode
*
* \subsection udc_use_case_2_usage_flow Workflow
* -# Ensure that conf_usb.h is available and contains the following parameters
* required to enable different USB strings:
* - \code // Static ASCII name for the manufacture
#define USB_DEVICE_MANUFACTURE_NAME "Manufacture name" \endcode
#define USB_DEVICE_MANUFACTURE_NAME "Manufacture name" \endcode
* - \code // Static ASCII name for the product
#define USB_DEVICE_PRODUCT_NAME "Product name" \endcode
#define USB_DEVICE_PRODUCT_NAME "Product name" \endcode
* - \code // Static ASCII name to enable and set a serial number
#define USB_DEVICE_SERIAL_NAME "12...EF" \endcode
#define USB_DEVICE_SERIAL_NAME "12...EF" \endcode
*/
/**
@@ -548,42 +541,42 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
* \subsection udc_use_case_3_usage_code Example code
* Content of conf_usb.h:
* \code
#define USB_DEVICE_ATTR \
(USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_..._POWERED)
#define UDC_REMOTEWAKEUP_ENABLE() my_callback_remotewakeup_enable()
extern void my_callback_remotewakeup_enable(void);
#define UDC_REMOTEWAKEUP_DISABLE() my_callback_remotewakeup_disable()
extern void my_callback_remotewakeup_disable(void);
#define USB_DEVICE_ATTR \
(USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_..._POWERED)
#define UDC_REMOTEWAKEUP_ENABLE() my_callback_remotewakeup_enable()
extern void my_callback_remotewakeup_enable(void);
#define UDC_REMOTEWAKEUP_DISABLE() my_callback_remotewakeup_disable()
extern void my_callback_remotewakeup_disable(void);
\endcode
*
* Add to application C-file:
* \code
void my_callback_remotewakeup_enable(void)
{
// Enable application wakeup events (e.g. enable GPIO interrupt)
}
void my_callback_remotewakeup_disable(void)
{
// Disable application wakeup events (e.g. disable GPIO interrupt)
}
void my_callback_remotewakeup_enable(void)
{
// Enable application wakeup events (e.g. enable GPIO interrupt)
}
void my_callback_remotewakeup_disable(void)
{
// Disable application wakeup events (e.g. disable GPIO interrupt)
}
void my_interrupt_event(void)
{
udc_remotewakeup();
}
void my_interrupt_event(void)
{
udc_remotewakeup();
}
\endcode
*
* \subsection udc_use_case_3_usage_flow Workflow
* -# Ensure that conf_usb.h is available and contains the following parameters
* required to enable remote wakeup feature:
* - \code // Authorizes the remote wakeup feature
#define USB_DEVICE_ATTR (USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_..._POWERED) \endcode
#define USB_DEVICE_ATTR (USB_CONFIG_ATTR_REMOTE_WAKEUP | USB_CONFIG_ATTR_..._POWERED) \endcode
* - \code // Define callback called when the host enables the remotewakeup feature
#define UDC_REMOTEWAKEUP_ENABLE() my_callback_remotewakeup_enable()
extern void my_callback_remotewakeup_enable(void); \endcode
#define UDC_REMOTEWAKEUP_ENABLE() my_callback_remotewakeup_enable()
extern void my_callback_remotewakeup_enable(void); \endcode
* - \code // Define callback called when the host disables the remotewakeup feature
#define UDC_REMOTEWAKEUP_DISABLE() my_callback_remotewakeup_disable()
extern void my_callback_remotewakeup_disable(void); \endcode
#define UDC_REMOTEWAKEUP_DISABLE() my_callback_remotewakeup_disable()
extern void my_callback_remotewakeup_disable(void); \endcode
* -# Send a remote wakeup (USB upstream):
* - \code udc_remotewakeup(); \endcode
*/
@@ -603,40 +596,40 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
* \subsection udc_use_case_5_usage_code Example code
* Content of conf_usb.h:
* \code
#define USB_DEVICE_ATTR (USB_CONFIG_ATTR_BUS_POWERED)
#define UDC_SUSPEND_EVENT() user_callback_suspend_action()
extern void user_callback_suspend_action(void)
#define UDC_RESUME_EVENT() user_callback_resume_action()
extern void user_callback_resume_action(void)
#define USB_DEVICE_ATTR (USB_CONFIG_ATTR_BUS_POWERED)
#define UDC_SUSPEND_EVENT() user_callback_suspend_action()
extern void user_callback_suspend_action(void)
#define UDC_RESUME_EVENT() user_callback_resume_action()
extern void user_callback_resume_action(void)
\endcode
*
* Add to application C-file:
* \code
void user_callback_suspend_action(void)
{
// Disable hardware component to reduce power consumption
}
void user_callback_resume_action(void)
{
// Re-enable hardware component
}
void user_callback_suspend_action(void)
{
// Disable hardware component to reduce power consumption
}
void user_callback_resume_action(void)
{
// Re-enable hardware component
}
\endcode
*
* \subsection udc_use_case_5_usage_flow Workflow
* -# Ensure that conf_usb.h is available and contains the following parameters:
* - \code // Authorizes the BUS power feature
#define USB_DEVICE_ATTR (USB_CONFIG_ATTR_BUS_POWERED) \endcode
#define USB_DEVICE_ATTR (USB_CONFIG_ATTR_BUS_POWERED) \endcode
* - \code // Define callback called when the host suspend the USB line
#define UDC_SUSPEND_EVENT() user_callback_suspend_action()
extern void user_callback_suspend_action(void); \endcode
#define UDC_SUSPEND_EVENT() user_callback_suspend_action()
extern void user_callback_suspend_action(void); \endcode
* - \code // Define callback called when the host or device resume the USB line
#define UDC_RESUME_EVENT() user_callback_resume_action()
extern void user_callback_resume_action(void); \endcode
#define UDC_RESUME_EVENT() user_callback_resume_action()
extern void user_callback_resume_action(void); \endcode
* -# Reduce power consumption in suspend mode (max. 2.5mA on Vbus):
* - \code void user_callback_suspend_action(void)
{
turn_off_components();
} \endcode
{
turn_off_components();
} \endcode
*/
/**
@@ -654,42 +647,42 @@ usb_iface_desc_t UDC_DESC_STORAGE *udc_get_interface_desc(void);
* \subsection udc_use_case_6_usage_code Example code
* Content of conf_usb.h:
* \code
#define USB_DEVICE_SERIAL_NAME
#define USB_DEVICE_GET_SERIAL_NAME_POINTER serial_number
#define USB_DEVICE_GET_SERIAL_NAME_LENGTH 12
extern uint8_t serial_number[];
#define USB_DEVICE_SERIAL_NAME
#define USB_DEVICE_GET_SERIAL_NAME_POINTER serial_number
#define USB_DEVICE_GET_SERIAL_NAME_LENGTH 12
extern uint8_t serial_number[];
\endcode
*
* Add to application C-file:
* \code
uint8_t serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH];
uint8_t serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH];
void init_build_usb_serial_number(void)
{
serial_number[0] = 'A';
serial_number[1] = 'B';
...
serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH-1] = 'C';
} \endcode
void init_build_usb_serial_number(void)
{
serial_number[0] = 'A';
serial_number[1] = 'B';
...
serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH-1] = 'C';
} \endcode
*
* \subsection udc_use_case_6_usage_flow Workflow
* -# Ensure that conf_usb.h is available and contains the following parameters
* required to enable a USB serial number strings dynamically:
* - \code #define USB_DEVICE_SERIAL_NAME // Define this empty
#define USB_DEVICE_GET_SERIAL_NAME_POINTER serial_number // Give serial array pointer
#define USB_DEVICE_GET_SERIAL_NAME_LENGTH 12 // Give size of serial array
extern uint8_t serial_number[]; // Declare external serial array \endcode
#define USB_DEVICE_GET_SERIAL_NAME_POINTER serial_number // Give serial array pointer
#define USB_DEVICE_GET_SERIAL_NAME_LENGTH 12 // Give size of serial array
extern uint8_t serial_number[]; // Declare external serial array \endcode
* -# Before start USB stack, initialize the serial array
* - \code
uint8_t serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH];
uint8_t serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH];
void init_build_usb_serial_number(void)
{
serial_number[0] = 'A';
serial_number[1] = 'B';
...
serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH-1] = 'C';
} \endcode
void init_build_usb_serial_number(void)
{
serial_number[0] = 'A';
serial_number[1] = 'B';
...
serial_number[USB_DEVICE_GET_SERIAL_NAME_LENGTH-1] = 'C';
} \endcode
*/
+28 -31
View File
@@ -78,50 +78,47 @@ extern "C" {
* For Mega application used "code".
*/
#define UDC_DESC_STORAGE
// Descriptor storage in internal RAM
// Descriptor storage in internal RAM
#if (defined UDC_DATA_USE_HRAM_SUPPORT)
# if defined(__GNUC__)
# define UDC_DATA(x) COMPILER_WORD_ALIGNED __attribute__((__section__(".data_hram0")))
# define UDC_BSS(x) COMPILER_ALIGNED(x) __attribute__((__section__(".bss_hram0")))
# elif defined(__ICCAVR32__)
# define UDC_DATA(x) COMPILER_ALIGNED(x) __data32
# define UDC_BSS(x) COMPILER_ALIGNED(x) __data32
# endif
#else
# define UDC_DATA(x) COMPILER_ALIGNED(x)
# define UDC_BSS(x) COMPILER_ALIGNED(x)
#if defined(__GNUC__)
#define UDC_DATA(x) COMPILER_WORD_ALIGNED __attribute__((__section__(".data_hram0")))
#define UDC_BSS(x) COMPILER_ALIGNED(x) __attribute__((__section__(".bss_hram0")))
#elif defined(__ICCAVR32__)
#define UDC_DATA(x) COMPILER_ALIGNED(x) __data32
#define UDC_BSS(x) COMPILER_ALIGNED(x) __data32
#endif
#else
#define UDC_DATA(x) COMPILER_ALIGNED(x)
#define UDC_BSS(x) COMPILER_ALIGNED(x)
#endif
/**
* \brief Configuration descriptor and UDI link for one USB speed
*/
typedef struct {
//! USB configuration descriptor
usb_conf_desc_t UDC_DESC_STORAGE *desc;
//! Array of UDI API pointer
udi_api_t UDC_DESC_STORAGE *UDC_DESC_STORAGE * udi_apis;
//! USB configuration descriptor
usb_conf_desc_t UDC_DESC_STORAGE *desc;
//! Array of UDI API pointer
udi_api_t UDC_DESC_STORAGE *UDC_DESC_STORAGE * udi_apis;
} udc_config_speed_t;
/**
* \brief All information about the USB Device
*/
typedef struct {
//! USB device descriptor for low or full speed
usb_dev_desc_t UDC_DESC_STORAGE *confdev_lsfs;
//! USB configuration descriptor and UDI API pointers for low or full speed
udc_config_speed_t UDC_DESC_STORAGE *conf_lsfs;
#ifdef USB_DEVICE_HS_SUPPORT
//! USB device descriptor for high speed
usb_dev_desc_t UDC_DESC_STORAGE *confdev_hs;
//! USB device qualifier, only use in high speed mode
usb_dev_qual_desc_t UDC_DESC_STORAGE *qualifier;
//! USB configuration descriptor and UDI API pointers for high speed
udc_config_speed_t UDC_DESC_STORAGE *conf_hs;
#endif
usb_dev_bos_desc_t UDC_DESC_STORAGE *conf_bos;
//! USB device descriptor for low or full speed
usb_dev_desc_t UDC_DESC_STORAGE *confdev_lsfs;
//! USB configuration descriptor and UDI API pointers for low or full speed
udc_config_speed_t UDC_DESC_STORAGE *conf_lsfs;
#ifdef USB_DEVICE_HS_SUPPORT
//! USB device descriptor for high speed
usb_dev_desc_t UDC_DESC_STORAGE *confdev_hs;
//! USB device qualifier, only use in high speed mode
usb_dev_qual_desc_t UDC_DESC_STORAGE *qualifier;
//! USB configuration descriptor and UDI API pointers for high speed
udc_config_speed_t UDC_DESC_STORAGE *conf_hs;
#endif
usb_dev_bos_desc_t UDC_DESC_STORAGE *conf_bos;
} udc_config_t;
//! Global variables of USB Device Descriptor and UDI links
+24 -34
View File
@@ -71,8 +71,8 @@ typedef uint8_t udd_ep_id_t;
//! \brief Endpoint transfer status
//! Returned in parameters of callback register via udd_ep_run routine.
typedef enum {
UDD_EP_TRANSFER_OK = 0,
UDD_EP_TRANSFER_ABORT = 1,
UDD_EP_TRANSFER_OK = 0,
UDD_EP_TRANSFER_ABORT = 1,
} udd_ep_status_t;
/**
@@ -82,41 +82,37 @@ typedef enum {
* It can be updated by udc_process_setup() from UDC or *setup() from UDIs.
*/
typedef struct {
//! Data received in USB SETUP packet
//! Note: The swap of "req.wValues" from uin16_t to le16_t is done by UDD.
usb_setup_req_t req;
//! Data received in USB SETUP packet
//! Note: The swap of "req.wValues" from uin16_t to le16_t is done by UDD.
usb_setup_req_t req;
//! Point to buffer to send or fill with data following SETUP packet
//! This buffer must be word align for DATA IN phase (use prefix COMPILER_WORD_ALIGNED for buffer)
uint8_t *payload;
//! Point to buffer to send or fill with data following SETUP packet
//! This buffer must be word align for DATA IN phase (use prefix COMPILER_WORD_ALIGNED for buffer)
uint8_t *payload;
//! Size of buffer to send or fill, and content the number of byte transferred
uint16_t payload_size;
//! Size of buffer to send or fill, and content the number of byte transferred
uint16_t payload_size;
//! Callback called after reception of ZLP from setup request
void (*callback)(void);
//! Callback called after reception of ZLP from setup request
void (*callback)(void);
//! Callback called when the buffer given (.payload) is full or empty.
//! This one return false to abort data transfer, or true with a new buffer in .payload.
bool (*over_under_run)(void);
//! Callback called when the buffer given (.payload) is full or empty.
//! This one return false to abort data transfer, or true with a new buffer in .payload.
bool (*over_under_run)(void);
} udd_ctrl_request_t;
extern udd_ctrl_request_t udd_g_ctrlreq;
//! Return true if the setup request \a udd_g_ctrlreq indicates IN data transfer
#define Udd_setup_is_in() \
(USB_REQ_DIR_IN == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
#define Udd_setup_is_in() (USB_REQ_DIR_IN == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
//! Return true if the setup request \a udd_g_ctrlreq indicates OUT data transfer
#define Udd_setup_is_out() \
(USB_REQ_DIR_OUT == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
#define Udd_setup_is_out() (USB_REQ_DIR_OUT == (udd_g_ctrlreq.req.bmRequestType & USB_REQ_DIR_MASK))
//! Return the type of the SETUP request \a udd_g_ctrlreq. \see usb_reqtype.
#define Udd_setup_type() \
(udd_g_ctrlreq.req.bmRequestType & USB_REQ_TYPE_MASK)
#define Udd_setup_type() (udd_g_ctrlreq.req.bmRequestType & USB_REQ_TYPE_MASK)
//! Return the recipient of the SETUP request \a udd_g_ctrlreq. \see usb_recipient
#define Udd_setup_recipient() \
(udd_g_ctrlreq.req.bmRequestType & USB_REQ_RECIP_MASK)
#define Udd_setup_recipient() (udd_g_ctrlreq.req.bmRequestType & USB_REQ_RECIP_MASK)
/**
* \brief End of halt callback function type.
@@ -134,8 +130,7 @@ typedef void (*udd_callback_halt_cleared_t)(void);
* \param status UDD_EP_TRANSFER_ABORT, if transfer is aborted
* \param n number of data transferred
*/
typedef void (*udd_callback_trans_t) (udd_ep_status_t status,
iram_size_t nb_transferred, udd_ep_id_t ep);
typedef void (*udd_callback_trans_t) (udd_ep_status_t status, iram_size_t nb_transferred, udd_ep_id_t ep);
/**
* \brief Authorizes the VBUS event
@@ -239,8 +234,7 @@ void udd_set_setup_payload( uint8_t *payload, uint16_t payload_size );
*
* \return \c 1 if the endpoint is enabled, otherwise \c 0.
*/
bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes,
uint16_t MaxEndpointSize);
bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes, uint16_t MaxEndpointSize);
/**
* \brief Disables an endpoint
@@ -294,8 +288,7 @@ bool udd_ep_clear_halt(udd_ep_id_t ep);
*
* \return \c 1 if the register is accepted, otherwise \c 0.
*/
bool udd_ep_wait_stall_clear(udd_ep_id_t ep,
udd_callback_halt_cleared_t callback);
bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callback);
/**
* \brief Allows to receive or send data on an endpoint
@@ -321,9 +314,8 @@ bool udd_ep_wait_stall_clear(udd_ep_id_t ep,
*
* \return \c 1 if function was successfully done, otherwise \c 0.
*/
bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket,
uint8_t * buf, iram_size_t buf_size,
udd_callback_trans_t callback);
bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t * buf, iram_size_t buf_size, udd_callback_trans_t callback);
/**
* \brief Aborts transfer on going on endpoint
*
@@ -339,7 +331,6 @@ void udd_ep_abort(udd_ep_id_t ep);
//@}
/**
* \name High speed test mode management
*
@@ -352,7 +343,6 @@ void udd_test_mode_se0_nak(void);
void udd_test_mode_packet(void);
//@}
/**
* \name UDC callbacks to provide for UDD
*
+47 -47
View File
@@ -72,57 +72,57 @@ extern "C" {
* selected by UDC.
*/
typedef struct {
/**
* \brief Enable the interface.
*
* This function is called when the host selects a configuration
* to which this interface belongs through a Set Configuration
* request, and when the host selects an alternate setting of
* this interface through a Set Interface request.
*
* \return \c 1 if function was successfully done, otherwise \c 0.
*/
bool (*enable)(void);
/**
* \brief Enable the interface.
*
* This function is called when the host selects a configuration
* to which this interface belongs through a Set Configuration
* request, and when the host selects an alternate setting of
* this interface through a Set Interface request.
*
* \return \c 1 if function was successfully done, otherwise \c 0.
*/
bool (*enable)(void);
/**
* \brief Disable the interface.
*
* This function is called when this interface is currently
* active, and
* - the host selects any configuration through a Set
* Configuration request, or
* - the host issues a USB reset, or
* - the device is detached from the host (i.e. Vbus is no
* longer present)
*/
void (*disable)(void);
/**
* \brief Disable the interface.
*
* This function is called when this interface is currently
* active, and
* - the host selects any configuration through a Set
* Configuration request, or
* - the host issues a USB reset, or
* - the device is detached from the host (i.e. Vbus is no
* longer present)
*/
void (*disable)(void);
/**
* \brief Handle a control request directed at an interface.
*
* This function is called when this interface is currently
* active and the host sends a SETUP request
* with this interface as the recipient.
*
* Use udd_g_ctrlreq to decode and response to SETUP request.
*
* \return \c 1 if this interface supports the SETUP request, otherwise \c 0.
*/
bool (*setup)(void);
/**
* \brief Handle a control request directed at an interface.
*
* This function is called when this interface is currently
* active and the host sends a SETUP request
* with this interface as the recipient.
*
* Use udd_g_ctrlreq to decode and response to SETUP request.
*
* \return \c 1 if this interface supports the SETUP request, otherwise \c 0.
*/
bool (*setup)(void);
/**
* \brief Returns the current setting of the selected interface.
*
* This function is called when UDC when know alternate setting of selected interface.
*
* \return alternate setting of selected interface
*/
uint8_t (*getsetting)(void);
/**
* \brief Returns the current setting of the selected interface.
*
* This function is called when UDC when know alternate setting of selected interface.
*
* \return alternate setting of selected interface
*/
uint8_t (*getsetting)(void);
/**
* \brief To signal that a SOF is occurred
*/
void (*sof_notify)(void);
/**
* \brief To signal that a SOF is occurred
*/
void (*sof_notify)(void);
} udi_api_t;
//@}
+145 -149
View File
@@ -92,18 +92,18 @@ extern UDC_DESC_STORAGE udi_api_t udi_api_cdc_data;
* descriptors for the CDC Communication Class interface.
*/
typedef struct {
//! Standard interface descriptor
usb_iface_desc_t iface;
//! CDC Header functional descriptor
usb_cdc_hdr_desc_t header;
//! CDC Abstract Control Model functional descriptor
usb_cdc_acm_desc_t acm;
//! CDC Union functional descriptor
usb_cdc_union_desc_t union_desc;
//! CDC Call Management functional descriptor
usb_cdc_call_mgmt_desc_t call_mgmt;
//! Notification endpoint descriptor
usb_ep_desc_t ep_notify;
//! Standard interface descriptor
usb_iface_desc_t iface;
//! CDC Header functional descriptor
usb_cdc_hdr_desc_t header;
//! CDC Abstract Control Model functional descriptor
usb_cdc_acm_desc_t acm;
//! CDC Union functional descriptor
usb_cdc_union_desc_t union_desc;
//! CDC Call Management functional descriptor
usb_cdc_call_mgmt_desc_t call_mgmt;
//! Notification endpoint descriptor
usb_ep_desc_t ep_notify;
} udi_cdc_comm_desc_t;
@@ -114,11 +114,11 @@ typedef struct {
* CDC Data Class interface.
*/
typedef struct {
//! Standard interface descriptor
usb_iface_desc_t iface;
//! Data IN/OUT endpoint descriptors
usb_ep_desc_t ep_in;
usb_ep_desc_t ep_out;
//! Standard interface descriptor
usb_iface_desc_t iface;
//! Data IN/OUT endpoint descriptors
usb_ep_desc_t ep_in;
usb_ep_desc_t ep_out;
} udi_cdc_data_desc_t;
@@ -136,13 +136,13 @@ typedef struct {
//@{
//! By default no string associated to these interfaces
#ifndef UDI_CDC_IAD_STRING_ID_0
#define UDI_CDC_IAD_STRING_ID_0 0
#define UDI_CDC_IAD_STRING_ID_0 0
#endif
#ifndef UDI_CDC_COMM_STRING_ID_0
#define UDI_CDC_COMM_STRING_ID_0 0
#define UDI_CDC_COMM_STRING_ID_0 0
#endif
#ifndef UDI_CDC_DATA_STRING_ID_0
#define UDI_CDC_DATA_STRING_ID_0 0
#define UDI_CDC_DATA_STRING_ID_0 0
#endif
#define UDI_CDC_IAD_DESC_0 UDI_CDC_IAD_DESC(0)
#define UDI_CDC_COMM_DESC_0 UDI_CDC_COMM_DESC(0)
@@ -151,13 +151,13 @@ typedef struct {
//! By default no string associated to these interfaces
#ifndef UDI_CDC_IAD_STRING_ID_1
#define UDI_CDC_IAD_STRING_ID_1 0
#define UDI_CDC_IAD_STRING_ID_1 0
#endif
#ifndef UDI_CDC_COMM_STRING_ID_1
#define UDI_CDC_COMM_STRING_ID_1 0
#define UDI_CDC_COMM_STRING_ID_1 0
#endif
#ifndef UDI_CDC_DATA_STRING_ID_1
#define UDI_CDC_DATA_STRING_ID_1 0
#define UDI_CDC_DATA_STRING_ID_1 0
#endif
#define UDI_CDC_IAD_DESC_1 UDI_CDC_IAD_DESC(1)
#define UDI_CDC_COMM_DESC_1 UDI_CDC_COMM_DESC(1)
@@ -166,13 +166,13 @@ typedef struct {
//! By default no string associated to these interfaces
#ifndef UDI_CDC_IAD_STRING_ID_2
#define UDI_CDC_IAD_STRING_ID_2 0
#define UDI_CDC_IAD_STRING_ID_2 0
#endif
#ifndef UDI_CDC_COMM_STRING_ID_2
#define UDI_CDC_COMM_STRING_ID_2 0
#define UDI_CDC_COMM_STRING_ID_2 0
#endif
#ifndef UDI_CDC_DATA_STRING_ID_2
#define UDI_CDC_DATA_STRING_ID_2 0
#define UDI_CDC_DATA_STRING_ID_2 0
#endif
#define UDI_CDC_IAD_DESC_2 UDI_CDC_IAD_DESC(2)
#define UDI_CDC_COMM_DESC_2 UDI_CDC_COMM_DESC(2)
@@ -181,13 +181,13 @@ typedef struct {
//! By default no string associated to these interfaces
#ifndef UDI_CDC_IAD_STRING_ID_3
#define UDI_CDC_IAD_STRING_ID_3 0
#define UDI_CDC_IAD_STRING_ID_3 0
#endif
#ifndef UDI_CDC_COMM_STRING_ID_3
#define UDI_CDC_COMM_STRING_ID_3 0
#define UDI_CDC_COMM_STRING_ID_3 0
#endif
#ifndef UDI_CDC_DATA_STRING_ID_3
#define UDI_CDC_DATA_STRING_ID_3 0
#define UDI_CDC_DATA_STRING_ID_3 0
#endif
#define UDI_CDC_IAD_DESC_3 UDI_CDC_IAD_DESC(3)
#define UDI_CDC_COMM_DESC_3 UDI_CDC_COMM_DESC(3)
@@ -196,13 +196,13 @@ typedef struct {
//! By default no string associated to these interfaces
#ifndef UDI_CDC_IAD_STRING_ID_4
#define UDI_CDC_IAD_STRING_ID_4 0
#define UDI_CDC_IAD_STRING_ID_4 0
#endif
#ifndef UDI_CDC_COMM_STRING_ID_4
#define UDI_CDC_COMM_STRING_ID_4 0
#define UDI_CDC_COMM_STRING_ID_4 0
#endif
#ifndef UDI_CDC_DATA_STRING_ID_4
#define UDI_CDC_DATA_STRING_ID_4 0
#define UDI_CDC_DATA_STRING_ID_4 0
#endif
#define UDI_CDC_IAD_DESC_4 UDI_CDC_IAD_DESC(4)
#define UDI_CDC_COMM_DESC_4 UDI_CDC_COMM_DESC(4)
@@ -211,13 +211,13 @@ typedef struct {
//! By default no string associated to these interfaces
#ifndef UDI_CDC_IAD_STRING_ID_5
#define UDI_CDC_IAD_STRING_ID_5 0
#define UDI_CDC_IAD_STRING_ID_5 0
#endif
#ifndef UDI_CDC_COMM_STRING_ID_5
#define UDI_CDC_COMM_STRING_ID_5 0
#define UDI_CDC_COMM_STRING_ID_5 0
#endif
#ifndef UDI_CDC_DATA_STRING_ID_5
#define UDI_CDC_DATA_STRING_ID_5 0
#define UDI_CDC_DATA_STRING_ID_5 0
#endif
#define UDI_CDC_IAD_DESC_5 UDI_CDC_IAD_DESC(5)
#define UDI_CDC_COMM_DESC_5 UDI_CDC_COMM_DESC(5)
@@ -226,13 +226,13 @@ typedef struct {
//! By default no string associated to these interfaces
#ifndef UDI_CDC_IAD_STRING_ID_6
#define UDI_CDC_IAD_STRING_ID_6 0
#define UDI_CDC_IAD_STRING_ID_6 0
#endif
#ifndef UDI_CDC_COMM_STRING_ID_6
#define UDI_CDC_COMM_STRING_ID_6 0
#define UDI_CDC_COMM_STRING_ID_6 0
#endif
#ifndef UDI_CDC_DATA_STRING_ID_6
#define UDI_CDC_DATA_STRING_ID_6 0
#define UDI_CDC_DATA_STRING_ID_6 0
#endif
#define UDI_CDC_IAD_DESC_6 UDI_CDC_IAD_DESC(6)
#define UDI_CDC_COMM_DESC_6 UDI_CDC_COMM_DESC(6)
@@ -240,7 +240,6 @@ typedef struct {
#define UDI_CDC_DATA_DESC_6_HS UDI_CDC_DATA_DESC_HS(6)
//@}
//! Content of CDC IAD interface descriptor for all speeds
#define UDI_CDC_IAD_DESC(port) { \
.bLength = sizeof(usb_iad_desc_t),\
@@ -270,7 +269,7 @@ typedef struct {
.call_mgmt.bDescriptorType = CDC_CS_INTERFACE,\
.call_mgmt.bDescriptorSubtype = CDC_SCS_CALL_MGMT,\
.call_mgmt.bmCapabilities = \
CDC_CALL_MGMT_SUPPORTED | CDC_CALL_MGMT_OVER_DCI,\
CDC_CALL_MGMT_SUPPORTED | CDC_CALL_MGMT_OVER_DCI,\
.acm.bFunctionLength = sizeof(usb_cdc_acm_desc_t),\
.acm.bDescriptorType = CDC_CS_INTERFACE,\
.acm.bDescriptorSubtype = CDC_SCS_ACM,\
@@ -610,40 +609,37 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
* \subsection udi_cdc_basic_use_case_usage_code Example code
* Content of conf_usb.h:
* \code
#define UDI_CDC_ENABLE_EXT(port) my_callback_cdc_enable()
extern bool my_callback_cdc_enable(void);
#define UDI_CDC_DISABLE_EXT(port) my_callback_cdc_disable()
extern void my_callback_cdc_disable(void);
#define UDI_CDC_LOW_RATE
#define UDI_CDC_ENABLE_EXT(port) my_callback_cdc_enable()
extern bool my_callback_cdc_enable(void);
#define UDI_CDC_DISABLE_EXT(port) my_callback_cdc_disable()
extern void my_callback_cdc_disable(void);
#define UDI_CDC_LOW_RATE
#define UDI_CDC_DEFAULT_RATE 115200
#define UDI_CDC_DEFAULT_STOPBITS CDC_STOP_BITS_1
#define UDI_CDC_DEFAULT_PARITY CDC_PAR_NONE
#define UDI_CDC_DEFAULT_DATABITS 8
#define UDI_CDC_DEFAULT_RATE 115200
#define UDI_CDC_DEFAULT_STOPBITS CDC_STOP_BITS_1
#define UDI_CDC_DEFAULT_PARITY CDC_PAR_NONE
#define UDI_CDC_DEFAULT_DATABITS 8
#include "udi_cdc_conf.h" // At the end of conf_usb.h file
#include "udi_cdc_conf.h" // At the end of conf_usb.h file
\endcode
*
* Add to application C-file:
* \code
static bool my_flag_autorize_cdc_transfert = false;
bool my_callback_cdc_enable(void)
{
my_flag_autorize_cdc_transfert = true;
return true;
}
void my_callback_cdc_disable(void)
{
my_flag_autorize_cdc_transfert = false;
}
static bool my_flag_autorize_cdc_transfert = false;
bool my_callback_cdc_enable(void) {
my_flag_autorize_cdc_transfert = true;
return true;
}
void my_callback_cdc_disable(void) {
my_flag_autorize_cdc_transfert = false;
}
void task(void)
{
if (my_flag_autorize_cdc_transfert) {
udi_cdc_putc('A');
udi_cdc_getc();
}
}
void task(void) {
if (my_flag_autorize_cdc_transfert) {
udi_cdc_putc('A');
udi_cdc_getc();
}
}
\endcode
*
* \subsection udi_cdc_basic_use_case_setup_flow Workflow
@@ -652,14 +648,14 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
* - \code #define USB_DEVICE_SERIAL_NAME "12...EF" // Disk SN for CDC \endcode
* \note The USB serial number is mandatory when a CDC interface is used.
* - \code #define UDI_CDC_ENABLE_EXT(port) my_callback_cdc_enable()
extern bool my_callback_cdc_enable(void); \endcode
extern bool my_callback_cdc_enable(void); \endcode
* \note After the device enumeration (detecting and identifying USB devices),
* the USB host starts the device configuration. When the USB CDC interface
* from the device is accepted by the host, the USB host enables this interface and the
* UDI_CDC_ENABLE_EXT() callback function is called and return true.
* Thus, when this event is received, the data transfer on CDC interface are authorized.
* - \code #define UDI_CDC_DISABLE_EXT(port) my_callback_cdc_disable()
extern void my_callback_cdc_disable(void); \endcode
extern void my_callback_cdc_disable(void); \endcode
* \note When the USB device is unplugged or is reset by the USB host, the USB
* interface is disabled and the UDI_CDC_DISABLE_EXT() callback function
* is called. Thus, the data transfer must be stopped on CDC interface.
@@ -667,19 +663,19 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
* \note Define it when the transfer CDC Device to Host is a low rate
* (<512000 bauds) to reduce CDC buffers size.
* - \code #define UDI_CDC_DEFAULT_RATE 115200
#define UDI_CDC_DEFAULT_STOPBITS CDC_STOP_BITS_1
#define UDI_CDC_DEFAULT_PARITY CDC_PAR_NONE
#define UDI_CDC_DEFAULT_DATABITS 8 \endcode
#define UDI_CDC_DEFAULT_STOPBITS CDC_STOP_BITS_1
#define UDI_CDC_DEFAULT_PARITY CDC_PAR_NONE
#define UDI_CDC_DEFAULT_DATABITS 8 \endcode
* \note Default configuration of communication port at startup.
* -# Send or wait data on CDC line:
* - \code // Waits and gets a value on CDC line
int udi_cdc_getc(void);
// Reads a RAM buffer on CDC line
iram_size_t udi_cdc_read_buf(int *buf, iram_size_t size);
// Puts a byte on CDC line
int udi_cdc_putc(int value);
// Writes a RAM buffer on CDC line
iram_size_t udi_cdc_write_buf(const int *buf, iram_size_t size); \endcode
int udi_cdc_getc(void);
// Reads a RAM buffer on CDC line
iram_size_t udi_cdc_read_buf(int *buf, iram_size_t size);
// Puts a byte on CDC line
int udi_cdc_putc(int value);
// Writes a RAM buffer on CDC line
iram_size_t udi_cdc_write_buf(const int *buf, iram_size_t size); \endcode
*
* \section udi_cdc_use_cases Advanced use cases
* For more advanced use of the UDI CDC module, see the following use cases:
@@ -713,90 +709,90 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
* \subsection udi_cdc_use_case_composite_usage_code Example code
* Content of conf_usb.h:
* \code
#define USB_DEVICE_EP_CTRL_SIZE 64
#define USB_DEVICE_NB_INTERFACE (X+2)
#define USB_DEVICE_MAX_EP (X+3)
#define USB_DEVICE_EP_CTRL_SIZE 64
#define USB_DEVICE_NB_INTERFACE (X+2)
#define USB_DEVICE_MAX_EP (X+3)
#define UDI_CDC_DATA_EP_IN_0 (1 | USB_EP_DIR_IN) // TX
#define UDI_CDC_DATA_EP_OUT_0 (2 | USB_EP_DIR_OUT) // RX
#define UDI_CDC_COMM_EP_0 (3 | USB_EP_DIR_IN) // Notify endpoint
#define UDI_CDC_COMM_IFACE_NUMBER_0 X+0
#define UDI_CDC_DATA_IFACE_NUMBER_0 X+1
#define UDI_CDC_DATA_EP_IN_0 (1 | USB_EP_DIR_IN) // TX
#define UDI_CDC_DATA_EP_OUT_0 (2 | USB_EP_DIR_OUT) // RX
#define UDI_CDC_COMM_EP_0 (3 | USB_EP_DIR_IN) // Notify endpoint
#define UDI_CDC_COMM_IFACE_NUMBER_0 X+0
#define UDI_CDC_DATA_IFACE_NUMBER_0 X+1
#define UDI_COMPOSITE_DESC_T \
usb_iad_desc_t udi_cdc_iad; \
udi_cdc_comm_desc_t udi_cdc_comm; \
udi_cdc_data_desc_t udi_cdc_data; \
...
#define UDI_COMPOSITE_DESC_FS \
.udi_cdc_iad = UDI_CDC_IAD_DESC_0, \
.udi_cdc_comm = UDI_CDC_COMM_DESC_0, \
.udi_cdc_data = UDI_CDC_DATA_DESC_0_FS, \
...
#define UDI_COMPOSITE_DESC_HS \
.udi_cdc_iad = UDI_CDC_IAD_DESC_0, \
.udi_cdc_comm = UDI_CDC_COMM_DESC_0, \
.udi_cdc_data = UDI_CDC_DATA_DESC_0_HS, \
...
#define UDI_COMPOSITE_API \
&udi_api_cdc_comm, \
&udi_api_cdc_data, \
...
#define UDI_COMPOSITE_DESC_T \
usb_iad_desc_t udi_cdc_iad; \
udi_cdc_comm_desc_t udi_cdc_comm; \
udi_cdc_data_desc_t udi_cdc_data; \
...
#define UDI_COMPOSITE_DESC_FS \
.udi_cdc_iad = UDI_CDC_IAD_DESC_0, \
.udi_cdc_comm = UDI_CDC_COMM_DESC_0, \
.udi_cdc_data = UDI_CDC_DATA_DESC_0_FS, \
...
#define UDI_COMPOSITE_DESC_HS \
.udi_cdc_iad = UDI_CDC_IAD_DESC_0, \
.udi_cdc_comm = UDI_CDC_COMM_DESC_0, \
.udi_cdc_data = UDI_CDC_DATA_DESC_0_HS, \
...
#define UDI_COMPOSITE_API \
&udi_api_cdc_comm, \
&udi_api_cdc_data, \
...
\endcode
*
* \subsection udi_cdc_use_case_composite_usage_flow Workflow
* -# Ensure that conf_usb.h is available and contains the following parameters
* required for a USB composite device configuration:
* - \code // Endpoint control size, This must be:
// - 8, 16, 32 or 64 for full speed device (8 is recommended to save RAM)
// - 64 for a high speed device
#define USB_DEVICE_EP_CTRL_SIZE 64
// Total Number of interfaces on this USB device.
// Add 2 for CDC.
#define USB_DEVICE_NB_INTERFACE (X+2)
// Total number of endpoints on this USB device.
// This must include each endpoint for each interface.
// Add 3 for CDC.
#define USB_DEVICE_MAX_EP (X+3) \endcode
// - 8, 16, 32 or 64 for full speed device (8 is recommended to save RAM)
// - 64 for a high speed device
#define USB_DEVICE_EP_CTRL_SIZE 64
// Total Number of interfaces on this USB device.
// Add 2 for CDC.
#define USB_DEVICE_NB_INTERFACE (X+2)
// Total number of endpoints on this USB device.
// This must include each endpoint for each interface.
// Add 3 for CDC.
#define USB_DEVICE_MAX_EP (X+3) \endcode
* -# Ensure that conf_usb.h contains the description of
* composite device:
* - \code // The endpoint numbers chosen by you for the CDC.
// The endpoint numbers starting from 1.
#define UDI_CDC_DATA_EP_IN_0 (1 | USB_EP_DIR_IN) // TX
#define UDI_CDC_DATA_EP_OUT_0 (2 | USB_EP_DIR_OUT) // RX
#define UDI_CDC_COMM_EP_0 (3 | USB_EP_DIR_IN) // Notify endpoint
// The interface index of an interface starting from 0
#define UDI_CDC_COMM_IFACE_NUMBER_0 X+0
#define UDI_CDC_DATA_IFACE_NUMBER_0 X+1 \endcode
// The endpoint numbers starting from 1.
#define UDI_CDC_DATA_EP_IN_0 (1 | USB_EP_DIR_IN) // TX
#define UDI_CDC_DATA_EP_OUT_0 (2 | USB_EP_DIR_OUT) // RX
#define UDI_CDC_COMM_EP_0 (3 | USB_EP_DIR_IN) // Notify endpoint
// The interface index of an interface starting from 0
#define UDI_CDC_COMM_IFACE_NUMBER_0 X+0
#define UDI_CDC_DATA_IFACE_NUMBER_0 X+1 \endcode
* -# Ensure that conf_usb.h contains the following parameters
* required for a USB composite device configuration:
* - \code // USB Interfaces descriptor structure
#define UDI_COMPOSITE_DESC_T \
...
usb_iad_desc_t udi_cdc_iad; \
udi_cdc_comm_desc_t udi_cdc_comm; \
udi_cdc_data_desc_t udi_cdc_data; \
...
// USB Interfaces descriptor value for Full Speed
#define UDI_COMPOSITE_DESC_FS \
...
.udi_cdc_iad = UDI_CDC_IAD_DESC_0, \
.udi_cdc_comm = UDI_CDC_COMM_DESC_0, \
.udi_cdc_data = UDI_CDC_DATA_DESC_0_FS, \
...
// USB Interfaces descriptor value for High Speed
#define UDI_COMPOSITE_DESC_HS \
...
.udi_cdc_iad = UDI_CDC_IAD_DESC_0, \
.udi_cdc_comm = UDI_CDC_COMM_DESC_0, \
.udi_cdc_data = UDI_CDC_DATA_DESC_0_HS, \
...
// USB Interface APIs
#define UDI_COMPOSITE_API \
...
&udi_api_cdc_comm, \
&udi_api_cdc_data, \
... \endcode
#define UDI_COMPOSITE_DESC_T \
...
usb_iad_desc_t udi_cdc_iad; \
udi_cdc_comm_desc_t udi_cdc_comm; \
udi_cdc_data_desc_t udi_cdc_data; \
...
// USB Interfaces descriptor value for Full Speed
#define UDI_COMPOSITE_DESC_FS \
...
.udi_cdc_iad = UDI_CDC_IAD_DESC_0, \
.udi_cdc_comm = UDI_CDC_COMM_DESC_0, \
.udi_cdc_data = UDI_CDC_DATA_DESC_0_FS, \
...
// USB Interfaces descriptor value for High Speed
#define UDI_COMPOSITE_DESC_HS \
...
.udi_cdc_iad = UDI_CDC_IAD_DESC_0, \
.udi_cdc_comm = UDI_CDC_COMM_DESC_0, \
.udi_cdc_data = UDI_CDC_DATA_DESC_0_HS, \
...
// USB Interface APIs
#define UDI_COMPOSITE_API \
...
&udi_api_cdc_comm, \
&udi_api_cdc_data, \
... \endcode
* - \note The descriptors order given in the four lists above must be the
* same as the order defined by all interface indexes. The interface index
* orders are defined through UDI_X_IFACE_NUMBER defines.\n
+2 -2
View File
@@ -51,7 +51,7 @@
#include "udc_desc.h"
#include "udi_cdc.h"
#if DISABLED(SDSUPPORT)
#if !HAS_MEDIA
/**
* \defgroup udi_cdc_group_single_desc USB device descriptors for a single interface
@@ -256,6 +256,6 @@ UDC_DESC_STORAGE udc_config_t udc_config = {
//@}
//@}
#endif // SDSUPPORT
#endif // HAS_MEDIA
#endif // ARDUINO_ARCH_SAM
+2 -2
View File
@@ -50,7 +50,7 @@
#include "udd.h"
#include "udc_desc.h"
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
/**
* \defgroup udi_group_desc Descriptors for a USB Device
@@ -189,4 +189,4 @@ UDC_DESC_STORAGE udc_config_t udc_config = {
#endif // ARDUINO_ARCH_SAM
#endif // SDSUPPORT
#endif // HAS_MEDIA
+41 -105
View File
@@ -57,7 +57,7 @@
#include "ctrl_access.h"
#include <string.h>
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
#ifndef UDI_MSC_NOTIFY_TRANS_EXT
# define UDI_MSC_NOTIFY_TRANS_EXT()
@@ -372,9 +372,7 @@ static void udi_msc_sbc_trans(bool b_read);
//@}
bool udi_msc_enable(void)
{
bool udi_msc_enable(void) {
uint8_t lun;
udi_msc_b_trans_req = false;
udi_msc_b_cbw_invalid = false;
@@ -397,18 +395,14 @@ bool udi_msc_enable(void)
return true;
}
void udi_msc_disable(void)
{
void udi_msc_disable(void) {
udi_msc_b_trans_req = false;
udi_msc_b_ack_trans = true;
udi_msc_b_reset_trans = true;
UDI_MSC_DISABLE_EXT();
}
bool udi_msc_setup(void)
{
bool udi_msc_setup(void) {
if (Udd_setup_is_in()) {
// Requests Interface GET
if (Udd_setup_type() == USB_REQ_TYPE_CLASS) {
@@ -451,17 +445,14 @@ bool udi_msc_setup(void)
return false; // Not supported request
}
uint8_t udi_msc_getsetting(void)
{
uint8_t udi_msc_getsetting(void) {
return 0; // MSC don't have multiple alternate setting
}
// ------------------------
//------- Routines to process CBW packet
static void udi_msc_cbw_invalid(void)
{
static void udi_msc_cbw_invalid(void) {
if (!udi_msc_b_cbw_invalid)
return; // Don't re-stall endpoint if error reset by setup
udd_ep_set_halt(UDI_MSC_EP_OUT);
@@ -469,8 +460,7 @@ static void udi_msc_cbw_invalid(void)
udd_ep_wait_stall_clear(UDI_MSC_EP_OUT, udi_msc_cbw_invalid);
}
static void udi_msc_csw_invalid(void)
{
static void udi_msc_csw_invalid(void) {
if (!udi_msc_b_cbw_invalid)
return; // Don't re-stall endpoint if error reset by setup
udd_ep_set_halt(UDI_MSC_EP_IN);
@@ -478,8 +468,7 @@ static void udi_msc_csw_invalid(void)
udd_ep_wait_stall_clear(UDI_MSC_EP_IN, udi_msc_csw_invalid);
}
static void udi_msc_cbw_wait(void)
{
static void udi_msc_cbw_wait(void) {
// Register buffer and callback on OUT endpoint
if (!udd_ep_run(UDI_MSC_EP_OUT, true,
(uint8_t *) & udi_msc_cbw,
@@ -490,10 +479,8 @@ static void udi_msc_cbw_wait(void)
}
}
static void udi_msc_cbw_received(udd_ep_status_t status,
iram_size_t nb_received, udd_ep_id_t ep)
{
iram_size_t nb_received, udd_ep_id_t ep) {
UNUSED(ep);
// Check status of transfer
if (UDD_EP_TRANSFER_OK != status) {
@@ -582,9 +569,7 @@ static void udi_msc_cbw_received(udd_ep_status_t status,
}
}
static bool udi_msc_cbw_validate(uint32_t alloc_len, uint8_t dir_flag)
{
static bool udi_msc_cbw_validate(uint32_t alloc_len, uint8_t dir_flag) {
/*
* The following cases should result in a phase error:
* - Case 2: Hn < Di
@@ -612,12 +597,10 @@ static bool udi_msc_cbw_validate(uint32_t alloc_len, uint8_t dir_flag)
return true;
}
// ------------------------
//------- Routines to process small data packet
static void udi_msc_data_send(uint8_t * buffer, uint8_t buf_size)
{
static void udi_msc_data_send(uint8_t * buffer, uint8_t buf_size) {
// Sends data on IN endpoint
if (!udd_ep_run(UDI_MSC_EP_IN, true,
buffer, buf_size, udi_msc_data_sent)) {
@@ -627,10 +610,8 @@ static void udi_msc_data_send(uint8_t * buffer, uint8_t buf_size)
}
}
static void udi_msc_data_sent(udd_ep_status_t status, iram_size_t nb_sent,
udd_ep_id_t ep)
{
udd_ep_id_t ep) {
UNUSED(ep);
if (UDD_EP_TRANSFER_OK != status) {
// Error protocol
@@ -644,12 +625,10 @@ static void udi_msc_data_sent(udd_ep_status_t status, iram_size_t nb_sent,
udi_msc_csw_process();
}
// ------------------------
//------- Routines to process CSW packet
static void udi_msc_csw_process(void)
{
static void udi_msc_csw_process(void) {
if (0 != udi_msc_csw.dCSWDataResidue) {
// Residue not NULL
// then STALL next request from USB host on corresponding endpoint
@@ -664,9 +643,7 @@ static void udi_msc_csw_process(void)
udi_msc_csw_send();
}
void udi_msc_csw_send(void)
{
void udi_msc_csw_send(void) {
// Sends CSW on IN endpoint
if (!udd_ep_run(UDI_MSC_EP_IN, false,
(uint8_t *) & udi_msc_csw,
@@ -678,10 +655,8 @@ void udi_msc_csw_send(void)
}
}
static void udi_msc_csw_sent(udd_ep_status_t status, iram_size_t nb_sent,
udd_ep_id_t ep)
{
udd_ep_id_t ep) {
UNUSED(ep);
UNUSED(status);
UNUSED(nb_sent);
@@ -690,20 +665,17 @@ static void udi_msc_csw_sent(udd_ep_status_t status, iram_size_t nb_sent,
udi_msc_cbw_wait();
}
// ------------------------
//------- Routines manage sense data
static void udi_msc_clear_sense(void)
{
static void udi_msc_clear_sense(void) {
memset((uint8_t*)&udi_msc_sense, 0, sizeof(struct scsi_request_sense_data));
udi_msc_sense.valid_reponse_code = SCSI_SENSE_VALID | SCSI_SENSE_CURRENT;
udi_msc_sense.AddSenseLen = SCSI_SENSE_ADDL_LEN(sizeof(udi_msc_sense));
}
static void udi_msc_sense_fail(uint8_t sense_key, uint16_t add_sense,
uint32_t lba)
{
uint32_t lba) {
udi_msc_clear_sense();
udi_msc_csw.bCSWStatus = USB_CSW_STATUS_FAIL;
udi_msc_sense.sense_flag_key = sense_key;
@@ -715,53 +687,39 @@ static void udi_msc_sense_fail(uint8_t sense_key, uint16_t add_sense,
udi_msc_sense.AddSnsCodeQlfr = add_sense;
}
static void udi_msc_sense_pass(void)
{
static void udi_msc_sense_pass(void) {
udi_msc_clear_sense();
udi_msc_csw.bCSWStatus = USB_CSW_STATUS_PASS;
}
static void udi_msc_sense_fail_not_present(void)
{
static void udi_msc_sense_fail_not_present(void) {
udi_msc_sense_fail(SCSI_SK_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT, 0);
}
static void udi_msc_sense_fail_busy_or_change(void)
{
udi_msc_sense_fail(SCSI_SK_UNIT_ATTENTION,
SCSI_ASC_NOT_READY_TO_READY_CHANGE, 0);
static void udi_msc_sense_fail_busy_or_change(void) {
udi_msc_sense_fail(SCSI_SK_UNIT_ATTENTION, SCSI_ASC_NOT_READY_TO_READY_CHANGE, 0);
}
static void udi_msc_sense_fail_hardware(void)
{
udi_msc_sense_fail(SCSI_SK_HARDWARE_ERROR,
SCSI_ASC_NO_ADDITIONAL_SENSE_INFO, 0);
static void udi_msc_sense_fail_hardware(void) {
udi_msc_sense_fail(SCSI_SK_HARDWARE_ERROR, SCSI_ASC_NO_ADDITIONAL_SENSE_INFO, 0);
}
static void udi_msc_sense_fail_protected(void)
{
static void udi_msc_sense_fail_protected(void) {
udi_msc_sense_fail(SCSI_SK_DATA_PROTECT, SCSI_ASC_WRITE_PROTECTED, 0);
}
static void udi_msc_sense_fail_cdb_invalid(void)
{
udi_msc_sense_fail(SCSI_SK_ILLEGAL_REQUEST,
SCSI_ASC_INVALID_FIELD_IN_CDB, 0);
static void udi_msc_sense_fail_cdb_invalid(void) {
udi_msc_sense_fail(SCSI_SK_ILLEGAL_REQUEST, SCSI_ASC_INVALID_FIELD_IN_CDB, 0);
}
static void udi_msc_sense_command_invalid(void)
{
udi_msc_sense_fail(SCSI_SK_ILLEGAL_REQUEST,
SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 0);
static void udi_msc_sense_command_invalid(void) {
udi_msc_sense_fail(SCSI_SK_ILLEGAL_REQUEST, SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 0);
}
// ------------------------
//------- Routines manage SCSI Commands
static void udi_msc_spc_requestsense(void)
{
static void udi_msc_spc_requestsense(void) {
uint8_t length = udi_msc_cbw.CDB[4];
// Can't send more than sense data length
@@ -774,9 +732,7 @@ static void udi_msc_spc_requestsense(void)
udi_msc_data_send((uint8_t*)&udi_msc_sense, length);
}
static void udi_msc_spc_inquiry(void)
{
static void udi_msc_spc_inquiry(void) {
uint8_t length, i;
UDC_DATA(4)
// Constant inquiry data for all LUNs
@@ -835,9 +791,7 @@ static void udi_msc_spc_inquiry(void)
udi_msc_data_send((uint8_t *) & udi_msc_inquiry_data, length);
}
static bool udi_msc_spc_testunitready_global(void)
{
static bool udi_msc_spc_testunitready_global(void) {
switch (mem_test_unit_ready(udi_msc_cbw.bCBWLUN)) {
case CTRL_GOOD:
return true; // Don't change sense data
@@ -855,9 +809,7 @@ static bool udi_msc_spc_testunitready_global(void)
return false;
}
static void udi_msc_spc_testunitready(void)
{
static void udi_msc_spc_testunitready(void) {
if (udi_msc_spc_testunitready_global()) {
// LUN ready, then update sense data with status pass
udi_msc_sense_pass();
@@ -866,9 +818,7 @@ static void udi_msc_spc_testunitready(void)
udi_msc_csw_process();
}
static void udi_msc_spc_mode_sense(bool b_sense10)
{
static void udi_msc_spc_mode_sense(bool b_sense10) {
// Union of all mode sense structures
union sense_6_10 {
struct {
@@ -943,9 +893,7 @@ static void udi_msc_spc_mode_sense(bool b_sense10)
udi_msc_data_send((uint8_t *) & sense, request_lgt);
}
static void udi_msc_spc_prevent_allow_medium_removal(void)
{
static void udi_msc_spc_prevent_allow_medium_removal(void) {
uint8_t prevent = udi_msc_cbw.CDB[4];
if (0 == prevent) {
udi_msc_sense_pass();
@@ -955,9 +903,7 @@ static void udi_msc_spc_prevent_allow_medium_removal(void)
udi_msc_csw_process();
}
static void udi_msc_sbc_start_stop(void)
{
static void udi_msc_sbc_start_stop(void) {
bool start = 0x1 & udi_msc_cbw.CDB[4];
bool loej = 0x2 & udi_msc_cbw.CDB[4];
if (loej) {
@@ -967,9 +913,7 @@ static void udi_msc_sbc_start_stop(void)
udi_msc_csw_process();
}
static void udi_msc_sbc_read_capacity(void)
{
static void udi_msc_sbc_read_capacity(void) {
UDC_BSS(4) static struct sbc_read_capacity10_data udi_msc_capacity;
if (!udi_msc_cbw_validate(sizeof(udi_msc_capacity),
@@ -1003,9 +947,7 @@ static void udi_msc_sbc_read_capacity(void)
sizeof(udi_msc_capacity));
}
static void udi_msc_sbc_trans(bool b_read)
{
static void udi_msc_sbc_trans(bool b_read) {
uint32_t trans_size;
if (!b_read) {
@@ -1038,9 +980,7 @@ static void udi_msc_sbc_trans(bool b_read)
UDI_MSC_NOTIFY_TRANS_EXT();
}
bool udi_msc_process_trans(void)
{
bool udi_msc_process_trans(void) {
Ctrl_status status;
if (!udi_msc_b_trans_req)
@@ -1084,10 +1024,8 @@ bool udi_msc_process_trans(void)
return true;
}
static void udi_msc_trans_ack(udd_ep_status_t status, iram_size_t n,
udd_ep_id_t ep)
{
udd_ep_id_t ep) {
UNUSED(ep);
UNUSED(n);
// Update variable to signal the end of transfer
@@ -1095,10 +1033,8 @@ static void udi_msc_trans_ack(udd_ep_status_t status, iram_size_t n,
udi_msc_b_ack_trans = true;
}
bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
void (*callback) (udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep))
{
void (*callback) (udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep)) {
if (!udi_msc_b_ack_trans)
return false; // No possible, transfer on going
@@ -1127,6 +1063,6 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
//@}
#endif // SDSUPPORT
#endif // HAS_MEDIA
#endif // ARDUINO_ARCH_SAM
+111 -116
View File
@@ -77,9 +77,9 @@ extern UDC_DESC_STORAGE udi_api_t udi_api_msc;
//! Interface descriptor structure for MSC
typedef struct {
usb_iface_desc_t iface;
usb_ep_desc_t ep_in;
usb_ep_desc_t ep_out;
usb_iface_desc_t iface;
usb_ep_desc_t ep_in;
usb_ep_desc_t ep_out;
} udi_msc_desc_t;
//! By default no string associated to this interface
@@ -94,32 +94,32 @@ typedef struct {
//! Content of MSC interface descriptor for all speeds
#define UDI_MSC_DESC \
.iface.bLength = sizeof(usb_iface_desc_t),\
.iface.bDescriptorType = USB_DT_INTERFACE,\
.iface.bInterfaceNumber = UDI_MSC_IFACE_NUMBER,\
.iface.bAlternateSetting = 0,\
.iface.bNumEndpoints = 2,\
.iface.bInterfaceClass = MSC_CLASS,\
.iface.bInterfaceSubClass = MSC_SUBCLASS_TRANSPARENT,\
.iface.bInterfaceProtocol = MSC_PROTOCOL_BULK,\
.iface.iInterface = UDI_MSC_STRING_ID,\
.ep_in.bLength = sizeof(usb_ep_desc_t),\
.ep_in.bDescriptorType = USB_DT_ENDPOINT,\
.ep_in.bEndpointAddress = UDI_MSC_EP_IN,\
.ep_in.bmAttributes = USB_EP_TYPE_BULK,\
.ep_in.bInterval = 0,\
.ep_out.bLength = sizeof(usb_ep_desc_t),\
.ep_out.bDescriptorType = USB_DT_ENDPOINT,\
.ep_out.bEndpointAddress = UDI_MSC_EP_OUT,\
.ep_out.bmAttributes = USB_EP_TYPE_BULK,\
.ep_out.bInterval = 0,
.iface.bLength = sizeof(usb_iface_desc_t),\
.iface.bDescriptorType = USB_DT_INTERFACE,\
.iface.bInterfaceNumber = UDI_MSC_IFACE_NUMBER,\
.iface.bAlternateSetting = 0,\
.iface.bNumEndpoints = 2,\
.iface.bInterfaceClass = MSC_CLASS,\
.iface.bInterfaceSubClass = MSC_SUBCLASS_TRANSPARENT,\
.iface.bInterfaceProtocol = MSC_PROTOCOL_BULK,\
.iface.iInterface = UDI_MSC_STRING_ID,\
.ep_in.bLength = sizeof(usb_ep_desc_t),\
.ep_in.bDescriptorType = USB_DT_ENDPOINT,\
.ep_in.bEndpointAddress = UDI_MSC_EP_IN,\
.ep_in.bmAttributes = USB_EP_TYPE_BULK,\
.ep_in.bInterval = 0,\
.ep_out.bLength = sizeof(usb_ep_desc_t),\
.ep_out.bDescriptorType = USB_DT_ENDPOINT,\
.ep_out.bEndpointAddress = UDI_MSC_EP_OUT,\
.ep_out.bmAttributes = USB_EP_TYPE_BULK,\
.ep_out.bInterval = 0,
//! Content of MSC interface descriptor for full speed only
#define UDI_MSC_DESC_FS {\
UDI_MSC_DESC \
.ep_in.wMaxPacketSize = LE16(UDI_MSC_EPS_SIZE_FS),\
.ep_out.wMaxPacketSize = LE16(UDI_MSC_EPS_SIZE_FS),\
}
UDI_MSC_DESC \
.ep_in.wMaxPacketSize = LE16(UDI_MSC_EPS_SIZE_FS),\
.ep_out.wMaxPacketSize = LE16(UDI_MSC_EPS_SIZE_FS),\
}
//! Content of MSC interface descriptor for high speed only
#define UDI_MSC_DESC_HS {\
@@ -129,7 +129,6 @@ typedef struct {
}
//@}
/**
* \ingroup udi_group
* \defgroup udi_msc_group USB Device Interface (UDI) for Mass Storage Class (MSC)
@@ -163,14 +162,13 @@ bool udi_msc_process_trans(void);
* \return \c 1 if function was successfully done, otherwise \c 0.
*/
bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
void (*callback) (udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep));
void (*callback) (udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep));
//@}
#ifdef __cplusplus
}
#endif
/**
* \page udi_msc_quickstart Quick start guide for USB device Mass Storage module (UDI MSC)
*
@@ -200,35 +198,32 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
* \subsection udi_msc_basic_use_case_usage_code Example code
* Content of conf_usb.h:
* \code
#define USB_DEVICE_SERIAL_NAME "12...EF" // Disk SN for MSC
#define UDI_MSC_GLOBAL_VENDOR_ID \
'A', 'T', 'M', 'E', 'L', ' ', ' ', ' '
#define UDI_MSC_GLOBAL_PRODUCT_VERSION \
'1', '.', '0', '0'
#define UDI_MSC_ENABLE_EXT() my_callback_msc_enable()
extern bool my_callback_msc_enable(void);
#define UDI_MSC_DISABLE_EXT() my_callback_msc_disable()
extern void my_callback_msc_disable(void);
#include "udi_msc_conf.h" // At the end of conf_usb.h file
#define USB_DEVICE_SERIAL_NAME "12...EF" // Disk SN for MSC
#define UDI_MSC_GLOBAL_VENDOR_ID \
'A', 'T', 'M', 'E', 'L', ' ', ' ', ' '
#define UDI_MSC_GLOBAL_PRODUCT_VERSION \
'1', '.', '0', '0'
#define UDI_MSC_ENABLE_EXT() my_callback_msc_enable()
extern bool my_callback_msc_enable(void);
#define UDI_MSC_DISABLE_EXT() my_callback_msc_disable()
extern void my_callback_msc_disable(void);
#include "udi_msc_conf.h" // At the end of conf_usb.h file
\endcode
*
* Add to application C-file:
* \code
static bool my_flag_autorize_msc_transfert = false;
bool my_callback_msc_enable(void)
{
my_flag_autorize_msc_transfert = true;
return true;
}
void my_callback_msc_disable(void)
{
my_flag_autorize_msc_transfert = false;
}
static bool my_flag_autorize_msc_transfert = false;
bool my_callback_msc_enable(void) {
my_flag_autorize_msc_transfert = true;
return true;
}
void my_callback_msc_disable(void) {
my_flag_autorize_msc_transfert = false;
}
void task(void)
{
udi_msc_process_trans();
}
void task(void) {
udi_msc_process_trans();
}
\endcode
*
* \subsection udi_msc_basic_use_case_setup_flow Workflow
@@ -237,14 +232,14 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
* - \code #define USB_DEVICE_SERIAL_NAME "12...EF" // Disk SN for MSC \endcode
* \note The USB serial number is mandatory when a MSC interface is used.
* - \code //! Vendor name and Product version of MSC interface
#define UDI_MSC_GLOBAL_VENDOR_ID \
'A', 'T', 'M', 'E', 'L', ' ', ' ', ' '
#define UDI_MSC_GLOBAL_PRODUCT_VERSION \
'1', '.', '0', '0' \endcode
#define UDI_MSC_GLOBAL_VENDOR_ID \
'A', 'T', 'M', 'E', 'L', ' ', ' ', ' '
#define UDI_MSC_GLOBAL_PRODUCT_VERSION \
'1', '.', '0', '0' \endcode
* \note The USB MSC interface requires a vendor ID (8 ASCII characters)
* and a product version (4 ASCII characters).
* - \code #define UDI_MSC_ENABLE_EXT() my_callback_msc_enable()
extern bool my_callback_msc_enable(void); \endcode
extern bool my_callback_msc_enable(void); \endcode
* \note After the device enumeration (detecting and identifying USB devices),
* the USB host starts the device configuration. When the USB MSC interface
* from the device is accepted by the host, the USB host enables this interface and the
@@ -252,7 +247,7 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
* Thus, when this event is received, the tasks which call
* udi_msc_process_trans() must be enabled.
* - \code #define UDI_MSC_DISABLE_EXT() my_callback_msc_disable()
extern void my_callback_msc_disable(void); \endcode
extern void my_callback_msc_disable(void); \endcode
* \note When the USB device is unplugged or is reset by the USB host, the USB
* interface is disabled and the UDI_MSC_DISABLE_EXT() callback function
* is called. Thus, it is recommended to disable the task which is called udi_msc_process_trans().
@@ -261,15 +256,15 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
* must be done outside USB interrupt routine. This is done in the MSC process
* ("udi_msc_process_trans()") called by main loop:
* - \code * void task(void) {
udi_msc_process_trans();
} \endcode
udi_msc_process_trans();
} \endcode
* -# The MSC speed depends on task periodicity. To get the best speed
* the notification callback "UDI_MSC_NOTIFY_TRANS_EXT" can be used to wakeup
* this task (Example, through a mutex):
* - \code #define UDI_MSC_NOTIFY_TRANS_EXT() msc_notify_trans()
void msc_notify_trans(void) {
wakeup_my_task();
} \endcode
void msc_notify_trans(void) {
wakeup_my_task();
} \endcode
*
* \section udi_msc_use_cases Advanced use cases
* For more advanced use of the UDI MSC module, see the following use cases:
@@ -302,72 +297,72 @@ bool udi_msc_trans_block(bool b_read, uint8_t * block, iram_size_t block_size,
* \subsection udi_msc_use_case_composite_usage_code Example code
* Content of conf_usb.h:
* \code
#define USB_DEVICE_EP_CTRL_SIZE 64
#define USB_DEVICE_NB_INTERFACE (X+1)
#define USB_DEVICE_MAX_EP (X+2)
#define USB_DEVICE_EP_CTRL_SIZE 64
#define USB_DEVICE_NB_INTERFACE (X+1)
#define USB_DEVICE_MAX_EP (X+2)
#define UDI_MSC_EP_IN (X | USB_EP_DIR_IN)
#define UDI_MSC_EP_OUT (Y | USB_EP_DIR_OUT)
#define UDI_MSC_IFACE_NUMBER X
#define UDI_MSC_EP_IN (X | USB_EP_DIR_IN)
#define UDI_MSC_EP_OUT (Y | USB_EP_DIR_OUT)
#define UDI_MSC_IFACE_NUMBER X
#define UDI_COMPOSITE_DESC_T \
udi_msc_desc_t udi_msc; \
...
#define UDI_COMPOSITE_DESC_FS \
.udi_msc = UDI_MSC_DESC, \
...
#define UDI_COMPOSITE_DESC_HS \
.udi_msc = UDI_MSC_DESC, \
...
#define UDI_COMPOSITE_API \
&udi_api_msc, \
...
#define UDI_COMPOSITE_DESC_T \
udi_msc_desc_t udi_msc; \
...
#define UDI_COMPOSITE_DESC_FS \
.udi_msc = UDI_MSC_DESC, \
...
#define UDI_COMPOSITE_DESC_HS \
.udi_msc = UDI_MSC_DESC, \
...
#define UDI_COMPOSITE_API \
&udi_api_msc, \
...
\endcode
*
* \subsection udi_msc_use_case_composite_usage_flow Workflow
* -# Ensure that conf_usb.h is available and contains the following parameters
* required for a USB composite device configuration:
* - \code // Endpoint control size, This must be:
// - 8, 16, 32 or 64 for full speed device (8 is recommended to save RAM)
// - 64 for a high speed device
#define USB_DEVICE_EP_CTRL_SIZE 64
// Total Number of interfaces on this USB device.
// Add 1 for MSC.
#define USB_DEVICE_NB_INTERFACE (X+1)
// Total number of endpoints on this USB device.
// This must include each endpoint for each interface.
// Add 2 for MSC.
#define USB_DEVICE_MAX_EP (X+2) \endcode
// - 8, 16, 32 or 64 for full speed device (8 is recommended to save RAM)
// - 64 for a high speed device
#define USB_DEVICE_EP_CTRL_SIZE 64
// Total Number of interfaces on this USB device.
// Add 1 for MSC.
#define USB_DEVICE_NB_INTERFACE (X+1)
// Total number of endpoints on this USB device.
// This must include each endpoint for each interface.
// Add 2 for MSC.
#define USB_DEVICE_MAX_EP (X+2) \endcode
* -# Ensure that conf_usb.h contains the description of
* composite device:
* - \code // The endpoint numbers chosen by you for the MSC.
// The endpoint numbers starting from 1.
#define UDI_MSC_EP_IN (X | USB_EP_DIR_IN)
#define UDI_MSC_EP_OUT (Y | USB_EP_DIR_OUT)
// The interface index of an interface starting from 0
#define UDI_MSC_IFACE_NUMBER X \endcode
// The endpoint numbers starting from 1.
#define UDI_MSC_EP_IN (X | USB_EP_DIR_IN)
#define UDI_MSC_EP_OUT (Y | USB_EP_DIR_OUT)
// The interface index of an interface starting from 0
#define UDI_MSC_IFACE_NUMBER X \endcode
* -# Ensure that conf_usb.h contains the following parameters
* required for a USB composite device configuration:
* - \code // USB Interfaces descriptor structure
#define UDI_COMPOSITE_DESC_T \
...
udi_msc_desc_t udi_msc; \
...
// USB Interfaces descriptor value for Full Speed
#define UDI_COMPOSITE_DESC_FS \
...
.udi_msc = UDI_MSC_DESC_FS, \
...
// USB Interfaces descriptor value for High Speed
#define UDI_COMPOSITE_DESC_HS \
...
.udi_msc = UDI_MSC_DESC_HS, \
...
// USB Interface APIs
#define UDI_COMPOSITE_API \
...
&udi_api_msc, \
... \endcode
#define UDI_COMPOSITE_DESC_T \
...
udi_msc_desc_t udi_msc; \
...
// USB Interfaces descriptor value for Full Speed
#define UDI_COMPOSITE_DESC_FS \
...
.udi_msc = UDI_MSC_DESC_FS, \
...
// USB Interfaces descriptor value for High Speed
#define UDI_COMPOSITE_DESC_HS \
...
.udi_msc = UDI_MSC_DESC_HS, \
...
// USB Interface APIs
#define UDI_COMPOSITE_API \
...
&udi_api_msc, \
... \endcode
* - \note The descriptors order given in the four lists above must be the
* same as the order defined by all interface indexes. The interface index
* orders are defined through UDI_X_IFACE_NUMBER defines.
+70 -9
View File
@@ -116,6 +116,23 @@
//#define dbg_print printf
#define dbg_print(...)
// Marlin modification: Redefine the otg_freeze_clock and otg_unfreeze_clock macros
// to add memory barriers to ensure that any accesses to USB registers aren't re-ordered
// to occur while the clock is frozen.
#undef otg_freeze_clock
#undef otg_unfreeze_clock
#define otg_freeze_clock() do { \
__DSB(); \
Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_FRZCLK); \
} while (0)
#define otg_unfreeze_clock() \
do { \
Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_FRZCLK); \
__DSB(); \
} while (0)
/**
* \ingroup udd_group
* \defgroup udd_udphs_group USB On-The-Go High-Speed Port for device mode (UOTGHS)
@@ -611,6 +628,18 @@ ISR(UDD_USB_INT_FUN)
// The wakeup interrupt is automatic acked when a suspend occur
udd_disable_wake_up_interrupt();
udd_enable_suspend_interrupt();
// Marlin modification: The RESET, SOF, and MSOF interrupts were previously
// enabled in udd_attach, which caused a race condition where they could
// be raised and unclearable with the clock is frozen. They are now
// enabled here, after the clock has been unfrozen in response to the wake
// interrupt.
udd_enable_reset_interrupt();
udd_enable_sof_interrupt();
#ifdef USB_DEVICE_HS_SUPPORT
udd_enable_msof_interrupt();
#endif
udd_sleep_mode(true); // Enter in IDLE mode
#ifdef UDC_RESUME_EVENT
UDC_RESUME_EVENT();
@@ -776,6 +805,27 @@ void udd_disable(void)
cpu_irq_restore(flags);
}
// Marlin modification: The original implementation did not use a memory
// barrier between disabling and clearing interrupts. This sometimes
// allowed interrupts to remain raised and unclearable after the clock
// was frozen. This helper was added to ensure that memory barriers
// are used consistently from all places where interrupts are disabled.
static void disable_and_ack_sync_interrupts()
{
// Disable USB line events
udd_disable_reset_interrupt();
udd_disable_sof_interrupt();
#ifdef USB_DEVICE_HS_SUPPORT
udd_disable_msof_interrupt();
#endif
__DSB();
udd_ack_reset();
udd_ack_sof();
#ifdef USB_DEVICE_HS_SUPPORT
udd_ack_msof();
#endif
__DSB();
}
void udd_attach(void)
{
@@ -796,17 +846,16 @@ void udd_attach(void)
udd_attach_device();
// Enable USB line events
udd_enable_reset_interrupt();
udd_enable_suspend_interrupt();
udd_enable_wake_up_interrupt();
udd_enable_sof_interrupt();
#ifdef USB_DEVICE_HS_SUPPORT
udd_enable_msof_interrupt();
#endif
// Reset following interrupts flag
udd_ack_reset();
udd_ack_sof();
udd_ack_msof();
// Marlin modification: The RESET, SOF, and MSOF interrupts were previously
// enabled here, which caused a race condition where they could be raised
// and unclearable with the clock is frozen. They are now enabled in the
// wake interrupt handler, after the clock has been unfrozen. They are now
// explicitly disabled here to ensure that they cannot be raised before
// the clock is frozen.
disable_and_ack_sync_interrupts();
// The first suspend interrupt must be forced
// The first suspend interrupt is not detected else raise it
@@ -824,6 +873,12 @@ void udd_detach(void)
// Detach device from the bus
udd_detach_device();
// Marlin modification: Added the explicit disabling of the RESET, SOF, and
// MSOF interrupts here, to ensure that they cannot be raised after the
// clock is frozen.
disable_and_ack_sync_interrupts();
otg_freeze_clock();
udd_sleep_mode(false);
}
@@ -2043,6 +2098,12 @@ static bool udd_ep_interrupt(void)
dbg_print("I ");
udd_disable_in_send_interrupt(ep);
// One bank is free then send a ZLP
// Marlin modification: Add a barrier to ensure in_send is disabled
// before it is cleared. This was not an observed problem, but
// other interrupts were seen to misbehave without this barrier.
__DSB();
udd_ack_in_send(ep);
udd_ack_fifocon(ep);
udd_ep_finish_job(ptr_job, false, ep);
+13 -14
View File
@@ -127,13 +127,13 @@ void otg_dual_disable(void);
//! These macros allows to enable/disable pad and UOTGHS hardware
//! @{
//! Reset USB macro
#define otg_reset() \
do { \
UOTGHS->UOTGHS_CTRL = 0; \
while( UOTGHS->UOTGHS_SR & 0x3FFF) {\
UOTGHS->UOTGHS_SCR = 0xFFFFFFFF;\
} \
} while (0)
#define otg_reset() \
do { \
UOTGHS->UOTGHS_CTRL = 0; \
while( UOTGHS->UOTGHS_SR & 0x3FFF) { \
UOTGHS->UOTGHS_SCR = 0xFFFFFFFF; \
} \
} while (0)
//! Enable USB macro
#define otg_enable() (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_USBE))
//! Disable USB macro
@@ -157,15 +157,14 @@ void otg_dual_disable(void);
//! Configure time-out of specified OTG timer
#define otg_configure_timeout(timer, timeout) (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK),\
Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMPAGE_Msk, timer),\
Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMVALUE_Msk, timeout),\
Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK))
Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMPAGE_Msk, timer),\
Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMVALUE_Msk, timeout),\
Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK))
//! Get configured time-out of specified OTG timer
#define otg_get_timeout(timer) (Set_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK),\
Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMPAGE_Msk, timer),\
Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK),\
Rd_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMVALUE_Msk))
Wr_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMPAGE_Msk, timer),\
Clr_bits(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_UNLOCK),\
Rd_bitfield(UOTGHS->UOTGHS_CTRL, UOTGHS_CTRL_TIMVALUE_Msk))
//! Get the dual-role device state of the internal USB finite state machine of the UOTGHS controller
#define otg_get_fsm_drd_state() (Rd_bitfield(UOTGHS->UOTGHS_FSM, UOTGHS_FSM_DRDSTATE_Msk))
+133 -133
View File
@@ -108,17 +108,17 @@
* \brief Standard USB requests (bRequest)
*/
enum usb_reqid {
USB_REQ_GET_STATUS = 0,
USB_REQ_CLEAR_FEATURE = 1,
USB_REQ_SET_FEATURE = 3,
USB_REQ_SET_ADDRESS = 5,
USB_REQ_GET_DESCRIPTOR = 6,
USB_REQ_SET_DESCRIPTOR = 7,
USB_REQ_GET_CONFIGURATION = 8,
USB_REQ_SET_CONFIGURATION = 9,
USB_REQ_GET_INTERFACE = 10,
USB_REQ_SET_INTERFACE = 11,
USB_REQ_SYNCH_FRAME = 12,
USB_REQ_GET_STATUS = 0,
USB_REQ_CLEAR_FEATURE = 1,
USB_REQ_SET_FEATURE = 3,
USB_REQ_SET_ADDRESS = 5,
USB_REQ_GET_DESCRIPTOR = 6,
USB_REQ_SET_DESCRIPTOR = 7,
USB_REQ_GET_CONFIGURATION = 8,
USB_REQ_SET_CONFIGURATION = 9,
USB_REQ_GET_INTERFACE = 10,
USB_REQ_SET_INTERFACE = 11,
USB_REQ_SYNCH_FRAME = 12,
};
/**
@@ -126,9 +126,9 @@ enum usb_reqid {
*
*/
enum usb_device_status {
USB_DEV_STATUS_BUS_POWERED = 0,
USB_DEV_STATUS_SELF_POWERED = 1,
USB_DEV_STATUS_REMOTEWAKEUP = 2
USB_DEV_STATUS_BUS_POWERED = 0,
USB_DEV_STATUS_SELF_POWERED = 1,
USB_DEV_STATUS_REMOTEWAKEUP = 2
};
/**
@@ -136,7 +136,7 @@ enum usb_device_status {
*
*/
enum usb_interface_status {
USB_IFACE_STATUS_RESERVED = 0
USB_IFACE_STATUS_RESERVED = 0
};
/**
@@ -144,7 +144,7 @@ enum usb_interface_status {
*
*/
enum usb_endpoint_status {
USB_EP_STATUS_HALTED = 1,
USB_EP_STATUS_HALTED = 1,
};
/**
@@ -153,11 +153,11 @@ enum usb_endpoint_status {
* \note valid for SetFeature request.
*/
enum usb_device_feature {
USB_DEV_FEATURE_REMOTE_WAKEUP = 1, //!< Remote wakeup enabled
USB_DEV_FEATURE_TEST_MODE = 2, //!< USB test mode
USB_DEV_FEATURE_OTG_B_HNP_ENABLE = 3,
USB_DEV_FEATURE_OTG_A_HNP_SUPPORT = 4,
USB_DEV_FEATURE_OTG_A_ALT_HNP_SUPPORT = 5
USB_DEV_FEATURE_REMOTE_WAKEUP = 1, //!< Remote wakeup enabled
USB_DEV_FEATURE_TEST_MODE = 2, //!< USB test mode
USB_DEV_FEATURE_OTG_B_HNP_ENABLE = 3,
USB_DEV_FEATURE_OTG_A_HNP_SUPPORT = 4,
USB_DEV_FEATURE_OTG_A_ALT_HNP_SUPPORT = 5
};
/**
@@ -166,54 +166,54 @@ enum usb_device_feature {
* \note valid for USB_DEV_FEATURE_TEST_MODE request.
*/
enum usb_device_hs_test_mode {
USB_DEV_TEST_MODE_J = 1,
USB_DEV_TEST_MODE_K = 2,
USB_DEV_TEST_MODE_SE0_NAK = 3,
USB_DEV_TEST_MODE_PACKET = 4,
USB_DEV_TEST_MODE_FORCE_ENABLE = 5,
USB_DEV_TEST_MODE_J = 1,
USB_DEV_TEST_MODE_K = 2,
USB_DEV_TEST_MODE_SE0_NAK = 3,
USB_DEV_TEST_MODE_PACKET = 4,
USB_DEV_TEST_MODE_FORCE_ENABLE = 5,
};
/**
* \brief Standard USB endpoint feature/status flags
*/
enum usb_endpoint_feature {
USB_EP_FEATURE_HALT = 0,
USB_EP_FEATURE_HALT = 0,
};
/**
* \brief Standard USB Test Mode Selectors
*/
enum usb_test_mode_selector {
USB_TEST_J = 0x01,
USB_TEST_K = 0x02,
USB_TEST_SE0_NAK = 0x03,
USB_TEST_PACKET = 0x04,
USB_TEST_FORCE_ENABLE = 0x05,
USB_TEST_J = 0x01,
USB_TEST_K = 0x02,
USB_TEST_SE0_NAK = 0x03,
USB_TEST_PACKET = 0x04,
USB_TEST_FORCE_ENABLE = 0x05,
};
/**
* \brief Standard USB descriptor types
*/
enum usb_descriptor_type {
USB_DT_DEVICE = 1,
USB_DT_CONFIGURATION = 2,
USB_DT_STRING = 3,
USB_DT_INTERFACE = 4,
USB_DT_ENDPOINT = 5,
USB_DT_DEVICE_QUALIFIER = 6,
USB_DT_OTHER_SPEED_CONFIGURATION = 7,
USB_DT_INTERFACE_POWER = 8,
USB_DT_OTG = 9,
USB_DT_IAD = 0x0B,
USB_DT_BOS = 0x0F,
USB_DT_DEVICE_CAPABILITY = 0x10,
USB_DT_DEVICE = 1,
USB_DT_CONFIGURATION = 2,
USB_DT_STRING = 3,
USB_DT_INTERFACE = 4,
USB_DT_ENDPOINT = 5,
USB_DT_DEVICE_QUALIFIER = 6,
USB_DT_OTHER_SPEED_CONFIGURATION = 7,
USB_DT_INTERFACE_POWER = 8,
USB_DT_OTG = 9,
USB_DT_IAD = 0x0B,
USB_DT_BOS = 0x0F,
USB_DT_DEVICE_CAPABILITY = 0x10,
};
/**
* \brief USB Device Capability types
*/
enum usb_capability_type {
USB_DC_USB20_EXTENSION = 0x02,
USB_DC_USB20_EXTENSION = 0x02,
};
/**
@@ -221,7 +221,7 @@ enum usb_capability_type {
* To fill bmAttributes field of usb_capa_ext_desc_t structure.
*/
enum usb_capability_extension_attr {
USB_DC_EXT_LPM = 0x00000002,
USB_DC_EXT_LPM = 0x00000002,
};
#define HIRD_50_US 0
@@ -254,18 +254,18 @@ enum usb_capability_extension_attr {
* \brief Standard USB endpoint transfer types
*/
enum usb_ep_type {
USB_EP_TYPE_CONTROL = 0x00,
USB_EP_TYPE_ISOCHRONOUS = 0x01,
USB_EP_TYPE_BULK = 0x02,
USB_EP_TYPE_INTERRUPT = 0x03,
USB_EP_TYPE_MASK = 0x03,
USB_EP_TYPE_CONTROL = 0x00,
USB_EP_TYPE_ISOCHRONOUS = 0x01,
USB_EP_TYPE_BULK = 0x02,
USB_EP_TYPE_INTERRUPT = 0x03,
USB_EP_TYPE_MASK = 0x03,
};
/**
* \brief Standard USB language IDs for string descriptors
*/
enum usb_langid {
USB_LANGID_EN_US = 0x0409, //!< English (United States)
USB_LANGID_EN_US = 0x0409, //!< English (United States)
};
/**
@@ -308,31 +308,31 @@ COMPILER_PACK_SET(1)
* The data payload of SETUP packets always follows this structure.
*/
typedef struct {
uint8_t bmRequestType;
uint8_t bRequest;
le16_t wValue;
le16_t wIndex;
le16_t wLength;
uint8_t bmRequestType;
uint8_t bRequest;
le16_t wValue;
le16_t wIndex;
le16_t wLength;
} usb_setup_req_t;
/**
* \brief Standard USB device descriptor structure
*/
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
le16_t bcdUSB;
uint8_t bDeviceClass;
uint8_t bDeviceSubClass;
uint8_t bDeviceProtocol;
uint8_t bMaxPacketSize0;
le16_t idVendor;
le16_t idProduct;
le16_t bcdDevice;
uint8_t iManufacturer;
uint8_t iProduct;
uint8_t iSerialNumber;
uint8_t bNumConfigurations;
uint8_t bLength;
uint8_t bDescriptorType;
le16_t bcdUSB;
uint8_t bDeviceClass;
uint8_t bDeviceSubClass;
uint8_t bDeviceProtocol;
uint8_t bMaxPacketSize0;
le16_t idVendor;
le16_t idProduct;
le16_t bcdDevice;
uint8_t iManufacturer;
uint8_t iProduct;
uint8_t iSerialNumber;
uint8_t bNumConfigurations;
} usb_dev_desc_t;
/**
@@ -344,15 +344,15 @@ typedef struct {
* the device was operating at full speed.)
*/
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
le16_t bcdUSB;
uint8_t bDeviceClass;
uint8_t bDeviceSubClass;
uint8_t bDeviceProtocol;
uint8_t bMaxPacketSize0;
uint8_t bNumConfigurations;
uint8_t bReserved;
uint8_t bLength;
uint8_t bDescriptorType;
le16_t bcdUSB;
uint8_t bDeviceClass;
uint8_t bDeviceSubClass;
uint8_t bDeviceProtocol;
uint8_t bMaxPacketSize0;
uint8_t bNumConfigurations;
uint8_t bReserved;
} usb_dev_qual_desc_t;
/**
@@ -368,10 +368,10 @@ typedef struct {
* The descriptor type in the GetDescriptor() request is set to BOS.
*/
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
le16_t wTotalLength;
uint8_t bNumDeviceCaps;
uint8_t bLength;
uint8_t bDescriptorType;
le16_t wTotalLength;
uint8_t bNumDeviceCaps;
} usb_dev_bos_desc_t;
@@ -381,10 +381,10 @@ typedef struct {
* Defines the set of USB 1.1-specific device level capabilities.
*/
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDevCapabilityType;
le32_t bmAttributes;
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bDevCapabilityType;
le32_t bmAttributes;
} usb_dev_capa_ext_desc_t;
/**
@@ -393,22 +393,22 @@ typedef struct {
* The BOS descriptor and capabilities descriptors for LPM.
*/
typedef struct {
usb_dev_bos_desc_t bos;
usb_dev_capa_ext_desc_t capa_ext;
usb_dev_bos_desc_t bos;
usb_dev_capa_ext_desc_t capa_ext;
} usb_dev_lpm_desc_t;
/**
* \brief Standard USB Interface Association Descriptor structure
*/
typedef struct {
uint8_t bLength; //!< size of this descriptor in bytes
uint8_t bDescriptorType; //!< INTERFACE descriptor type
uint8_t bFirstInterface; //!< Number of interface
uint8_t bInterfaceCount; //!< value to select alternate setting
uint8_t bFunctionClass; //!< Class code assigned by the USB
uint8_t bFunctionSubClass;//!< Sub-class code assigned by the USB
uint8_t bFunctionProtocol;//!< Protocol code assigned by the USB
uint8_t iFunction; //!< Index of string descriptor
uint8_t bLength; //!< size of this descriptor in bytes
uint8_t bDescriptorType; //!< INTERFACE descriptor type
uint8_t bFirstInterface; //!< Number of interface
uint8_t bInterfaceCount; //!< value to select alternate setting
uint8_t bFunctionClass; //!< Class code assigned by the USB
uint8_t bFunctionSubClass;//!< Sub-class code assigned by the USB
uint8_t bFunctionProtocol;//!< Protocol code assigned by the USB
uint8_t iFunction; //!< Index of string descriptor
} usb_association_desc_t;
@@ -416,14 +416,14 @@ typedef struct {
* \brief Standard USB configuration descriptor structure
*/
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
le16_t wTotalLength;
uint8_t bNumInterfaces;
uint8_t bConfigurationValue;
uint8_t iConfiguration;
uint8_t bmAttributes;
uint8_t bMaxPower;
uint8_t bLength;
uint8_t bDescriptorType;
le16_t wTotalLength;
uint8_t bNumInterfaces;
uint8_t bConfigurationValue;
uint8_t iConfiguration;
uint8_t bmAttributes;
uint8_t bMaxPower;
} usb_conf_desc_t;
@@ -438,41 +438,41 @@ typedef struct {
* \brief Standard USB association descriptor structure
*/
typedef struct {
uint8_t bLength; //!< Size of this descriptor in bytes
uint8_t bDescriptorType; //!< Interface descriptor type
uint8_t bFirstInterface; //!< Number of interface
uint8_t bInterfaceCount; //!< value to select alternate setting
uint8_t bFunctionClass; //!< Class code assigned by the USB
uint8_t bFunctionSubClass; //!< Sub-class code assigned by the USB
uint8_t bFunctionProtocol; //!< Protocol code assigned by the USB
uint8_t iFunction; //!< Index of string descriptor
uint8_t bLength; //!< Size of this descriptor in bytes
uint8_t bDescriptorType; //!< Interface descriptor type
uint8_t bFirstInterface; //!< Number of interface
uint8_t bInterfaceCount; //!< value to select alternate setting
uint8_t bFunctionClass; //!< Class code assigned by the USB
uint8_t bFunctionSubClass; //!< Sub-class code assigned by the USB
uint8_t bFunctionProtocol; //!< Protocol code assigned by the USB
uint8_t iFunction; //!< Index of string descriptor
} usb_iad_desc_t;
/**
* \brief Standard USB interface descriptor structure
*/
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bInterfaceNumber;
uint8_t bAlternateSetting;
uint8_t bNumEndpoints;
uint8_t bInterfaceClass;
uint8_t bInterfaceSubClass;
uint8_t bInterfaceProtocol;
uint8_t iInterface;
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bInterfaceNumber;
uint8_t bAlternateSetting;
uint8_t bNumEndpoints;
uint8_t bInterfaceClass;
uint8_t bInterfaceSubClass;
uint8_t bInterfaceProtocol;
uint8_t iInterface;
} usb_iface_desc_t;
/**
* \brief Standard USB endpoint descriptor structure
*/
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bEndpointAddress;
uint8_t bmAttributes;
le16_t wMaxPacketSize;
uint8_t bInterval;
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bEndpointAddress;
uint8_t bmAttributes;
le16_t wMaxPacketSize;
uint8_t bInterval;
} usb_ep_desc_t;
@@ -480,13 +480,13 @@ typedef struct {
* \brief A standard USB string descriptor structure
*/
typedef struct {
uint8_t bLength;
uint8_t bDescriptorType;
uint8_t bLength;
uint8_t bDescriptorType;
} usb_str_desc_t;
typedef struct {
usb_str_desc_t desc;
le16_t string[1];
usb_str_desc_t desc;
le16_t string[1];
} usb_str_lgid_desc_t;
COMPILER_PACK_RESET()
+66 -66
View File
@@ -58,42 +58,42 @@
* \name Possible values of class
*/
//@{
#define CDC_CLASS_DEVICE 0x02 //!< USB Communication Device Class
#define CDC_CLASS_COMM 0x02 //!< CDC Communication Class Interface
#define CDC_CLASS_DATA 0x0A //!< CDC Data Class Interface
#define CDC_CLASS_DEVICE 0x02 //!< USB Communication Device Class
#define CDC_CLASS_COMM 0x02 //!< CDC Communication Class Interface
#define CDC_CLASS_DATA 0x0A //!< CDC Data Class Interface
#define CDC_CLASS_MULTI 0xEF //!< CDC Multi-interface Function
//@}
//! \name USB CDC Subclass IDs
//@{
#define CDC_SUBCLASS_DLCM 0x01 //!< Direct Line Control Model
#define CDC_SUBCLASS_ACM 0x02 //!< Abstract Control Model
#define CDC_SUBCLASS_TCM 0x03 //!< Telephone Control Model
#define CDC_SUBCLASS_MCCM 0x04 //!< Multi-Channel Control Model
#define CDC_SUBCLASS_CCM 0x05 //!< CAPI Control Model
#define CDC_SUBCLASS_ETH 0x06 //!< Ethernet Networking Control Model
#define CDC_SUBCLASS_ATM 0x07 //!< ATM Networking Control Model
#define CDC_SUBCLASS_DLCM 0x01 //!< Direct Line Control Model
#define CDC_SUBCLASS_ACM 0x02 //!< Abstract Control Model
#define CDC_SUBCLASS_TCM 0x03 //!< Telephone Control Model
#define CDC_SUBCLASS_MCCM 0x04 //!< Multi-Channel Control Model
#define CDC_SUBCLASS_CCM 0x05 //!< CAPI Control Model
#define CDC_SUBCLASS_ETH 0x06 //!< Ethernet Networking Control Model
#define CDC_SUBCLASS_ATM 0x07 //!< ATM Networking Control Model
//@}
//! \name USB CDC Communication Interface Protocol IDs
//@{
#define CDC_PROTOCOL_V25TER 0x01 //!< Common AT commands
#define CDC_PROTOCOL_V25TER 0x01 //!< Common AT commands
//@}
//! \name USB CDC Data Interface Protocol IDs
//@{
#define CDC_PROTOCOL_I430 0x30 //!< ISDN BRI
#define CDC_PROTOCOL_HDLC 0x31 //!< HDLC
#define CDC_PROTOCOL_TRANS 0x32 //!< Transparent
#define CDC_PROTOCOL_Q921M 0x50 //!< Q.921 management protocol
#define CDC_PROTOCOL_Q921 0x51 //!< Q.931 [sic] Data link protocol
#define CDC_PROTOCOL_Q921TM 0x52 //!< Q.921 TEI-multiplexor
#define CDC_PROTOCOL_V42BIS 0x90 //!< Data compression procedures
#define CDC_PROTOCOL_Q931 0x91 //!< Euro-ISDN protocol control
#define CDC_PROTOCOL_V120 0x92 //!< V.24 rate adaption to ISDN
#define CDC_PROTOCOL_CAPI20 0x93 //!< CAPI Commands
#define CDC_PROTOCOL_HOST 0xFD //!< Host based driver
#define CDC_PROTOCOL_I430 0x30 //!< ISDN BRI
#define CDC_PROTOCOL_HDLC 0x31 //!< HDLC
#define CDC_PROTOCOL_TRANS 0x32 //!< Transparent
#define CDC_PROTOCOL_Q921M 0x50 //!< Q.921 management protocol
#define CDC_PROTOCOL_Q921 0x51 //!< Q.931 [sic] Data link protocol
#define CDC_PROTOCOL_Q921TM 0x52 //!< Q.921 TEI-multiplexor
#define CDC_PROTOCOL_V42BIS 0x90 //!< Data compression procedures
#define CDC_PROTOCOL_Q931 0x91 //!< Euro-ISDN protocol control
#define CDC_PROTOCOL_V120 0x92 //!< V.24 rate adaption to ISDN
#define CDC_PROTOCOL_CAPI20 0x93 //!< CAPI Commands
#define CDC_PROTOCOL_HOST 0xFD //!< Host based driver
/**
* \brief Describes the Protocol Unit Functional Descriptors [sic]
* on Communication Class Interface
@@ -103,16 +103,16 @@
//! \name USB CDC Functional Descriptor Types
//@{
#define CDC_CS_INTERFACE 0x24 //!< Interface Functional Descriptor
#define CDC_CS_ENDPOINT 0x25 //!< Endpoint Functional Descriptor
#define CDC_CS_INTERFACE 0x24 //!< Interface Functional Descriptor
#define CDC_CS_ENDPOINT 0x25 //!< Endpoint Functional Descriptor
//@}
//! \name USB CDC Functional Descriptor Subtypes
//@{
#define CDC_SCS_HEADER 0x00 //!< Header Functional Descriptor
#define CDC_SCS_CALL_MGMT 0x01 //!< Call Management
#define CDC_SCS_ACM 0x02 //!< Abstract Control Management
#define CDC_SCS_UNION 0x06 //!< Union Functional Descriptor
#define CDC_SCS_HEADER 0x00 //!< Header Functional Descriptor
#define CDC_SCS_CALL_MGMT 0x01 //!< Call Management
#define CDC_SCS_ACM 0x02 //!< Abstract Control Management
#define CDC_SCS_UNION 0x06 //!< Union Functional Descriptor
//@}
//! \name USB CDC Request IDs
@@ -171,36 +171,36 @@ COMPILER_PACK_SET(1)
//! CDC Header Functional Descriptor
typedef struct {
uint8_t bFunctionLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubtype;
le16_t bcdCDC;
uint8_t bFunctionLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubtype;
le16_t bcdCDC;
} usb_cdc_hdr_desc_t;
//! CDC Call Management Functional Descriptor
typedef struct {
uint8_t bFunctionLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubtype;
uint8_t bmCapabilities;
uint8_t bDataInterface;
uint8_t bFunctionLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubtype;
uint8_t bmCapabilities;
uint8_t bDataInterface;
} usb_cdc_call_mgmt_desc_t;
//! CDC ACM Functional Descriptor
typedef struct {
uint8_t bFunctionLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubtype;
uint8_t bmCapabilities;
uint8_t bFunctionLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubtype;
uint8_t bmCapabilities;
} usb_cdc_acm_desc_t;
//! CDC Union Functional Descriptor
typedef struct {
uint8_t bFunctionLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubtype;
uint8_t bMasterInterface;
uint8_t bSlaveInterface0;
uint8_t bFunctionLength;
uint8_t bDescriptorType;
uint8_t bDescriptorSubtype;
uint8_t bMasterInterface;
uint8_t bSlaveInterface0;
} usb_cdc_union_desc_t;
@@ -235,24 +235,24 @@ typedef struct {
//@{
//! Line Coding structure
typedef struct {
le32_t dwDTERate;
uint8_t bCharFormat;
uint8_t bParityType;
uint8_t bDataBits;
le32_t dwDTERate;
uint8_t bCharFormat;
uint8_t bParityType;
uint8_t bDataBits;
} usb_cdc_line_coding_t;
//! Possible values of bCharFormat
enum cdc_char_format {
CDC_STOP_BITS_1 = 0, //!< 1 stop bit
CDC_STOP_BITS_1_5 = 1, //!< 1.5 stop bits
CDC_STOP_BITS_2 = 2, //!< 2 stop bits
CDC_STOP_BITS_1 = 0, //!< 1 stop bit
CDC_STOP_BITS_1_5 = 1, //!< 1.5 stop bits
CDC_STOP_BITS_2 = 2, //!< 2 stop bits
};
//! Possible values of bParityType
enum cdc_parity {
CDC_PAR_NONE = 0, //!< No parity
CDC_PAR_ODD = 1, //!< Odd parity
CDC_PAR_EVEN = 2, //!< Even parity
CDC_PAR_MARK = 3, //!< Parity forced to 0 (space)
CDC_PAR_SPACE = 4, //!< Parity forced to 1 (mark)
CDC_PAR_NONE = 0, //!< No parity
CDC_PAR_ODD = 1, //!< Odd parity
CDC_PAR_EVEN = 2, //!< Even parity
CDC_PAR_MARK = 3, //!< Parity forced to 0 (space)
CDC_PAR_SPACE = 4, //!< Parity forced to 1 (mark)
};
//@}
@@ -262,7 +262,7 @@ enum cdc_parity {
//! Control signal structure
typedef struct {
uint16_t value;
uint16_t value;
} usb_cdc_control_signal_t;
//! \name Possible values in usb_cdc_control_signal_t
@@ -283,11 +283,11 @@ typedef struct {
//@{
typedef struct {
uint8_t bmRequestType;
uint8_t bNotification;
le16_t wValue;
le16_t wIndex;
le16_t wLength;
uint8_t bmRequestType;
uint8_t bNotification;
le16_t wValue;
le16_t wIndex;
le16_t wLength;
} usb_cdc_notify_msg_t;
//! \name USB CDC serial state
@@ -295,8 +295,8 @@ typedef struct {
//! Hardware handshake support (cdc spec 1.1 chapter 6.3.5)
typedef struct {
usb_cdc_notify_msg_t header;
le16_t value;
usb_cdc_notify_msg_t header;
le16_t value;
} usb_cdc_notify_serial_state_t;
//! \name Possible values in usb_cdc_notify_serial_state_t
+32 -32
View File
@@ -59,7 +59,7 @@
* \name Possible Class value
*/
//@{
#define MSC_CLASS 0x08
#define MSC_CLASS 0x08
//@}
/**
@@ -71,12 +71,12 @@
* operating systems like Windows XP.
*/
//@{
#define MSC_SUBCLASS_RBC 0x01 //!< Reduced Block Commands
#define MSC_SUBCLASS_ATAPI 0x02 //!< CD/DVD devices
#define MSC_SUBCLASS_QIC_157 0x03 //!< Tape devices
#define MSC_SUBCLASS_UFI 0x04 //!< Floppy disk drives
#define MSC_SUBCLASS_SFF_8070I 0x05 //!< Floppy disk drives
#define MSC_SUBCLASS_TRANSPARENT 0x06 //!< Determined by INQUIRY
#define MSC_SUBCLASS_RBC 0x01 //!< Reduced Block Commands
#define MSC_SUBCLASS_ATAPI 0x02 //!< CD/DVD devices
#define MSC_SUBCLASS_QIC_157 0x03 //!< Tape devices
#define MSC_SUBCLASS_UFI 0x04 //!< Floppy disk drives
#define MSC_SUBCLASS_SFF_8070I 0x05 //!< Floppy disk drives
#define MSC_SUBCLASS_TRANSPARENT 0x06 //!< Determined by INQUIRY
//@}
/**
@@ -84,9 +84,9 @@
* \note Only the BULK protocol should be used in new designs.
*/
//@{
#define MSC_PROTOCOL_CBI 0x00 //!< Command/Bulk/Interrupt
#define MSC_PROTOCOL_CBI_ALT 0x01 //!< W/o command completion
#define MSC_PROTOCOL_BULK 0x50 //!< Bulk-only
#define MSC_PROTOCOL_CBI 0x00 //!< Command/Bulk/Interrupt
#define MSC_PROTOCOL_CBI_ALT 0x01 //!< W/o command completion
#define MSC_PROTOCOL_BULK 0x50 //!< Bulk-only
//@}
@@ -94,8 +94,8 @@
* \brief MSC USB requests (bRequest)
*/
enum usb_reqid_msc {
USB_REQ_MSC_BULK_RESET = 0xFF, //!< Mass Storage Reset
USB_REQ_MSC_GET_MAX_LUN = 0xFE //!< Get Max LUN
USB_REQ_MSC_BULK_RESET = 0xFF, //!< Mass Storage Reset
USB_REQ_MSC_GET_MAX_LUN = 0xFE //!< Get Max LUN
};
@@ -106,20 +106,20 @@ COMPILER_PACK_SET(1)
*/
//@{
struct usb_msc_cbw {
le32_t dCBWSignature; //!< Must contain 'USBC'
le32_t dCBWTag; //!< Unique command ID
le32_t dCBWDataTransferLength; //!< Number of bytes to transfer
uint8_t bmCBWFlags; //!< Direction in bit 7
uint8_t bCBWLUN; //!< Logical Unit Number
uint8_t bCBWCBLength; //!< Number of valid CDB bytes
uint8_t CDB[16]; //!< SCSI Command Descriptor Block
le32_t dCBWSignature; //!< Must contain 'USBC'
le32_t dCBWTag; //!< Unique command ID
le32_t dCBWDataTransferLength; //!< Number of bytes to transfer
uint8_t bmCBWFlags; //!< Direction in bit 7
uint8_t bCBWLUN; //!< Logical Unit Number
uint8_t bCBWCBLength; //!< Number of valid CDB bytes
uint8_t CDB[16]; //!< SCSI Command Descriptor Block
};
#define USB_CBW_SIGNATURE 0x55534243 //!< dCBWSignature value
#define USB_CBW_DIRECTION_IN (1<<7) //!< Data from device to host
#define USB_CBW_DIRECTION_OUT (0<<7) //!< Data from host to device
#define USB_CBW_LUN_MASK 0x0F //!< Valid bits in bCBWLUN
#define USB_CBW_LEN_MASK 0x1F //!< Valid bits in bCBWCBLength
#define USB_CBW_SIGNATURE 0x55534243 //!< dCBWSignature value
#define USB_CBW_DIRECTION_IN (1<<7) //!< Data from device to host
#define USB_CBW_DIRECTION_OUT (0<<7) //!< Data from host to device
#define USB_CBW_LUN_MASK 0x0F //!< Valid bits in bCBWLUN
#define USB_CBW_LEN_MASK 0x1F //!< Valid bits in bCBWCBLength
//@}
@@ -128,16 +128,16 @@ struct usb_msc_cbw {
*/
//@{
struct usb_msc_csw {
le32_t dCSWSignature; //!< Must contain 'USBS'
le32_t dCSWTag; //!< Same as dCBWTag
le32_t dCSWDataResidue; //!< Number of bytes not transferred
uint8_t bCSWStatus; //!< Status code
le32_t dCSWSignature; //!< Must contain 'USBS'
le32_t dCSWTag; //!< Same as dCBWTag
le32_t dCSWDataResidue; //!< Number of bytes not transferred
uint8_t bCSWStatus; //!< Status code
};
#define USB_CSW_SIGNATURE 0x55534253 //!< dCSWSignature value
#define USB_CSW_STATUS_PASS 0x00 //!< Command Passed
#define USB_CSW_STATUS_FAIL 0x01 //!< Command Failed
#define USB_CSW_STATUS_PE 0x02 //!< Phase Error
#define USB_CSW_SIGNATURE 0x55534253 //!< dCSWSignature value
#define USB_CSW_STATUS_PASS 0x00 //!< Command Passed
#define USB_CSW_STATUS_FAIL 0x01 //!< Command Failed
#define USB_CSW_STATUS_PE 0x02 //!< Phase Error
//@}
COMPILER_PACK_RESET()
+6 -6
View File
@@ -51,14 +51,14 @@
#include "conf_usb.h"
#include "udc.h"
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
static volatile bool main_b_msc_enable = false;
#endif
static volatile bool main_b_cdc_enable = false;
static volatile bool main_b_dtr_active = false;
void usb_task_idle(void) {
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
// Attend SD card access from the USB MSD -- Prioritize access to improve speed
int delay = 2;
while (main_b_msc_enable && --delay > 0) {
@@ -70,7 +70,7 @@ void usb_task_idle(void) {
#endif
}
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
bool usb_task_msc_enable(void) { return ((main_b_msc_enable = true)); }
void usb_task_msc_disable(void) { main_b_msc_enable = false; }
bool usb_task_msc_isenabled(void) { return main_b_msc_enable; }
@@ -206,13 +206,13 @@ static USB_MicrosoftExtendedPropertiesDescriptor microsoft_extended_properties_d
bool usb_task_extra_string(void) {
static uint8_t udi_msft_magic[] = "MSFT100\xEE";
static uint8_t udi_cdc_name[] = "CDC interface";
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
static uint8_t udi_msc_name[] = "MSC interface";
#endif
struct extra_strings_desc_t {
usb_str_desc_t header;
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
le16_t string[Max(Max(sizeof(udi_cdc_name) - 1, sizeof(udi_msc_name) - 1), sizeof(udi_msft_magic) - 1)];
#else
le16_t string[Max(sizeof(udi_cdc_name) - 1, sizeof(udi_msft_magic) - 1)];
@@ -231,7 +231,7 @@ bool usb_task_extra_string(void) {
str_lgt = sizeof(udi_cdc_name) - 1;
str = udi_cdc_name;
break;
#if ENABLED(SDSUPPORT)
#if HAS_MEDIA
case UDI_MSC_STRING_ID:
str_lgt = sizeof(udi_msc_name) - 1;
str = udi_msc_name;
+2 -2
View File
@@ -165,7 +165,7 @@ void MarlinHAL::init_board() {
}
void MarlinHAL::idletask() {
#if BOTH(WIFISUPPORT, OTASUPPORT)
#if ALL(WIFISUPPORT, OTASUPPORT)
OTA_handle();
#endif
TERN_(ESP3D_WIFISUPPORT, esp3dlib.idletask());
@@ -175,7 +175,7 @@ uint8_t MarlinHAL::get_reset_source() { return rtc_get_reset_reason(1); }
void MarlinHAL::reboot() { ESP.restart(); }
void _delay_ms(int delay_ms) { delay(delay_ms); }
void _delay_ms(const int ms) { delay(ms); }
// return free memory between end of heap (or end bss) and whatever is current
int MarlinHAL::freeMemory() { return ESP.getFreeHeap(); }
+10 -10
View File
@@ -1,7 +1,9 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
*
* 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
@@ -50,14 +52,12 @@
#define MYSERIAL1 flushableSerial
#if EITHER(WIFISUPPORT, ESP3D_WIFISUPPORT)
#if ENABLED(ESP3D_WIFISUPPORT)
typedef ForwardSerial1Class< decltype(Serial2Socket) > DefaultSerial1;
extern DefaultSerial1 MSerial0;
#define MYSERIAL2 MSerial0
#else
#define MYSERIAL2 webSocketSerial
#endif
#if ENABLED(ESP3D_WIFISUPPORT)
typedef ForwardSerial1Class< decltype(Serial2Socket) > DefaultSerial1;
extern DefaultSerial1 MSerial0;
#define MYSERIAL2 MSerial0
#elif ENABLED(WIFISUPPORT)
#define MYSERIAL2 webSocketSerial
#endif
#define CRITICAL_SECTION_START() portENTER_CRITICAL(&hal.spinlock)
@@ -171,7 +171,7 @@ void _delay_ms(const int ms);
// MarlinHAL Class
// ------------------------
#define HAL_ADC_VREF 3.3
#define HAL_ADC_VREF_MV 3300
#define HAL_ADC_RESOLUTION 10
class MarlinHAL {
+1 -2
View File
@@ -4,7 +4,6 @@
*
* Based on Sprinter and grbl.
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
* Copyright (c) 2017 Victor Perez
*
* 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
@@ -53,7 +52,7 @@ static SPISettings spiConfig;
// ------------------------
void spiBegin() {
#if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_SS)
#if HAS_MEDIA && PIN_EXISTS(SD_SS)
OUT_WRITE(SD_SS_PIN, HIGH);
#endif
}
+29 -29
View File
@@ -42,33 +42,33 @@ void ICACHE_RAM_ATTR endstop_ISR() { endstops.update(); }
void setup_endstop_interrupts() {
#define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
TERN_(HAS_X_MAX, _ATTACH(X_MAX_PIN));
TERN_(HAS_X_MIN, _ATTACH(X_MIN_PIN));
TERN_(HAS_Y_MAX, _ATTACH(Y_MAX_PIN));
TERN_(HAS_Y_MIN, _ATTACH(Y_MIN_PIN));
TERN_(HAS_Z_MAX, _ATTACH(Z_MAX_PIN));
TERN_(HAS_Z_MIN, _ATTACH(Z_MIN_PIN));
TERN_(HAS_X2_MAX, _ATTACH(X2_MAX_PIN));
TERN_(HAS_X2_MIN, _ATTACH(X2_MIN_PIN));
TERN_(HAS_Y2_MAX, _ATTACH(Y2_MAX_PIN));
TERN_(HAS_Y2_MIN, _ATTACH(Y2_MIN_PIN));
TERN_(HAS_Z2_MAX, _ATTACH(Z2_MAX_PIN));
TERN_(HAS_Z2_MIN, _ATTACH(Z2_MIN_PIN));
TERN_(HAS_Z3_MAX, _ATTACH(Z3_MAX_PIN));
TERN_(HAS_Z3_MIN, _ATTACH(Z3_MIN_PIN));
TERN_(HAS_Z4_MAX, _ATTACH(Z4_MAX_PIN));
TERN_(HAS_Z4_MIN, _ATTACH(Z4_MIN_PIN));
TERN_(HAS_Z_MIN_PROBE_PIN, _ATTACH(Z_MIN_PROBE_PIN));
TERN_(HAS_I_MAX, _ATTACH(I_MAX_PIN));
TERN_(HAS_I_MIN, _ATTACH(I_MIN_PIN));
TERN_(HAS_J_MAX, _ATTACH(J_MAX_PIN));
TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
TERN_(USE_X_MAX, _ATTACH(X_MAX_PIN));
TERN_(USE_X_MIN, _ATTACH(X_MIN_PIN));
TERN_(USE_Y_MAX, _ATTACH(Y_MAX_PIN));
TERN_(USE_Y_MIN, _ATTACH(Y_MIN_PIN));
TERN_(USE_Z_MAX, _ATTACH(Z_MAX_PIN));
TERN_(USE_Z_MIN, _ATTACH(Z_MIN_PIN));
TERN_(USE_X2_MAX, _ATTACH(X2_MAX_PIN));
TERN_(USE_X2_MIN, _ATTACH(X2_MIN_PIN));
TERN_(USE_Y2_MAX, _ATTACH(Y2_MAX_PIN));
TERN_(USE_Y2_MIN, _ATTACH(Y2_MIN_PIN));
TERN_(USE_Z2_MAX, _ATTACH(Z2_MAX_PIN));
TERN_(USE_Z2_MIN, _ATTACH(Z2_MIN_PIN));
TERN_(USE_Z3_MAX, _ATTACH(Z3_MAX_PIN));
TERN_(USE_Z3_MIN, _ATTACH(Z3_MIN_PIN));
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_I_MAX, _ATTACH(I_MAX_PIN));
TERN_(USE_I_MIN, _ATTACH(I_MIN_PIN));
TERN_(USE_J_MAX, _ATTACH(J_MAX_PIN));
TERN_(USE_J_MIN, _ATTACH(J_MIN_PIN));
TERN_(USE_K_MAX, _ATTACH(K_MAX_PIN));
TERN_(USE_K_MIN, _ATTACH(K_MIN_PIN));
TERN_(USE_U_MAX, _ATTACH(U_MAX_PIN));
TERN_(USE_U_MIN, _ATTACH(U_MIN_PIN));
TERN_(USE_V_MAX, _ATTACH(V_MAX_PIN));
TERN_(USE_V_MIN, _ATTACH(V_MIN_PIN));
TERN_(USE_W_MAX, _ATTACH(W_MAX_PIN));
TERN_(USE_W_MIN, _ATTACH(W_MIN_PIN));
}
+38 -20
View File
@@ -34,6 +34,10 @@
#include <freertos/queue.h>
#include "../../module/stepper.h"
#if ENABLED(FT_MOTION)
#include "../../module/ft_motion.h"
#endif
#define DMA_BUF_COUNT 8 // number of DMA buffers to store data
#define DMA_BUF_LEN 4092 // maximum size in bytes
#define I2S_SAMPLE_SIZE 4 // 4 bytes, 32 bits per sample
@@ -134,8 +138,8 @@ static void IRAM_ATTR i2s_intr_handler_default(void *arg) {
if (high_priority_task_awoken == pdTRUE) portYIELD_FROM_ISR();
// clear interrupt
I2S0.int_clr.val = I2S0.int_st.val; //clear pending interrupt
// Clear pending interrupt
I2S0.int_clr.val = I2S0.int_st.val;
}
void stepperTask(void *parameter) {
@@ -148,29 +152,43 @@ 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);
while (dma.rw_pos < DMA_SAMPLE_COUNT) {
if (!nextMainISR) {
Stepper::pulse_phase_isr();
nextMainISR = Stepper::block_phase_isr();
}
#if ENABLED(LIN_ADVANCE)
else if (!nextAdvanceISR) {
Stepper::advance_isr();
nextAdvanceISR = Stepper::la_interval;
#if ENABLED(FT_MOTION)
if (using_ftMotion) {
if (!nextMainISR) stepper.ftMotion_stepper();
nextMainISR = 0;
}
#endif
else
i2s_push_sample();
nextMainISR--;
if (!using_ftMotion) {
if (!nextMainISR) {
Stepper::pulse_phase_isr();
nextMainISR = Stepper::block_phase_isr();
}
#if ENABLED(LIN_ADVANCE)
else if (!nextAdvanceISR) {
Stepper::advance_isr();
nextAdvanceISR = Stepper::la_interval;
}
#endif
else
i2s_push_sample();
#if ENABLED(LIN_ADVANCE)
if (nextAdvanceISR == Stepper::LA_ADV_NEVER)
nextAdvanceISR = Stepper::la_interval;
nextMainISR--;
if (nextAdvanceISR && nextAdvanceISR != Stepper::LA_ADV_NEVER)
nextAdvanceISR--;
#endif
#if ENABLED(LIN_ADVANCE)
if (nextAdvanceISR == Stepper::LA_ADV_NEVER)
nextAdvanceISR = Stepper::la_interval;
if (nextAdvanceISR && nextAdvanceISR != Stepper::LA_ADV_NEVER)
nextAdvanceISR--;
#endif
}
}
}
}
@@ -356,7 +374,7 @@ void i2s_push_sample() {
// Every 4µs (when space in DMA buffer) toggle each expander PWM output using
// the current duty cycle/frequency so they sync with any steps (once
// through the DMA/FIFO buffers). PWM signal inversion handled by other functions
LOOP_L_N(p, MAX_EXPANDER_BITS) {
for (uint8_t p = 0; p < MAX_EXPANDER_BITS; ++p) {
if (hal.pwm_pin_data[p].pwm_duty_ticks > 0) { // pin has active pwm?
if (hal.pwm_pin_data[p].pwm_tick_count == 0) {
if (TEST32(i2s_port_data, p)) { // hi->lo
+2 -2
View File
@@ -21,6 +21,6 @@
*/
#pragma once
#if HAS_SPI_TFT || HAS_FSMC_TFT
#error "Sorry! TFT displays are not available for HAL/ESP32."
#if ANY(MKS_MINI_12864, FYSETC_MINI_12864_2_1)
#define U8G_HW_SPI_ESP32 1
#endif
+15 -8
View File
@@ -21,19 +21,26 @@
*/
#pragma once
#if HAS_SPI_TFT || HAS_FSMC_TFT
#error "Sorry! TFT displays are not available for HAL/ESP32."
#endif
#if ENABLED(EMERGENCY_PARSER)
#error "EMERGENCY_PARSER is not yet implemented for ESP32. Disable EMERGENCY_PARSER to continue."
#endif
#if (ENABLED(SPINDLE_LASER_USE_PWM) && SPINDLE_LASER_FREQUENCY > 78125) || (ENABLED(FAST_PWM_FAN_FREQUENCY) && FAST_PWM_FAN_FREQUENCY > 78125)
#error "SPINDLE_LASER_FREQUENCY and FAST_PWM_FREQUENCY maximum value is 78125Hz for ESP32."
#if ENABLED(SPINDLE_LASER_USE_PWM) && SPINDLE_LASER_FREQUENCY > 78125
#error "SPINDLE_LASER_FREQUENCY maximum value is 78125Hz for ESP32."
#endif
#if ENABLED(FAST_PWM_FAN) && FAST_PWM_FAN_FREQUENCY > 78125
#error "FAST_PWM_FREQUENCY maximum value is 78125Hz for ESP32."
#endif
#if HAS_TMC_SW_SERIAL
#error "TMC220x Software Serial is not supported on ESP32."
#endif
#if BOTH(WIFISUPPORT, ESP3D_WIFISUPPORT)
#if ALL(WIFISUPPORT, ESP3D_WIFISUPPORT)
#error "Only enable one WiFi option, either WIFISUPPORT or ESP3D_WIFISUPPORT."
#endif
@@ -45,14 +52,14 @@
#error "FAST_PWM_FAN is not available on TinyBee."
#endif
#if BOTH(I2S_STEPPER_STREAM, BABYSTEPPING) && DISABLED(INTEGRATED_BABYSTEPPING)
#error "BABYSTEPPING on I2S stream requires INTEGRATED_BABYSTEPPING."
#endif
#if USING_PULLDOWNS
#error "PULLDOWN pin mode is not available on ESP32 boards."
#endif
#if BOTH(I2S_STEPPER_STREAM, LIN_ADVANCE) && DISABLED(EXPERIMENTAL_I2S_LA)
#if ALL(I2S_STEPPER_STREAM, LIN_ADVANCE) && DISABLED(EXPERIMENTAL_I2S_LA)
#error "I2S stream is currently incompatible with LIN_ADVANCE."
#endif
#if ALL(I2S_STEPPER_STREAM, PRINTCOUNTER) && PRINTCOUNTER_SAVE_INTERVAL > 0 && DISABLED(PRINTCOUNTER_SYNC)
#error "PRINTCOUNTER_SAVE_INTERVAL may cause issues on ESP32 with an I2S expander. Define PRINTCOUNTER_SYNC in Configuration.h for an imperfect solution."
#endif
+5 -3
View File
@@ -1,7 +1,9 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
*
* 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
@@ -22,7 +24,7 @@
#include "../../inc/MarlinConfigPre.h"
#if BOTH(WIFISUPPORT, OTASUPPORT)
#if ALL(WIFISUPPORT, OTASUPPORT)
#include <WiFi.h>
#include <ESPmDNS.h>
@@ -50,7 +52,7 @@ void OTA_init() {
})
.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
char *str;
const char *str = "unknown";
switch (error) {
case OTA_AUTH_ERROR: str = "Auth Failed"; break;
case OTA_BEGIN_ERROR: str = "Begin Failed"; break;
+3 -1
View File
@@ -1,7 +1,9 @@
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
*
* 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
+1 -1
View File
@@ -23,7 +23,7 @@
#include "../../inc/MarlinConfigPre.h"
#if BOTH(WIFISUPPORT, WEBSUPPORT)
#if ALL(WIFISUPPORT, WEBSUPPORT)
#include "../../core/serial.h"

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