Compare commits

...

904 Commits

Author SHA1 Message Date
Scott Lahteine
5996c3a907 1.1.1 Readme / Version 2017-05-12 05:37:35 -05:00
Scott Lahteine
bb7e3f1d07 Patch configuration temp units 2017-05-07 23:09:40 -05:00
Scott Lahteine
c9bfe7004c Adjust spacing of "spaces" 2017-05-07 23:09:40 -05:00
Scott Lahteine
fa9e54146a Patch redundant lcd settings 2017-05-07 23:09:40 -05:00
Scott Lahteine
0079166388 Spacing adjustment, ubl_G29 2017-05-07 23:09:40 -05:00
Scott Lahteine
232f5d235d Patch mfqp for use directly with MarlinDocumentation 2017-05-07 23:09:40 -05:00
Scott Lahteine
41cf1c9e6a Note 5 extruders in config comments 2017-05-07 23:09:40 -05:00
Scott Lahteine
2e61c1fb37 Patch missing const in temp_abs 2017-05-07 23:09:39 -05:00
Brian
a68084f417 Improve BLTOUCH_HEATERS_OFF functionality
- rename to PROBING_HEATERS_OFF
 - move heater pausing functionality into thermalManager
   - add variables, pause(), ispaused(), other functions
 - add fan pausing functionality -> PROBING_FANS_OFF
 - add probing_pause() wrapper
 - move pausing into do_homing_move() and do_probe_move() to minimize quiet time and so other probe types can benefit
 - example configs
2017-05-07 23:09:39 -05:00
Scott Lahteine
d5346a0689 Adjust spacing in LSF 2017-05-07 23:09:39 -05:00
Roxy-3D
c45b668142 More misc UBL fixes and update gMax examples (#6632)
I think I forgot to Sync before I committed last time.   Some UBL
changes did not stick.

Also, update the gMax configuaration.h file so other than unique numbers
and settings, it exactly matches the default configuration.h file.
2017-05-07 23:09:39 -05:00
Roxy-3D
ad0e5928f5 misc. UBL fixes (#6631)
* Restore LSF functionality

Some of the typo's persisted...   Hopefully this gets them all fixed.

* Restore user's expectations of how G28 should behave

* Allow Nozzle size control with ornery host programs
2017-05-07 23:09:39 -05:00
lrpirlet
06ca56a13c G29 P1 stops reporting Invalid location with this patch 2017-05-07 23:09:39 -05:00
Scott Lahteine
fbd021a756 Support temperature units in M503 2017-05-07 23:09:38 -05:00
bgort
d99794f11d Various improvements - mostly UBL-related (#6607)
UBL Clean up.
2017-05-07 23:09:38 -05:00
Scott Lahteine
c0f1052efb Fix mfrb and mfpub 2017-05-07 23:09:38 -05:00
Scott Lahteine
bf7ecc761f Edit configuration comments 2017-05-07 23:09:38 -05:00
Scott Lahteine
d0480c15ef Tweak git helper scripts 2017-05-07 23:09:38 -05:00
Scott Lahteine
771f42744a Tweak command index increment 2017-05-07 23:09:38 -05:00
Scott Lahteine
3a44157ee8 Minor fix in K8200 readme 2017-05-07 23:09:38 -05:00
Max Matveev
a666ff1255 Fixed USE_CONTROLLER_FAN #define usage 2017-05-07 23:09:37 -05:00
bgort
264f0960f7 fix error in M105 output -- use SERIAL_PROTOCOL for ints instead of SERIAL_PROTOCOL_F (#6584)
also removed wayward 'address of' ampersand in setTargetHotend and setTargetBed parameters
2017-05-07 23:09:37 -05:00
Scott Lahteine
03f94a7a18 1.1.0 ReadMe, Version, helper scripts 2017-05-07 23:09:37 -05:00
Scott Lahteine
28e597f945 Merge pull request #6570 from FHeilmann/patch-2
Fix broken fwretract recovery extruder feedrate
2017-05-04 07:15:19 -05:00
Florian Heilmann
15268770f5 Fix broken fwretract recovery extruder feedrate
When both lowering and recovery are performed using the same "prepare_move_to_destination()" the extruder recovery feedrate ends up being ignored and, instead, is only capped by either the maximum e-speed or the time it takes to perform the z-lowering. 
Performing the two moves separately from each other ensures a correct recovery feedrate.
2017-05-04 11:34:28 +02:00
Scott Lahteine
58210c3a19 Merge pull request #6568 from thinkyhead/rc_bilinear_extension
Add EXTRAPOLATE_BEYOND_GRID option to bilinear leveling
2017-05-04 00:46:05 -05:00
Scott Lahteine
da08e11acd Add EXTRAPOLATE_BEYOND_GRID option to bilinear leveling 2017-05-04 00:19:07 -05:00
Scott Lahteine
6834e36871 Merge pull request #6567 from thinkyhead/rc_sdcard_stop
Shutdown heaters, autotemp on SD Cancel
2017-05-03 23:54:29 -05:00
Scott Lahteine
399efd66ed Click to resume 2017-05-03 22:26:06 -05:00
Scott Lahteine
1196e3ca59 SDCard print completion can use "M0" 2017-05-03 22:24:03 -05:00
Scott Lahteine
6854f08d22 Shut down autotemp in disable_all_heaters 2017-05-03 20:54:26 -05:00
Thomas Moore
acec237092 Shutdown heaters and fan after canceling a print from the SD card 2017-05-03 20:43:09 -05:00
Scott Lahteine
11b6a3cbb6 Fix regression in least_squares_fit.cpp 2017-05-03 19:21:44 -05:00
Scott Lahteine
e1b85ff67b Merge pull request #6559 from thinkyhead/rc_more_optimal
Compact smart_fill_mesh slightly
2017-05-03 19:07:36 -05:00
Scott Lahteine
9890141f7b M100 tweak 2017-05-03 17:28:09 -05:00
Scott Lahteine
2658cc707a Treat temperature as integer, when possible 2017-05-03 17:27:25 -05:00
Scott Lahteine
1b2c7ec20a Make G26 compatible with inches and thermal unit modes 2017-05-03 17:12:48 -05:00
Scott Lahteine
241bdffe65 Dress up Bilinear Leveling code 2017-05-03 17:12:35 -05:00
Scott Lahteine
67ecf06cc4 Patch issue in gcode_M900
Noted in #6550
2017-05-03 15:26:00 -05:00
Scott Lahteine
de5e485ed7 Explicit upward angle solution 2017-05-03 01:19:44 -05:00
Scott Lahteine
ecdf68735f Compact smart_fill_mesh slightly 2017-05-03 01:06:58 -05:00
Scott Lahteine
628391304f Merge pull request #6552 from thinkyhead/rc_more_ubl_cleanup
Further cleanup of UBL
2017-05-02 22:46:04 -05:00
Scott Lahteine
902fe76db9 Merge pull request #6556 from thinkyhead/rc_use_controller_fan
Implement USE_CONTROLLER_FAN as a feature
2017-05-02 22:43:26 -05:00
Scott Lahteine
7ba7474a73 Drop extra parens from address-of operator 2017-05-02 22:22:23 -05:00
Scott Lahteine
0bf5add075 Use UBL_MESH_(MIN|MAX)_[XY] for G29 move limits 2017-05-02 22:22:23 -05:00
Scott Lahteine
b8ba3b7647 Use 'sq' macro where possible 2017-05-02 22:22:23 -05:00
Scott Lahteine
66eba3346b Remove G29 lcd control debugging 2017-05-02 22:22:23 -05:00
Scott Lahteine
3517154135 Reduce code size, fix bug in smart_fill_mesh 2017-05-02 22:22:23 -05:00
Scott Lahteine
c4e34adcf1 Apply formatting, coding standards to UBL 2017-05-02 22:22:23 -05:00
Scott Lahteine
f4239e62b1 Merge pull request #6557 from thinkyhead/rc_hotend_status_item
Keep refreshing LCD if hotend status is on-screen
2017-05-02 22:04:21 -05:00
Scott Lahteine
fc857c5b78 Merge pull request #6549 from thinkyhead/rc_bltouch_refix
Fix BLTOUCH_HEATERS_OFF bug
2017-05-02 21:53:09 -05:00
Thomas Moore
b39f634252 Continuously update LCD when hotend status is displayed in Filament Change screens 2017-05-02 21:49:40 -05:00
Scott Lahteine
2c13922c46 Implement USE_CONTROLLER_FAN as a feature 2017-05-02 20:18:52 -05:00
Scott Lahteine
492bc536bf Modify debug methods to take PSTR 2017-05-02 17:53:40 -05:00
Bob-the-Kuhn
e5a27d9f36 G29 P2 & P4 bug fixes & improvements 2017-05-02 17:53:40 -05:00
Scott Lahteine
b93be716cf Remove trailing whitespace 2017-05-02 17:53:40 -05:00
Scott Lahteine
76eca9732d Fix mis-named language string define in Dutch 2017-05-02 16:08:09 -05:00
Scott Lahteine
806f670092 Merge pull request #6511 from Bob-the-Kuhn/UBL--G26-minor-improvements
UBL: G26 minor improvements
2017-05-02 16:06:22 -05:00
Scott Lahteine
0803c9d997 Merge pull request #6533 from thinkyhead/rc_autocal_patches
General cleanup of G33
2017-05-02 16:01:02 -05:00
Scott Lahteine
46a5cab6fb Merge pull request #6548 from thinkyhead/rc_fix_dual_z_endstops
Fix Dual-Z endstop conditional test
2017-05-02 16:00:49 -05:00
Brian
ff5fed137f Fix BLTOUCH_HEATERS_OFF bug 2017-05-02 15:53:52 -05:00
Scott Lahteine
ca1dd739a3 Organize ubl.h defines by the files they serve 2017-05-02 15:47:06 -05:00
Scott Lahteine
0449f69179 Cleanup patch to recent merge 2017-05-02 15:47:06 -05:00
LVD-AC
da2abad636 Various cleanups of G33
- update comment section
- redefined P5 grid
- minor clean to probe radius routine
- updated EEPROM version to V37 according remark in #6517
2017-05-02 15:47:06 -05:00
Bob-the-Kuhn
7ce613db0a Fix Conditionals test for endstop plug used by Z2 or probe. 2017-05-02 15:41:47 -05:00
Scott Lahteine
ef750ae86b Towards supporting Z2 in Endstops::report_state 2017-05-02 15:39:32 -05:00
Scott Lahteine
c03c623951 Sanity-check Z2 endstop assigned to a nonexistent pin. 2017-05-02 15:39:00 -05:00
Scott Lahteine
70f31b6c76 Throw an error if no E stepper is free for X2, Y2, Z2 2017-05-02 15:13:47 -05:00
Scott Lahteine
ac69eca586 Merge pull request #6538 from bgort/ubl_gridlbls
Fix, cleanup, prettify `G29 O` output
2017-05-02 14:09:18 -05:00
Scott Lahteine
99b11db1a1 Merge pull request #6537 from thinkyhead/rc_cleanup_sunday
Various leveling-related patches
2017-05-02 00:59:59 -05:00
Roxy-3D
41e63bbb7c Fix Horizontal and Vertical UBL optimization bug. (#6540)
* Fix Horizontal and Vertical optimization bug.

And drastically reduce the debug code foot print....

* Yeah Baby!

The debug print is going A - OK !
2017-05-01 23:52:33 -05:00
Scott Lahteine
e79b335367 Patches for leveling reactivation in G28 / M48 2017-05-01 17:38:57 -05:00
Brian
92e22c3bf2 Fix, cleanup, prettify G29 O output 2017-05-01 18:19:57 -04:00
Scott Lahteine
7d5cd7e0d7 Tweak set_bed_leveling_enabled 2017-05-01 16:46:52 -05:00
Scott Lahteine
ed81e9b3d3 Adjust leveling conditionals 2017-05-01 16:46:48 -05:00
Scott Lahteine
a64e5659ce Clean up G26 external references, private vars 2017-05-01 15:17:52 -05:00
Scott Lahteine
2887c20788 Add a function to home all axes (i.e., gcode_G28) 2017-05-01 15:03:37 -05:00
Scott Lahteine
8f895d5e01 Merge pull request #6530 from thinkyhead/rc_cleanups_2
Fixes for DUAL_NOZZLE_DUPLICATION_MODE
2017-05-01 12:34:11 -05:00
Scott Lahteine
8002672938 Fixes for DUAL_NOZZLE_DUPLICATION_MODE 2017-05-01 12:20:25 -05:00
Scott Lahteine
f69acde966 Merge pull request #6528 from MarlinFirmware/revert-6416-negative-mesh-fix
Revert "Fix for Meshpositions if printer has negative endstop positions"
2017-05-01 11:51:13 -05:00
Scott Lahteine
8bd63aafb9 Merge pull request #6527 from thinkyhead/rc_cleanups_2
Patch DELTA_HEIGHT, BLTOUCH init
2017-05-01 11:28:43 -05:00
Scott Lahteine
4803a4322e Revert "Fix for Meshpositions if printer has negative endstop positions" 2017-05-01 11:25:07 -05:00
Scott Lahteine
4f74c416a4 Patch for BLTOUCH_HEATERS_OFF 2017-05-01 11:13:40 -05:00
Scott Lahteine
1823a6ea29 Patch for missing DELTA_HEIGHT 2017-05-01 11:05:35 -05:00
Scott Lahteine
984c210dec Merge pull request #6519 from thinkyhead/rc_cleanups_2
Various fixes for compiler warnings
2017-05-01 02:46:34 -05:00
Scott Lahteine
d814e468d2 Fix set_heaters_for_bltouch and usage
- Only call `set_heaters_for_bltouch` when actually deploying/stowing
- Clear `next_emi_protection` when re-enabling heaters
2017-05-01 02:27:52 -05:00
Brian
4e1448e75a Various fixes for compiler warnings
add BLTouch-related messages in english and (rusty) french;
add missing endstops.h in ultralcd.cpp;
fix misc. compiler warnings;
fix lsf_reset - ZERO macro can't handle a pointer as it would only memset the size of the pointer, not the size of the entire struct
2017-05-01 02:12:40 -05:00
Scott Lahteine
fc9919b749 Merge pull request #6515 from thinkyhead/rc_cleanup_sunday
Some minor cleanups to code formatting
2017-04-30 22:58:16 -05:00
Scott Lahteine
c12bc51a59 cardreader.cpp spacing tweak 2017-04-30 22:27:47 -05:00
Scott Lahteine
46b714a52f Cleanup spacing in pinsDebug.h 2017-04-30 22:27:26 -05:00
Scott Lahteine
88141ca717 Remove things that aren't pins from pinsDebug_list.h 2017-04-30 22:24:51 -05:00
Scott Lahteine
ff35b11d08 Resolve compiler complaint about memset volatile * 2017-04-30 22:24:03 -05:00
Scott Lahteine
ff95a9850a Merge pull request #6516 from thinkyhead/rc_meaningful_branch_name
Need to define this for Rigidboard V2
2017-04-30 22:17:41 -05:00
Scott Lahteine
0b421e97c9 Rename some (unused) OMCA pins 2017-04-30 22:16:44 -05:00
Scott Lahteine
c2c9f01c8e Patch newly-introduced bug in IS_Z2_OR_PROBE 2017-04-30 20:17:10 -05:00
Scott Lahteine
819df5e06d Cleanups to pins debugging 2017-04-30 20:17:10 -05:00
Scott Lahteine
42824b0e1f Use new serial spacing function to save PROGMEM 2017-04-30 20:14:42 -05:00
Scott Lahteine
cd72901fb7 Cleanups to UBL code 2017-04-30 20:14:42 -05:00
Bob-the-Kuhn
ce87c7803e implement G26 changes per review 2017-04-30 19:05:25 -05:00
jaysonkelly
769817ce5e Need to define this for Rigidboard V2
Motor current defaults need to be defined for Rigidboard
2017-04-30 19:04:27 -05:00
Scott Lahteine
39c6c5621b Merge pull request #6416 from SkyNet3D/negative-mesh-fix
Fix for Meshpositions if printer has negative endstop positions
2017-04-30 17:38:41 -05:00
Scott Lahteine
671a44b8aa Merge pull request #6410 from teemuatlut/LVD-Delta
Delta auto-calibration updates
2017-04-30 16:39:51 -05:00
Scott Lahteine
5d5c9a040a Merge pull request #6509 from thinkyhead/rc_config_patches
Configuration cleanup
2017-04-30 16:10:27 -05:00
Scott Lahteine
d480b6f75a Enable E1 stepper for DUAL_NOZZLE_DUPLICATION_MODE 2017-04-30 16:01:01 -05:00
Bob-the-Kuhn
dcde202157 Add startup notice & update host temperatures while waiting
Right now G26 doesn't send a notice to the host that it's running.  It's
not until the heaters are at temperature that you know for sure if it's
running or not.

Added host temperature prints so that someone watching the host
interface will see the temperatures change during the warm up period.
Updates are sent every 5 seconds.
2017-04-30 15:51:58 -05:00
Scott Lahteine
54751e8557 Put DISTINCT_E_FACTORS adjacent to the affected settings 2017-04-30 15:30:31 -05:00
Scott Lahteine
0dbe4b3e54 Edit configurations to reduce verbosity, arrange logically 2017-04-30 15:30:31 -05:00
Scott Lahteine
0750933bc6 Merge pull request #6490 from Bob-the-Kuhn/Missing-X-stop
Endstop not enabled if pin is zero
2017-04-30 15:09:36 -05:00
bgort
5ace3699b1 Output (commented) coordinates on G29 S-1; helps identify the x/y points that correspond with i/j coordinates, which eases manual tweaking of z values (#6507) 2017-04-30 14:59:34 -05:00
Scott Lahteine
d7d4378481 Remove inaccurate version description 2017-04-30 14:57:19 -05:00
Scott Lahteine
f169c04604 Merge pull request #6491 from thinkyhead/rc_cleanup_wednesday
Various cleanups for recent merges
2017-04-30 14:56:48 -05:00
Scott Lahteine
6d63255ddc Merge pull request #6508 from bgort/pio_improvements
PlatformIO-related improvement
2017-04-30 14:53:22 -05:00
LVD-AC
cafc48dff8 little oops 2017-04-30 22:17:49 +03:00
Brian
627730948d Add U8glib as a dependency to platformio.ini for those who use PlatformIO; this makes compiling even easier as u8glib will be downloaded and included automatically.
Also added the new .pio-related directory to .gitignore, and a few ignores for those who use cmake.
2017-04-30 15:13:51 -04:00
bgort
5974d8e168 change G26 default nozzle size to 0.4, consistent with instructions (#6506) 2017-04-30 13:23:46 -05:00
LVD-AC
471a321624 leaner code for probe routine 2017-04-30 19:15:16 +03:00
bgort
3c0d5ba0a1 allow idle() to be called - fixes sometimes crash/hang in G29 I; (#6505) 2017-04-30 10:22:31 -05:00
Roxy-3D
2509587b5a Correct over optimization of pre-initialized variables (#6500)
* Correct over optimization of pre-initialized variables

NEAR_ZERO() works most of the time...  But it leaves corner cases
uncovered.  We need to explicitly check if these variables are +/-
infinity.

* Correct over optimization of pre-initialized variables
2017-04-29 22:01:29 -05:00
LVD-AC
585c00a728 Proposed changes
This is what I did yesterday:

- basicly gave the tests more comprehensive names; put all the
declarations at the top; got rid of the magic negative C-value (renamed
to P + A, O, T)

- "cos(RADIANS(180 + 30 * axis)) * (1 + circles * 0.1 * ((zig_zag) ? 1 :
-1)) * delta_calibration_radius" compiles wrong is zig_zag statement is
without brackets

- DELTA_TOWER_ANGLE_TRIM reset to 3 values (the calcs use the 3th value
to normalize will not compile otherwise)

-Wrote 3 dummies to keep EEPROM lenght the same

-Reset the configs to the 'original' with autocal + menu disabled (but
can be enabled of course)
2017-04-29 18:53:14 +03:00
Scott Lahteine
29fa241617 Initial patches to G33 2017-04-29 15:29:49 +03:00
Scott Lahteine
12ce051b55 Add a function to output spaces to serial 2017-04-29 15:29:49 +03:00
Scott Lahteine
42f4c53254 Starting on G33 rewrite 2017-04-29 15:29:49 +03:00
Scott Lahteine
baf3b91460 DELTA_TOWER_ANGLE_TRIM only needs AB 2017-04-29 15:29:49 +03:00
Scott Lahteine
6424068412 Merge pull request #6495 from emartinez167/Spanish-language-changes
Last three Spanish language strings
2017-04-29 05:43:04 -05:00
emartinez167
27cd165adf Last three Spanish language strings
Updates as per @thinkyhead request.
2017-04-29 11:33:30 +08:00
Scott Lahteine
2cc9774f34 Apply bltouch_menu
As proffered in #6252
2017-04-28 18:43:03 -05:00
Scott Lahteine
1a111180de Clean up set_heaters_for_bltouch 2017-04-28 18:32:39 -05:00
Scott Lahteine
7db805930a Cleanup configurations 2017-04-28 18:32:39 -05:00
Scott Lahteine
8bf3a3fcdb Remove inaccurate comments from ubl.h 2017-04-28 18:32:38 -05:00
Scott Lahteine
47557d5a19 Fix up formatting in ubl.h 2017-04-28 18:32:38 -05:00
Scott Lahteine
0a8e09c723 Clean up excess whitespace, comment formatting 2017-04-28 18:32:38 -05:00
Scott Lahteine
a35c681453 Clean up least_squares_fit 2017-04-28 17:33:28 -05:00
Bob-the-Kuhn
40089249c3 add PIN_EXISTS to HAS_xyz_MIN macro 2017-04-28 16:47:59 -05:00
Scott Lahteine
8020069371 Apply coding standards for indentation 2017-04-28 15:43:06 -05:00
Scott Lahteine
dabca83742 Merge pull request #6437 from Kaibob2/patch-1
Update language_de.h
2017-04-28 14:47:47 -05:00
Kai
3d0a4c4ea9 Update language_de.h 2017-04-28 21:09:10 +02:00
Silvio
6bf1d50188 Added missing translations (#6458) 2017-04-28 13:49:16 -05:00
Mehmet Sutas
404f767d44 Update language_tr.h (#6463) 2017-04-28 13:48:31 -05:00
Petr Zahradnik
5e701524f8 Update language_cz.h for new translations (#6465)
* Update language_cz.h for new translations

* Correction translate

* Revert correction back to hotend
2017-04-28 13:47:43 -05:00
gege2b
0a92ce7a98 Completed french translation (#6475) 2017-04-28 13:46:09 -05:00
Ernesto Martinez
ff4fb42e7d Add new strings as per recent changes in RCBugFix (#6482)
Adding missing strings to Spanish language, as per changes recently
done to the RCBugFix branch.
2017-04-28 13:45:22 -05:00
paulusjacobus
67d1fc5556 Update language_nl.h (#6478)
updated the RCbugfix release with additional Dutch translations
2017-04-28 13:42:39 -05:00
benlye
8c6b4537a6 Fix issue in itostr4sign with numbers <100 (#6487)
The first character in the string wasn't blanked if the number went from >= 100 to <100, resulting in artefacts in the displayed string.
2017-04-28 13:35:11 -05:00
LVD-AC
4ea8d0f89b Solved "The Travis CI build failed " 2017-04-28 19:55:21 +03:00
LVD-AC
ed6b361e27 cleanup ready to squash 2017-04-28 18:09:18 +03:00
LVD-AC
7a6a1ef583 M666 normalize positive values to <=0
M666

+ tower radians absolute value
2017-04-28 18:05:24 +03:00
Roxy-3D
4075b95519 Allow BL-Touch users to control heaters during probe event (#6485)
The Configuration.h file entries for BL-Touch have been updated to:
```cpp
//#define BLTOUCH
//#define BLTOUCH_DELAY 375      // (ms) Enable and increase if needed
//#define BLTOUCH_HEATERS_OFF // if defined the printer's heaters are
turned off during probe event
```
2017-04-28 09:19:55 -05:00
Roxy-3D
6e8ecb908a Shut down heaters during BL-Touch probe event
The electro-magnetic interference from the bed and nozzle are affecting
the BL-Touch repeatability for some users.   This problem can be helped
by shutting down the heaters during the actual probe event and then
quickly turning them back on.

Because this code is messing with the heaters, it is written in a
paranoid manner.  It only turns the heaters back on if everything is
EXACTLY as it expects things to be.  The BL-Touch probe must have been
put into a deployed state less than 20 seconds prior, or the stow()
function will NOT turn the heaters on.

This code has been tested and works for both G28 and probing functions.
2017-04-27 18:52:58 -05:00
LVD-AC
d8102aeca8 Cn negative : no tower angle calibration
Giving a negative number of probe points disables the tower angle
correction calibration ('4point' instead of '7point' solution)

EEPROM version updated
2017-04-27 21:13:07 +03:00
Roxy-3D
3601f08e87 Better tuned FolgerTech i3-2020 example file 2017-04-27 11:16:38 -05:00
Roxy-3D
a20b7d9581 Better tuned Example file for FolgerTech i3-2020
Also setting up Z-Probe on the machine.
2017-04-27 11:16:38 -05:00
Kai
bf2fe46062 Update language_de.h 2017-04-27 10:13:02 +02:00
Kai
11d34be060 Update language_de.h 2017-04-27 10:06:26 +02:00
Scott Lahteine
817ecb9ff4 Merge pull request #6453 from thinkyhead/rc_cleanup_wednesday
Minor cleanups, work-in-progress
2017-04-26 19:41:52 -05:00
Roxy-3D
22f6e277af Get example files fully into compliance
Change to support new name GRID_MAX_POINTS_XY
Start UBL at version 1.0 in the CUSTOM_MACHINE_NAME
2017-04-26 16:22:17 -05:00
LVD-AC
a9bc1d30cc z_offset change
Avoids to have to recalibrate the delta_height after a z_offset change
2017-04-26 21:57:11 +03:00
Roxy-3D
ec26e23e7e Add my two 'Nice' machines as example configurations
These are my two 'Nice' machines.  Both are good example machines.  The
FolgerTech i3-2020 is probably the best value kit on the market right
now.  And it has developed a 'Cult Following' of hobbiests.  I'll always
have an up to date Configuration.h file set for it, so it may as well be
an example configuration.

And the gCreate gMax 1.5+ is the best printer I've ever seen that runs
Marlin.  For sure, I'll always have up to the minute Configuration.h
files for this printer also.   I've moved over to using the gMax as my
primary development machine for Marlin.   So...  Besides being a good
machine, it is a nice convienience for me to have this Configuration.h
file as an 'Example'.
2017-04-26 12:46:12 -05:00
Scott Lahteine
adb8e68592 Fix stuck "Print Aborted" LCD message
Fixes #6393
2017-04-26 06:24:23 -05:00
Scott Lahteine
096b927102 Minor optimization of FILAMENT_WIDTH_SENSOR 2017-04-26 06:24:23 -05:00
Scott Lahteine
5bdb0b567d Cosmetic patches 2017-04-26 06:24:23 -05:00
Kai
38ae7f4238 Added more translation strings
There are some quite tricky ones which are hardly translateable.
Maybe @Sebastianv650 can review this
2017-04-26 11:58:11 +02:00
Scott Lahteine
4d96d3eab1 Bootscreen delay after clear, then set chars
Fixes #6426
2017-04-25 23:37:28 -05:00
Scott Lahteine
5512130d6c Only set Compare Mode for channel A
Fixes #6445
2017-04-25 23:14:16 -05:00
Roxy-3D
d467e97679 Smart-Fill and Mesh-Tilting (both 3-point and grid) working!
Also...   The memory corruption issue may be fixed.   The GCC compiler
was inlining static functions and this caused the G29() stack frame to
become much larger than the AVR could handle.
2017-04-25 21:03:41 -05:00
Scott Lahteine
a699967ec8 Merge pull request #6443 from thinkyhead/rc_interrupt_fastio
Patch fastio.h with Timer 2 interrupt support
2017-04-24 20:09:41 -05:00
Scott Lahteine
2823bf0874 Update fastio.h with special handling for Timer 2 2017-04-24 16:58:22 -05:00
Scott Lahteine
fd535e111a Fix up XYZ_CONSTS_FROM_CONFIG macro 2017-04-24 14:05:11 -05:00
Kai
03c2f756b9 Update language_de.h 2017-04-24 13:32:16 +02:00
LVD-AC
dcf30a69d6 Allowing #define DELTA_TOWER_ANGLE_TRIM[C_AXIS]
More consistent with M665 where C-value is allowed as well, then
normalized
2017-04-23 14:51:24 +03:00
Brian
f41fb2b635 Numerous UBL-related changes:
* relocated ubl state to config. store:
 * removed a number of ubl state variables and padding which were largely unused - saved 58 bytes of both SRAM and EEPROM;
 * modified ubl sanity_check - no longer checks removed state variables that were otherwise unused, where checking didn't seem to accomplish anything, ultimately;
 * removed pre_initialized state, saving 64 bytes of SRAM;
 * removed automatic saving of UBL state after UBL activation/deactivation;
* consolidated multiple GRID_MAX_POINTS_X/Y to 'Global Leveling' section of EEPROM;
* minor update to G29 Sx notes/instructions;
* renamed mesh load and save parameter to 'slot' from 'm' for clarity;
2017-04-22 18:44:39 -05:00
Brian
f1a4758cef use progmem instead of sram for mesh_index_to_x/ypos array;
fix maximum mesh_index_ array size at 16 (15+1);
2017-04-22 18:34:49 -05:00
Scott Lahteine
d5ec34e7ed Merge pull request #6431 from thinkyhead/rc_bilinear_super_optimize
Minor cleanup, optimize number-to-string
2017-04-22 17:05:24 -05:00
Scott Lahteine
87d240042a Optimize number-to-string functions, no-fan display 2017-04-22 16:23:15 -05:00
Scott Lahteine
959566cf0a Update note about M163 / M164 2017-04-22 16:23:15 -05:00
Scott Lahteine
830851df13 Spend some SRAM to optimize bilinear leveling 2017-04-22 16:19:31 -05:00
Scott Lahteine
091179d960 bed_level_grid => z_values (also *_virt array) 2017-04-22 16:19:31 -05:00
Scott Lahteine
23cdbbb2d3 Add a method to refresh bilinear bed level after a change 2017-04-22 16:19:30 -05:00
Scott Lahteine
ccda63c473 Drop the accessor form for LCD value editing 2017-04-22 16:19:30 -05:00
Scott Lahteine
10da175be5 Fix a pair of compiler complaints 2017-04-22 16:19:30 -05:00
Scott Lahteine
ff0018e287 Format hex values as uppercase 2017-04-21 21:42:41 -05:00
android444
77aa16005d Polish font
Add polish font for GLCD displays only.
HD44780 work properly without polish character.
Update language_pl.h.
2017-04-21 21:42:41 -05:00
teemuatlut
244f67590e Delta probe height bug solved 2017-04-22 02:23:56 +03:00
Hans Raaf
406a83ff2d Fix for Meshpositions if printer has negative endstop positions 2017-04-22 00:16:16 +02:00
benlye
3ed737425d Fix typo in new SET_COM macro 2017-04-21 15:08:18 -05:00
Brian
88649b06a6 use planner.z_fade_height, etc. instead of private, ubl-specific g29 fade height 2017-04-21 09:09:09 -05:00
LVD-AC
004928148c Tower angles
Adding '7-point' tower angle correction calibration
2017-04-21 12:48:45 +03:00
LVD-AC
76ec7a0f80 Adding upto 7*7 probe grids
- adding Cn 5, 6 and 7
2017-04-21 11:58:39 +03:00
LVD-AC
d4f593d200 Delete 'expert level'
and getting rid off verbose level 3 and configuration_adv settings
2017-04-21 11:58:39 +03:00
LVD-AC
13c8493878 M665 rework and related issues (all delta's)
- Making M665 compatible with repetier (see
http://reprap.org/wiki/G_code#M665:_Set_delta_configuration)

- M665 B also sets the radius for manual calibration menu

- Converting tower ajustment definitions to arrays - tower angle
corrections compatible with Esher 3D wizzard

- Only tower angles need to be adjustable with M665 and stored to EEPROM
- tower radius and diag rod can be adjusted in the FW only with #define
2017-04-21 11:58:39 +03:00
Scott Lahteine
e66d9f1313 Merge pull request #6406 from thinkyhead/test_remote
Refresh Marlin git helper scripts
2017-04-20 23:45:24 -05:00
Scott Lahteine
dd436ceeb7 Add 'mfdoc' and 'mfpub' scripts to help with documentation 2017-04-20 21:37:26 -05:00
Scott Lahteine
78308b1c0b New git helper scripts 'mfadd' and 'mfqp'
- `mfadd` adds and fetches a user’s fork of Marlin
- `mfqp` invokes `git commit -m`, `mfrb`, `git push -f`
2017-04-20 21:37:25 -05:00
Scott Lahteine
7b4c245de3 Improve existing git helper scripts 2017-04-20 21:37:25 -05:00
Scott Lahteine
06f4776be4 mfprune: fetch remotes, offer checkout option 2017-04-20 21:37:25 -05:00
Scott Lahteine
c73b62447c Merge pull request #6403 from thinkyhead/rc_flsun_clean
FLSUN and trailing whitespace cleanup
2017-04-20 20:48:41 -05:00
Scott Lahteine
e0e069c6d8 Clean up trailing whitespace 2017-04-20 17:52:07 -05:00
Scott Lahteine
9b94210394 Bring FLSUN config more up to date 2017-04-20 17:52:06 -05:00
Scott Lahteine
b0aa256bc0 Updates for all configs 2017-04-20 17:52:05 -05:00
Scott Lahteine
b6ed69571a Merge pull request #6400 from thinkyhead/rc_interrupt_macros
Add and apply interrupt helper macros
2017-04-20 17:17:21 -05:00
Scott Lahteine
ee46ce1743 Add and apply interrupt helper macros 2017-04-20 16:04:29 -05:00
Scott Lahteine
6131c62499 General cleanup 2017-04-20 16:04:29 -05:00
benlye
2c86dfd3b5 Fix compiler type conversion errors after LCD changes 2017-04-20 16:04:29 -05:00
Scott Lahteine
55f9e76610 Merge pull request #6367 from thinkyhead/rc_cleanup_followup
Cleanup after some direct commits
2017-04-20 15:13:24 -05:00
Scott Lahteine
d38a792a91 Merge pull request #6382 from MagoKimbra/fix_configuration_store
Fix double definition in configuration_store
2017-04-20 15:06:58 -05:00
Scott Lahteine
b98bc034ae Replace c_assert hack with static_assert 2017-04-19 13:07:35 -05:00
Scott Lahteine
5eb2b1a790 Clear up G29 compiler warnings 2017-04-19 13:07:35 -05:00
Scott Lahteine
4ce2a63db0 Apply const, spacing to Marlin_main.cpp 2017-04-19 13:07:34 -05:00
Scott Lahteine
e97f1284c1 Cleanup of pins testing code 2017-04-19 13:07:34 -05:00
Scott Lahteine
e9b53ae00c Cleanup after some direct commits
https://github.com/MarlinFirmware/Marlin/commit/5e9726530ff21d3bc62beaa6
ac1b9437c276130a
2017-04-19 13:07:34 -05:00
Scott Lahteine
e05d050a1e Add hex routine to print an address 2017-04-19 13:07:34 -05:00
Scott Lahteine
4542282f5e Fix broken TOGGLE macro in fastio.h 2017-04-19 12:38:13 -05:00
MagoKimbra
ed52275a14 Fix double definition in configuration_store 2017-04-18 17:57:40 +02:00
Scott Lahteine
de569e3d4e Merge pull request #6327 from Bob-the-Kuhn/M43-toggle-&-Z-probe-fixes
M43 Toggle & Z servo test - fix bug & add another check
2017-04-18 03:21:57 -05:00
Scott Lahteine
f33a650ecc Merge pull request #6368 from thinkyhead/rc_linear_advance_eeprom
Add Linear Advance values to EEPROM and LCD
2017-04-18 02:54:12 -05:00
Scott Lahteine
a00ae4790a Replace M905 with unique code M900 2017-04-17 16:39:37 -05:00
Scott Lahteine
1286d9603d Clean up and organize ultralcd.cpp 2017-04-17 16:39:36 -05:00
Scott Lahteine
3cdf78a79f MSG_VOLUMETRIC => MSG_FILAMENT 2017-04-17 16:39:36 -05:00
Thomas Moore
f8e77d6545 Add Linear Advance values to EEPROM and enable configuration of K via LCD 2017-04-17 16:39:36 -05:00
Scott Lahteine
eb2d073dae Add M905 R for setting the E/D ratio directly 2017-04-17 16:39:36 -05:00
Scott Lahteine
69dfa54a84 Use code_value_linear_units for known-linear axes 2017-04-17 16:39:36 -05:00
Scott Lahteine
b956f2642b Show M503 report with current linear units 2017-04-17 16:39:36 -05:00
Scott Lahteine
ba4a005ceb Merge pull request #6373 from mtowara/mt_makefile_fix
Fix Makefile build
2017-04-17 16:16:37 -05:00
towara
150b15c311 fix compiler errors generated by more stringent flags in Makefile:
- use volatile for registers
- avoid implicit casts
2017-04-17 11:59:47 +02:00
towara
f6095c9325 fix missing serial.cpp in Makefile 2017-04-17 11:59:03 +02:00
Scott Lahteine
871f92378c Tweak headings in EEPROM structure 2017-04-16 18:42:33 -05:00
Scott Lahteine
bf2548be4a Merge pull request #6362 from tcm0116/babystepping
Only queue babysteps if axis is in a known position
2017-04-16 17:46:06 -05:00
Scott Lahteine
bddd75aa5c Merge pull request #6363 from dot-bob/display_reset
Identifed a display initialization issue.
2017-04-16 17:44:44 -05:00
dot-bob
9c410ddf68 Fixed an issue where a display with a hardware reset pin (LCD_RESET) may not get initialized properly. 2017-04-15 22:45:15 -06:00
Thomas Moore
72a7fac461 Only queue babysteps if axis is in a known position 2017-04-15 23:19:43 -05:00
Roxy-3D
5e9726530f Setup to find data corruption and general clean up
This data corruption problem is very difficult.  Just changing the code
a little bit changes whether the problem even happens and what is
affected.  I need these changes in the main branch so I can operate with
the extra debug code always available and turned on.

Everything is setup such that if M100 is turned off or DEBUG(ECHO) is
turned off, the code is not affected.   M100 has been made a little bit
more inteligent so it can display the serial command buffers in a more
meaningful way (because the data corruption seems to often times end up
in that area).
2017-04-15 19:26:43 -05:00
Scott Lahteine
e519e95953 Merge pull request #6358 from thinkyhead/rc_doubleclick_fix
Show Cancel/Continue screen for ABL "Level Bed"
2017-04-15 17:25:37 -05:00
Scott Lahteine
a81606c680 Show Cancel/Continue screen for ABL "Level Bed" 2017-04-15 16:51:03 -05:00
Scott Lahteine
51021bc7b8 Merge pull request #6353 from thinkyhead/rc_endstop_coolness
Clean up endstop triggering code
2017-04-15 16:49:54 -05:00
Scott Lahteine
857dec0990 Merge pull request #6342 from benlye/benlye-fix-softspi
Fix softspi variant conditional for 1284p
2017-04-15 16:33:50 -05:00
Scott Lahteine
4e04383d18 Merge pull request #6354 from thinkyhead/rc_doubleclick_fix
Fix undefined symbol if DOUBLECLICK_FOR_Z_BABYSTEPPING and HAS_BED_PROBE defined
2017-04-15 16:06:29 -05:00
Thomas Moore
8dd0492e68 Show lcd_babystep_zoffset screen if DOUBLECLICK_FOR_Z_BABYSTEPPING is enabled and HAS_BED_PROBE is defined 2017-04-15 14:44:50 -05:00
benlye
0a2f60fab4 Make spi.h inclusion conditional
spi.h is only needed if HEATER_0_USES_MAX6675 is defined, so making its inclusion conditional on HEATER_0_USES_MAX6675 being defined.
2017-04-15 16:22:42 +01:00
Bob-the-Kuhn
60471b7592 minor improvements
Configuration_store.cpp - changed a couple of print statements so the
values were printed.  The old method resulted in the formula being
printed.

ubl_G29
1) added support for R option to P4.  Now probes all points unless R is
present and the number is greater than 0.

2) P2 - moved map print statement so it showed the point that was
currently being probed,  The old location did this only for the first
point.

3) P4 - Moved the map print for the same reason.

ultralcd.cpp - changed "Mesh Editor :" to "Mesh Editor" because the LCD
draw routine puts a ":" in automatically so you end up with an extra ":"
using the old message.
2017-04-15 09:31:55 -05:00
Scott Lahteine
25a61e9061 Improve motion-based endstop triggering code 2017-04-15 06:16:50 -05:00
Scott Lahteine
5a97a7be97 Merge pull request #6352 from thinkyhead/rc_patch_menu_bug
Fix compiler warning about z-offset callback
2017-04-15 03:35:16 -05:00
Scott Lahteine
a2356c2825 Fix compiler warning about z-offset callback 2017-04-15 02:50:27 -05:00
Scott Lahteine
3a40e637cd Merge pull request #6350 from thinkyhead/rc_more_dualx_logging
Add more Dual X logging
2017-04-15 02:02:54 -05:00
Scott Lahteine
037c964d26 Reverse bools on prepare_move sub-functions 2017-04-15 01:08:19 -05:00
Scott Lahteine
d9c4333806 Extra logging of Dual X modes 2017-04-15 01:08:19 -05:00
Scott Lahteine
8cccf69ef7 Merge pull request #6348 from thinkyhead/rc_tmc2130_clean_clean
TMC2130 update. Fixes, tune-ups, new features
2017-04-14 23:40:56 -05:00
Scott Lahteine
4067d15c92 Cleanup, extend TMC2130 implementation 2017-04-14 23:00:00 -05:00
Scott Lahteine
d60c02c5b1 Cleanup, extend TMC2130 configuration 2017-04-14 22:43:56 -05:00
Scott Lahteine
0e97b3d6d0 Fix some configuration spacing 2017-04-14 22:36:10 -05:00
Scott Lahteine
cf6f483378 Merge pull request #6187 from thinkyhead/rc_flsun_delta_autocal
Delta: DELTA_HEIGHT, G33 Auto-Calibrate, drop M206/M428, add M665 H
2017-04-14 22:32:12 -05:00
Scott Lahteine
24882adfbf Allow NO_WORKSPACE_OFFSETS with DELTA_AUTO_CALIBRATION
- On `DELTA` the `M665 H` option supplants `M206`
- On `DELTA` `NO_WORKSPACE_OFFSETS` only reverts `G92` behavior
- Spawn 4 conditionals based on `NO_WORKSPACE_OFFSETS`
- Optimize coordinate space conversion for `DELTA` workspace
- To keep EEPROM version, retain `home_offset[XYZ]`, just ignore XY
2017-04-14 21:56:49 -05:00
Bob-the-Kuhn
1acb84ba02 fix 1 bug, add error messages
===============================================

make changes requested by reviewers

===============================================

add M43 test to Travis, fix EOL, remove trailing spaces
2017-04-14 20:57:45 -05:00
Scott Lahteine
40dfafbe89 Add Travis CI test for FLSUN config 2017-04-14 19:46:31 -05:00
LVD-AC
8821963873 Implement delta auto-calibration and delta_height 2017-04-14 19:46:31 -05:00
Scott Lahteine
b305699046 Merge pull request #6341 from benlye/benlye-lcd_babystep_zoffset
Fix lcd_babystep_zoffset()
2017-04-14 19:11:46 -05:00
LVD-AC
03bda24d19 Add delta auto-calibration and configuration for Flsun AC 2017-04-14 19:08:14 -05:00
Scott Lahteine
396bd7b377 Update "firstpush" to open branch commits on Github 2017-04-14 19:06:31 -05:00
Scott Lahteine
1bd25fd2b3 Clean up config spacing, section headings, etc. 2017-04-14 19:06:31 -05:00
Scott Lahteine
153b0ae967 Tweak Delta Printer configuration note 2017-04-14 19:06:06 -05:00
Scott Lahteine
81ffd98dd9 Allow faux leveling 2017-04-14 19:06:06 -05:00
Scott Lahteine
2355d87e11 Merge pull request #6346 from thinkyhead/rc_broken_abl_test
Add support for SOLENOID_PROBE
2017-04-14 18:36:32 -05:00
Scott Lahteine
f4685c28b7 Reorder Conditionals_post.h and add comments 2017-04-14 18:18:21 -05:00
Scott Lahteine
5135be14ea Include Travis CI tests for 5 extruders / e-steppers 2017-04-14 18:18:20 -05:00
Scott Lahteine
0ac2b5c045 Additional 5 extruders support (solenoids, microstepping) 2017-04-14 18:18:20 -05:00
Scott Lahteine
fd2a0784ba Add support for SOLENOID_PROBE 2017-04-14 17:24:36 -05:00
Scott Lahteine
5803ba43a9 Expose EXT_SOLENOID as an advanced option 2017-04-14 17:24:36 -05:00
Scott Lahteine
ea734f910b Use direct pin manipulation whenever possible 2017-04-14 16:55:35 -05:00
Scott Lahteine
19d0c6a0c0 Patch to init W with RGBW_LED 2017-04-14 16:55:23 -05:00
Scott Lahteine
3e079660b0 Never define SLED_PIN 2017-04-14 16:36:32 -05:00
Scott Lahteine
76765a8279 Merge pull request #6337 from thinkyhead/rc_core_endstop_fix
CORExx endstop detection fixes
2017-04-14 14:24:58 -05:00
benlye
1a447d0047 Fix variant conditional for 1284p 2017-04-14 18:46:09 +01:00
benlye
1f9ee42750 Fix lcd_babystep_zoffset()
Resolve 'steps_to_mm was not declared in this scope' compilation error after recent changes to merge babystepping with M851
2017-04-14 18:38:35 +01:00
Bob-the-Kuhn
445d39e95a CORExx endstop detection fixes
1. The CORExx printers were checking more endstop axis than needed.

2. Removed all the CORE_xx_NOT logic.  The motor_direction(xx) routine
always returns the correct data so it is not needed.  It was actually
cause the wrong direction to be checked in some cases.

3. Made the logic/defines for X, Y & Z axis all the same.  The old logic
checked inappropriate configurations for Y and didn't check all the
correct configurations on Z.

4. Added a check for zero steps before the X, Y & Z axis.  Previously
would check the they axis even if there were no movement.
2017-04-13 21:43:37 -05:00
Roxy-3D
28fec61f92 M100 Fixes and Features
All the memory accesses need to be unsigned char in  order to avoid
false errors being detected.   Two new features are available for
developers to call into the M100 functionality to look for data
corruption.
2017-04-13 18:20:53 -05:00
Scott Lahteine
2f2835e622 Merge pull request #6332 from thinkyhead/rc_babystep_zprobe
Make BABYSTEP_ZPROBE_OFFSET an optional feature
2017-04-13 16:50:08 -05:00
Scott Lahteine
52c3ace102 Add BABYSTEP_ZPROBE_OFFSET as an optional feature 2017-04-13 16:29:43 -05:00
Scott Lahteine
cd4e6abec8 Group BABYSTEPPING options together 2017-04-13 16:26:45 -05:00
Scott Lahteine
972c9655e9 Merge pull request #6245 from thinkyhead/rc_babystep_zprobe
BABYSTEPPING updates Z probe offset
2017-04-13 16:06:07 -05:00
Scott Lahteine
60ac41a32c Add code to handle changes to zprobe_zoffset 2017-04-13 15:46:35 -05:00
Scott Lahteine
8fa4209916 Movement/adjustment should be reverse of probe offset change 2017-04-13 15:46:05 -05:00
Thomas Moore
361655828f Use babystepping to adjust bed probe z-offset 2017-04-13 15:46:05 -05:00
Scott Lahteine
36e5c7c389 Merge pull request #6330 from thinkyhead/rc_improvements
Sanity check per-axis options' array sizes
2017-04-13 13:08:44 -05:00
Scott Lahteine
02fca543bb Merge pull request #6272 from thinkyhead/rc_adc_variable_rate
Make ADC sensor reading frequency adjustable
2017-04-13 12:49:31 -05:00
Scott Lahteine
34308368c0 Sanity check per-axis settings for size 2017-04-13 11:35:20 -05:00
Scott Lahteine
ac96ae89f9 Apply const in Stepper::isr 2017-04-13 06:20:36 -05:00
Scott Lahteine
2fa1e882d0 Merge pull request #6325 from thinkyhead/rc_M20_with_size
Simplified M20 with size
2017-04-13 05:06:52 -05:00
Bob-the-Kuhn
1b12fea0fa simplified M20 with size 2017-04-13 04:56:58 -05:00
Scott Lahteine
4022b971db Merge pull request #6315 from thinkyhead/rc_unify_M421
Unify M421
2017-04-12 19:43:28 -05:00
Scott Lahteine
b236562354 Merge pull request #6306 from thinkyhead/cleanup_after_6302
Adjustments to M100
2017-04-12 19:12:27 -05:00
Scott Lahteine
5e4f4d387f Swap MBL z_values dimensions to [X][Y] 2017-04-12 17:24:05 -05:00
Scott Lahteine
f81b518a03 Add Travis tests for optional M100 features 2017-04-12 17:07:22 -05:00
Scott Lahteine
063f641651 Unify M421 2017-04-11 15:46:13 -05:00
Scott Lahteine
6d5400dc31 Merge pull request #6240 from thinkyhead/rebuild_rgb_led
Extend RGB LED with Printer Events
2017-04-11 15:16:57 -05:00
Scott Lahteine
dac21ec680 Add support for an RGBW LED 2017-04-11 12:58:55 -05:00
Scott Lahteine
e7746ffee4 Extend RGB LED support, adding Printer Events 2017-04-11 12:15:41 -05:00
Scott Lahteine
c7063eb55c theTarget => target_temp 2017-04-11 12:15:41 -05:00
Scott Lahteine
36bda2bade Add HAS_RESUME_CONTINUE shorthand macro 2017-04-11 12:15:40 -05:00
Scott Lahteine
53e6c33c37 2 is DXC_DUPLICATION_MODE 2017-04-11 12:15:40 -05:00
Scott Lahteine
a2cb0a3d54 Use multiply for delta probe constraint 2017-04-11 12:15:40 -05:00
Scott Lahteine
6487c96a4a Merge pull request #6313 from Kaibob2/patch-10
Allow 10mm Movements for Z-Axis
2017-04-11 12:04:10 -05:00
Scott Lahteine
944218f7da Merge pull request #6309 from thinkyhead/rc_fix_minimum_pulse
Fix MINIMUM_STEPPER_PULSE calculations
2017-04-11 11:54:26 -05:00
Kai
001bc14255 Allow 10mm Movements for Z-Axis
I use the movement options via LCD quite often. Especially to get the nozzle out of the way. I see no reason, why the 10mm option is disabled for the Z-Axis, this is why i always delete this line when i compile a new version.
If this is unwanted, please just close this PR
2017-04-11 18:39:26 +02:00
Scott Lahteine
6a9b008044 Fix MINIMUM_STEPPER_PULSE maths 2017-04-11 11:11:17 -05:00
Scott Lahteine
68773f4486 Simplify stepper macros by renaming enable/disable macros 2017-04-11 11:10:26 -05:00
Scott Lahteine
e02a5a6371 Add macros for delays by machine cycle 2017-04-11 09:18:32 -05:00
Scott Lahteine
4ea447959e Merge pull request #6311 from thinkyhead/rc_bare_M109_M190
Have M109 / M190 do nothing with no parameters
2017-04-11 06:10:31 -05:00
Scott Lahteine
ecc537015a Have M109 / M190 do nothing with no parameters 2017-04-11 05:06:25 -05:00
Scott Lahteine
03aa9a390e Apply coding standards to M100, break up into functions 2017-04-10 21:09:43 -05:00
Scott Lahteine
48c16fc6ef Merge pull request #6307 from thinkyhead/rc_less_no_reentrance
Only lcd_synchronize needs no_reentry
2017-04-10 20:58:32 -05:00
Scott Lahteine
4fcfe926d6 Only lcd_synchronize needs no_reentry 2017-04-10 20:13:23 -05:00
Scott Lahteine
67fb7f82ac Merge pull request #6283 from thinkyhead/rc_eeprom_z_fade
Save / restore z_fade_height in EEPROM
2017-04-10 20:05:20 -05:00
Scott Lahteine
eff5af569b Merge pull request #6300 from MagoKimbra/rc_fix_mesh_report
Fix mbl_mesh_report
2017-04-10 19:37:19 -05:00
Scott Lahteine
4a18968c10 Merge pull request #6297 from Kaibob2/patch-9
Fix EPROM -> EEPROM
2017-04-10 19:35:30 -05:00
Roxy-3D
ba85faabc0 Fix M100 Free Memory Checker
M100 had numerious changes and quit working.   Part of the problem is
the overloading of the SERIAL_PROTOCOL functions.   Also, some of the
address arithmatic was changed to use char *ptr and passing ptr into the
SERIAL_PROTOCOL functions caused them to try to print a string instead
of a number.     M100 is working again.   Let's keep it that way!

M100 has been expanded to now have a function  int
free_memory_is_corrupted()  that can be called from other code to see if
the free space is still contiguous.  It may make sense to add a flag to
control its verbose nature but right now, the extra chit chat is very
helpful to know int free_memory_is_corrupted()  is doing the right thing
and what it found at various points when it was called.     A 'Show &
Tell' is coming up with int free_memory_is_corrupted().
2017-04-10 15:33:55 -05:00
Kai
3b82db5fe9 Missing semicolon in ultralcd.cpp
When PARK_HEAD_ON_PAUSE is defined Marlin won't compile because of two missing semicolon.
2017-04-10 14:45:51 -05:00
MagoKimbra
7d2e637867 Fix mbl_mesh_report 2017-04-10 20:50:19 +02:00
Kai
afeb0452ef Fix EPROM -> EEPROM
These fixes are neede because before it showed the englisch text even if language = de was selected
2017-04-10 18:37:00 +02:00
Scott Lahteine
7f950a80c0 Make ADC sensor reading frequency adjustable 2017-04-09 22:18:21 -05:00
Scott Lahteine
dad907b923 Merge pull request #6293 from thinkyhead/rc_move_toshiba
Put TOSHIBA with other stepper driver options
2017-04-09 22:08:36 -05:00
Scott Lahteine
786af73e24 Convert config code to a static class 2017-04-09 22:06:41 -05:00
james94jeans2
5b9476fe78 Added z_fade_height to EEPROM-Settings
Firmware was forgetting the z_fade_height in Planner, set by M420 Z<f>,
after each reset or loading settings from EEPROM. Added the float
z_fade_height to EEPROM-Storage, now remembers the value.
2017-04-09 21:16:58 -05:00
Scott Lahteine
9343f6a95f Put TOSHIBA with other stepper driver options 2017-04-09 20:52:49 -05:00
Scott Lahteine
7a704af5e6 Merge pull request #6284 from thinkyhead/rc_wt150_rebase
wt150 (Mightyboard Rev E) & RRD Full Graphic Smart Controller
2017-04-09 20:27:44 -05:00
Scott Lahteine
2bde7940e0 Merge pull request #6289 from zlowred/RCBugFix
Fixed comparison of float values to NaN
2017-04-09 19:39:04 -05:00
Max Matveev
2031fb913b Fixed comparison of float values to NaN 2017-04-09 20:28:46 +02:00
Scott Lahteine
e48a52a530 Patch a display issue with LCD_DECIMAL_SMALL_XY
The `ftostr4sign` function got munged by the `WITHIN` patch
2017-04-09 10:25:35 -05:00
Scott Lahteine
1a3cd6a090 Merge pull request #6213 from thinkyhead/rc_gitattributes
Init bed_level_virt_interpolate on EEPROM load
2017-04-09 08:13:11 -05:00
Scott Lahteine
314a02e2d5 Toggle with XOR 2017-04-09 07:58:47 -05:00
Scott Lahteine
cfad4736cd Merge pull request #6285 from thinkyhead/rc_cheaptronic_v2
Cheaptronic V2
2017-04-09 07:09:23 -05:00
Scott Lahteine
8bc0d90b00 Init bed_level_virt_interpolate on EEPROM load 2017-04-09 07:04:20 -05:00
MD
20dd5376b8 Cheaptronic V2
Add support for new electronics
www.reprapobchod.cz
2017-04-09 06:57:43 -05:00
Scott Lahteine
4cdda5615b Bring other configs up to date with wt150 changes 2017-04-09 06:45:42 -05:00
Paweł Stawicki
9b0885f4f6 Allow boards without a thermistor 2017-04-09 06:45:41 -05:00
Paweł Stawicki
64cfcebe66 Update SlowSoftI2CMaster link. MightyBoard digipots I2C bus has no resistors. 2017-04-09 06:45:03 -05:00
Paweł Stawicki
0eb16d9ff7 Add example config for the wt150 printer with RepRapDiscount Full Graphic Smart Controller 2017-04-09 06:44:54 -05:00
Paweł Stawicki
652bedfa18 Add RepRapDiscount Full Graphic Smart Controller support to MIGHTYBOARD REVE 2017-04-09 06:44:53 -05:00
Paweł Stawicki
44cdebb8f1 Add software spi support for max6675 2017-04-09 06:44:53 -05:00
Paweł Stawicki
191fec009f Add digipot i2c control for MCP4018 2017-04-09 06:44:53 -05:00
Scott Lahteine
e5b16081cb Update TinyBoy2 configurations 2017-04-09 06:44:53 -05:00
Scott Lahteine
1855534f20 Config files cleanup 2017-04-09 06:44:52 -05:00
Scott Lahteine
2f5e934a19 Merge pull request #6282 from thinkyhead/rc_cleanup_and_5_extruders
Additional missed patches
2017-04-09 04:35:08 -05:00
Scott Lahteine
c26a315d0b Additional missed patches 2017-04-09 04:24:23 -05:00
Scott Lahteine
635f182478 Merge pull request #6281 from thinkyhead/rc_cleanup_and_5_extruders
More patches for 5 extruders
2017-04-09 04:07:22 -05:00
Scott Lahteine
39617e10b8 Patch configs comment formatting 2017-04-09 03:49:16 -05:00
Scott Lahteine
c54f6cf23d Updates to support 5 extruders 2017-04-09 03:49:16 -05:00
Scott Lahteine
2b88ccd0aa Apply UBL mesh bounds to remaining configs 2017-04-09 03:49:15 -05:00
Scott Lahteine
60be3d264b Macros to print floats, hiding imprecision 2017-04-09 03:48:40 -05:00
Scott Lahteine
b356d73239 Merge pull request #6278 from thinkyhead/pr_delta_angles
Followup to additional delta trim options
2017-04-08 22:25:57 -05:00
Jimmy Envall
f78d44e91a Added support for delta tower angle corrections. 2017-04-08 21:13:44 -05:00
Scott Lahteine
d3b4d84586 Merge pull request #6277 from thinkyhead/pr_roxy3d_rcbugfix
Unify UBL Command Parsing
2017-04-08 20:17:46 -05:00
Scott Lahteine
98c9de11e1 Merge pull request #6266 from thinkyhead/rc_cleanup_after
Cleanup after recent merges
2017-04-08 20:08:15 -05:00
Scott Lahteine
d4ce839351 Cleanup following Pins Debug update 2017-04-08 18:59:57 -05:00
Scott Lahteine
c7a8f7970b Formatting / cleanup 2017-04-08 18:59:57 -05:00
Scott Lahteine
29d4ec8257 Support 5 extruder auto fans 2017-04-08 18:59:57 -05:00
Scott Lahteine
824f3c1c0d Fix up configuration comments 2017-04-08 18:59:56 -05:00
Scott Lahteine
995ed90248 Clean up Filament Width Sensor comments 2017-04-08 18:59:56 -05:00
Scott Lahteine
5a7b810fdd General comment cleanup 2017-04-08 18:58:33 -05:00
Scott Lahteine
0027c22839 Drop extraneous calls to lcd_update 2017-04-08 18:58:33 -05:00
Scott Lahteine
d6db7a9b03 patch "step_remaining" 2017-04-08 18:13:20 -05:00
Scott Lahteine
cbc2331187 Use LCD_MESSAGEPGM over lcd_setstatuspgm 2017-04-08 18:04:39 -05:00
Scott Lahteine
3729510b1e Set and check main parameter values, report all errors 2017-04-08 17:15:55 -05:00
Roxy-3D
34d3ed9ab1 These items were removed from the UBL Command Parsing
Having these items randomly (and errorniously) disappear cost me several
hours of work yesterday.
2017-04-08 15:30:20 -05:00
Scott Lahteine
15edb41cee Patches to UBL 2017-04-08 14:59:14 -05:00
Roxy-3D
14cf527bb8 Getting setup for debugging 2017-04-08 14:59:14 -05:00
Scott Lahteine
f8408036f2 Merge pull request #6264 from thinkyhead/rc_five_extruders
Support up to 5 extruders in Marlin
2017-04-07 12:48:56 -05:00
Bob-the-Kuhn
5212cb8304 Merge pull request #6271 from Bob-the-Kuhn/MCP4728-consistency-2
MCP4728 consistency ... Finish name change
2017-04-07 11:31:19 -05:00
Bob-the-Kuhn
f7fc49c3a3 Finish name change
DAC_STEPPER_DFLT wasn't changed to DAC_MOTOR_CURRENT_DEFAULT in all
places on PR #6124
2017-04-07 11:05:24 -05:00
Scott Lahteine
832064e4f2 Implementation changes to support 5 extruders 2017-04-07 10:46:37 -05:00
Scott Lahteine
04050237f0 Header and pins changes to support 5 extruders 2017-04-07 10:46:36 -05:00
Scott Lahteine
2a84122edd Configuration changes to support 5 extruders 2017-04-07 10:46:35 -05:00
Scott Lahteine
edf18977c1 Patch pins files hotends/e-steppers sanity check 2017-04-07 10:46:33 -05:00
Scott Lahteine
dc84678fc1 Fix HOTEND_STATUS_ITEM for graphical display 2017-04-06 23:07:30 -05:00
Scott Lahteine
a0de5d94e2 Merge pull request #6258 from benlye/benlye-bilinearfix2
Better fix for bilinear Z offset and G29 Z (update to #6251)
2017-04-06 20:51:57 -05:00
Scott Lahteine
b23aef5b8d Merge pull request #6190 from Bob-the-Kuhn/Stop-and-Kill-prints---round-2
Message for every KILL and STOP (also need delays)
2017-04-06 20:40:12 -05:00
Roxy-3D
945303c0d5 eleminate bootscreen.h 2017-04-06 19:55:41 -05:00
Roxy-3D
ef3da3971e Update ubl.h 2017-04-06 19:55:41 -05:00
Roxy-3D
8644dc170b get synchronized to current file names 2017-04-06 19:55:41 -05:00
Roxy-3D
1451b7eacf UBL's Grid Based Leveling code
Pretty much...  The code is in place.  Still more work to do.    But it
has a lot of hooks and variables in other code, so commit and merge
before I pick up a million 'Conflicts'.
2017-04-06 19:55:41 -05:00
Bob-the-Kuhn
549055f20c Merge pull request #6124 from Bob-the-Kuhn/MCP4728-consistency
MCP4728 consistency & fix ultralcd.cpp (PRINTRBOARD Rev F and RIGIDBOARD V2)
2017-04-06 16:35:50 -05:00
Bob-the-Kuhn
a77875c9d2 Merge pull request #6114 from Bob-the-Kuhn/try2-add-BLTouch-retry
Another BLTouch retry place (replaces PR #6108)
2017-04-06 16:25:55 -05:00
Bob-the-Kuhn
3b9ff2cb12 Merge pull request #5676 from Bob-the-Kuhn/configuration.h
Configuration.h - reword Z PROBE section
2017-04-06 16:18:34 -05:00
Bob-the-Kuhn
6643d553f6 # This is a combination of 2 commits.
# This is the 1st commit message:

MCP4728 consistency & fix ultralcd.cpp

The MCP4728 DAC controls the stepper motor current strenth on the
PRINTRBOARD Rev F and RIGIDBOARD V2 boards.

PR #5792 on 9 FEB 2017 implemented default drive percentages but only on
the RIGIDBOARD V2.

This change moves the default settings to Configuration_adv.h.

Also, ultralcd.cpp won't compile because of a type def conflict.
Changed it to match the one in stepper_dac.cpp

===========================================================

reword stepper curent section for clarity

===========================================================

change name & improve comments

===========================================================

changed name from A4JP to SCOOVO_X9H per PR #6139

# This is the commit message #2:

fix typo
2017-04-06 16:16:27 -05:00
Bob-the-Kuhn
a44b3432c1 add BLTouch retry to a second place & add/update delays
=================================================

implement requested changes

=================================================

remove delays (they're in another PR) & move return
2017-04-06 16:13:07 -05:00
Bob-the-Kuhn
a5abc61fb9 Merge pull request #6219 from Bob-the-Kuhn/Servo-probe-and-toggle-pins
M43 - add Toggle utility and Z servo utility (replaces PR #5864)
2017-04-06 16:10:50 -05:00
Bob-the-Kuhn
f87012a063 Merge pull request #5762 from Bob-the-Kuhn/Z_DUAL_ENDSTOP-make-offset-a-configuration-item
Z_DUAL_ENDSTOPS -  make offset a configuration item
2017-04-06 16:09:15 -05:00
Bob-the-Kuhn
3b8926bd09 improved wording, consolidation of info, BLTouch warning
==============================================

clarified BLTouch calculation & changed comment delimitters/flags

I found it hard to pickout the various sections in this area so I
changed most comments from // style to /** ... */

Made the BLTouch calculation simpler and clarified the units of measure
for the result.

============================================

add changes to example configurations

============================================

add TinyBoy2 to this PR & add BLTouch Delay
2017-04-06 16:06:01 -05:00
Scott Lahteine
55d296aaf0 pinsDebug with more features, uses less RAM
I've just uploaded a major change to pinsDebug.
The big change was creating an array in FLASH that contained every
active pin definition. That reduced the RAM memory usage considerably
but increased the FLASH usage.
Creating the array requires going through the pin list twice. Rather
than having two copies of it in the code I moved the list out to another
file (pinsDebug_list.h) and then just did two #includes.
From the user’s view they’ll see the following changes:
1. Now reports all the names assigned to a pin
2. The port is now reported in addition to the pin number.
3. When PWM0A & PWM1C share a pin, both PWMs are reported
4. More PWM/Timer info is reported
One new item that may cause some concern is the usage of the LINE
predefined preprocessor macro. It may not be available if the Arduino
IDE goes to a different compiler.

Includes support for 1284 & 1286 families.

Memory usage changes when enabling PINS_DEBUGGING:
ATmega2560
FLASH
.           without   52576
.           with new  64592
.           with old  62826
.           new-out   12016
.           old-out   10250
.           new-old   1766
.
RAM
.           without   2807
.           with new  2875
.           with old  3545
.           new-out   68
.           old-out   738
.           new-old   -670

==================================================================

minor changes - mostly formatting

1) added newline to end of teensyduino file

2) changed flag name from TEENSYDUINO to TEENSYDUINO_IDE.  Got warnings
about redefining TEENSYDUINO

3) removed some trailing spaces

reduce PROGMEM size & update pin list

Reduced PROGMEM usage by
1) converting often used macro to a function
2) moved as much as possible into the function

This required creating two arrays of address pointers for the PWM
registers.

==================================================================

update with new M3, M4, M5 pin names

==================================================================

report I/O status for unused/unknown pins
2017-04-06 16:06:01 -05:00
Scott Lahteine
e116723b8b Adjust indentation in ubl.h 2017-04-06 16:06:00 -05:00
Scott Lahteine
1b3a26f2f5 Rename all UBL files with a ubl_ prefix 2017-04-06 16:06:00 -05:00
Scott Lahteine
d13991ae18 Use same config name for all mesh dimensions 2017-04-06 16:05:59 -05:00
Bob-the-Kuhn
f9686a108c add Z servo test and toggle pins to M43 2017-04-06 15:59:38 -05:00
Scott Lahteine
62cbaa302e Z_DUAL_ENDSTOP - make offset a configuration item
The offset for Z_DUAL_ENDSTOP (z_endstop_adj) is already in Marlin.
This PR just makes it a configuration item.

z_endstop_adj is initialized in two places so both had to be modified.
2017-04-06 15:57:10 -05:00
Bob-the-Kuhn
3b6333c613 Merge pull request #5668 from Bob-the-Kuhn/pinsDebug-PROGMEM
pinsDebug with more features, uses less RAM
2017-04-06 15:51:45 -05:00
Scott Lahteine
c9e35004e7 pinsDebug with more features, uses less RAM
I've just uploaded a major change to pinsDebug.
The big change was creating an array in FLASH that contained every
active pin definition. That reduced the RAM memory usage considerably
but increased the FLASH usage.
Creating the array requires going through the pin list twice. Rather
than having two copies of it in the code I moved the list out to another
file (pinsDebug_list.h) and then just did two #includes.
From the user’s view they’ll see the following changes:
1. Now reports all the names assigned to a pin
2. The port is now reported in addition to the pin number.
3. When PWM0A & PWM1C share a pin, both PWMs are reported
4. More PWM/Timer info is reported
One new item that may cause some concern is the usage of the LINE
predefined preprocessor macro. It may not be available if the Arduino
IDE goes to a different compiler.

Includes support for 1284 & 1286 families.

Memory usage changes when enabling PINS_DEBUGGING:
ATmega2560
FLASH
.           without   52576
.           with new  64592
.           with old  62826
.           new-out   12016
.           old-out   10250
.           new-old   1766
.
RAM
.           without   2807
.           with new  2875
.           with old  3545
.           new-out   68
.           old-out   738
.           new-old   -670

==================================================================

minor changes - mostly formatting

1) added newline to end of teensyduino file

2) changed flag name from TEENSYDUINO to TEENSYDUINO_IDE.  Got warnings
about redefining TEENSYDUINO

3) removed some trailing spaces

reduce PROGMEM size & update pin list

Reduced PROGMEM usage by
1) converting often used macro to a function
2) moved as much as possible into the function

This required creating two arrays of address pointers for the PWM
registers.

==================================================================

update with new M3, M4, M5 pin names

==================================================================

report I/O status for unused/unknown pins
2017-04-06 14:46:28 -05:00
Scott Lahteine
7dfe2cc132 Merge pull request #6254 from thinkyhead/rc_ubl_rename
Group all UBL files via a common prefix
2017-04-06 05:46:18 -05:00
Scott Lahteine
4abd53f65a Adjust indentation in ubl.h 2017-04-06 05:36:16 -05:00
Scott Lahteine
f5c5c1f771 Rename all UBL files with a ubl_ prefix 2017-04-06 05:33:27 -05:00
Scott Lahteine
11430b6d33 Merge pull request #6256 from thinkyhead/rc_unify_grid_size
Use same config name for all mesh dimensions
2017-04-06 05:30:28 -05:00
benlye
f1d50ac1dc Fixing bilinear Z offset and G29 Z
The fix in #6251 for bilinear Z offset was flawed and broke the Z parameter of G29 for bilinear levelling.  This is reverted and a different fix is used for the double-addition of the Z-probe offset to the bilinear correction grid.
2017-04-06 07:41:46 +01:00
Scott Lahteine
eb1e6aa29b Use same config name for all mesh dimensions 2017-04-06 00:42:52 -05:00
Scott Lahteine
034e912c85 Merge pull request #6248 from thinkyhead/rc_marlin_scad_mesh
Add hidden option to output Bilinear grids in JSON
2017-04-06 00:36:45 -05:00
Scott Lahteine
c961dd084d Add hidden option to output Bilinear grids in JSON 2017-04-05 23:43:17 -05:00
Scott Lahteine
bc09e862a9 Re-enable .cpp as LF in .gitattributes 2017-04-05 22:30:30 -05:00
Scott Lahteine
df7b4252fd Reduce M420 code for UBL slightly 2017-04-05 22:30:29 -05:00
Scott Lahteine
8866158d03 Add LEVELING_DATA as a capability 2017-04-05 22:30:28 -05:00
benlye
0a2b4f3486 Fix bilinear levelling z offset
Since run_probe was altered to return the probe Z position rather than the nozzle Z position bilinear levelling has been broken because the Z-offset has been applied twice - once in the run_probe function, and then again in the G29 code for bilinear levelling.
2017-04-05 22:01:40 -05:00
Scott Lahteine
44a849bdce Fix broken M206/M428/G92 offsets 2017-04-05 22:01:37 -05:00
Roxy-3D
52978e5ba5 Fix spelling mistake when UBL's mesh is Inactive 2017-04-02 20:07:09 -05:00
Roxy-3D
0423e93c42 Fix M421 AUTO_BED_LEVELING_BILINEAR and AUTO_BED_LEVELING_UBL
M421 was not connected up for AUTO_BED_LEVELING_BILINEAR.
M421 needed to migrate mesh data to new UBL EEPROM layout.
2017-04-02 16:46:37 -05:00
Scott Lahteine
3412950abc Merge pull request #6209 from thinkyhead/rc_psu_zero
Power Supply 0 as "General"
2017-04-02 16:44:42 -05:00
Roxy-3D
3e9e94801f Fix problem described in issue # 6175
As it turns out...   an unsigned int can not go to less than 0,  so the
loop never terminates.
2017-04-02 13:00:27 -05:00
Scott Lahteine
a37a605fee Merge pull request #6217 from thinkyhead/rc_fix_invisibles_to_most
Patch .gitattributes till UBL line endings are fixed
2017-04-02 12:52:26 -05:00
Scott Lahteine
01a293b6e3 Patch .gitattributes till UBL line endings are fixed 2017-04-02 12:50:02 -05:00
Scott Lahteine
289e3d6844 Merge pull request #6215 from thinkyhead/rc_bed_false_alarm
Fix thermal runaway when nonexistent bed temp is set
2017-04-02 11:59:58 -05:00
Scott Lahteine
1c69a155cf Merge pull request #6214 from thinkyhead/rc_bltouch_delay_opt
Configurable delay for BLTouch servo emulation
2017-04-02 11:59:34 -05:00
Scott Lahteine
948728e63b Fix line-endings in UBL_G29 2017-04-02 11:48:26 -05:00
Scott Lahteine
699310d1d2 Fix: Thermal runaway if nonexistent bed's temp is set 2017-04-02 11:48:10 -05:00
Scott Lahteine
c56eec29f0 Configurable delay for BLTouch servo emulation 2017-04-02 11:14:53 -05:00
Scott Lahteine
deaad78df9 Merge pull request #5678 from Bob-the-Kuhn/G38-optional-double-tap
G38 bug fix, made double touch optional & reverted to Z_MIN_PROBE
2017-04-02 10:32:04 -05:00
Scott Lahteine
b3e9977f97 Merge pull request #6212 from thinkyhead/rc_gitattributes
Fix LCD preheat menus
2017-04-02 09:54:13 -05:00
Scott Lahteine
5bce731962 Fix LCD preheat menus 2017-04-02 09:32:22 -05:00
Scott Lahteine
9faa8c4704 Merge pull request #6210 from thinkyhead/rc_gitattributes
Add .gitattributes to normalize line endings
2017-04-02 08:56:51 -05:00
Scott Lahteine
4c72167af3 Prevent a warning on echo_command 2017-04-02 08:36:58 -05:00
Scott Lahteine
9b5fd9522e Fix formatting, order for a UBL change 2017-04-02 07:15:40 -05:00
Scott Lahteine
f0ef8a1cbd Add .gitattributes to normalize line endings 2017-04-02 06:47:52 -05:00
Tannoo
54173c80ad Power Supply 0 as "General" 2017-04-02 06:21:34 -05:00
Scott Lahteine
883c6762c4 Merge pull request #6208 from thinkyhead/rc_parity_with_32bit
Patch MarlinSerial to match up with 32-bit version
2017-04-02 05:13:03 -05:00
Scott Lahteine
a2775d0c70 can wstring be removed? 2017-04-02 04:43:33 -05:00
Scott Lahteine
de4e19f17e Patch MarlinSerial to match up with 32-bit version 2017-04-02 04:39:18 -05:00
Scott Lahteine
34b23ff312 Merge pull request #6202 from thinkyhead/rc_fix_broken_ubl
Patching up UBL, vetting recent commits
2017-04-02 03:51:38 -05:00
Scott Lahteine
2cbc7b4b73 Relocate serial macros and functions 2017-04-02 01:05:25 -05:00
Scott Lahteine
eaa66f3c46 Indent MarlinSerial code 2017-04-02 01:05:25 -05:00
Scott Lahteine
7a7a80e6c5 status_printf => lcd_status_printf_P 2017-04-02 01:05:25 -05:00
Scott Lahteine
0e6ec34228 Use PSTR versions of lcd_status... to save SRAM 2017-04-02 00:45:39 -05:00
Scott Lahteine
34e2420b9b Apply const args, clean up find_closest_circle_to_print 2017-04-01 23:15:41 -05:00
Scott Lahteine
e19fbd27ce Minor spelling patch 2017-04-01 23:08:00 -05:00
Scott Lahteine
790a3e9a8c Remove extraneous check of UBL_G26_MESH_EDITING 2017-04-01 23:03:40 -05:00
Scott Lahteine
7310110ec0 Fix logic of UBL::fade_scaling_factor_for_z 2017-04-01 22:52:48 -05:00
Scott Lahteine
a7aa70e79a Merge pull request #6201 from thinkyhead/rc_fix_broken_ubl
Fix broken auto#.g, some other regressions
2017-04-01 22:14:04 -05:00
Scott Lahteine
1a775cecac Revert behavior of enqueue_and_echo_commands_P 2017-04-01 21:53:46 -05:00
Scott Lahteine
79d42d87c1 Syntax cleanup 2017-04-01 21:53:46 -05:00
Scott Lahteine
b47fd31c37 Revert some changes to UBL 2017-04-01 21:53:45 -05:00
Bob-the-Kuhn
185337e787 add delays to allow stop & kill messages to get out 2017-04-01 00:23:14 -05:00
Scott Lahteine
63abb65146 Update description of PINS_DEBUGGING 2017-03-31 18:57:48 -05:00
Scott Lahteine
f75aa4d5be Merge pull request #6050 from thinkyhead/rc_probe_manually
Add PROBE_MANUALLY — ABL without a probe
2017-03-31 12:27:33 -05:00
Scott Lahteine
73e193da1d Implement LCD_BED_LEVELING for PROBE_MANUALLY 2017-03-31 11:50:18 -05:00
Scott Lahteine
fcadc7bb1a Implement the "manual" option for ABL 2017-03-31 11:50:18 -05:00
Scott Lahteine
9e22184936 Add a "manual" option for ABL 2017-03-31 11:50:18 -05:00
Scott Lahteine
541165e878 Merge pull request #6181 from thinkyhead/rc_ubl_further_fixes
Further adjustments to UBL code
2017-03-31 11:35:02 -05:00
Scott Lahteine
b19a15fa7f Within applied to UBL 2017-03-31 11:12:57 -05:00
Scott Lahteine
342ee458ae Additional UBL fixes, optimizations 2017-03-31 11:12:57 -05:00
Scott Lahteine
a5e085cbea Have run_probe() return probe Z, not nozzle Z 2017-03-31 09:27:49 -05:00
Scott Lahteine
4487d22d56 Apply FIXFLOAT macro 2017-03-31 09:27:48 -05:00
Scott Lahteine
6cac0f43eb MBL fiddle 2017-03-31 09:27:48 -05:00
Scott Lahteine
25a6bfa7ed Add and apply WITHIN macro 2017-03-31 09:27:48 -05:00
Scott Lahteine
81136c1e82 Merge pull request #6177 from thinkyhead/rc_tinyboy
Support for TinyBoy 2 3D printer (and its OLED display)
2017-03-31 04:31:47 -05:00
Scott Lahteine
93aad54dc1 Clean up code, remove _now command function 2017-03-31 04:17:31 -05:00
Stefan Brüns
6ba6c92a81 Add example configuration for TinyBoy L10/L16
The TB2 is a Indiegogo funded 3d printer. It uses a MKS SMELZI V1.0
main board (based on MELZI, i.e. Sanguinololu). I comes as a complete kit,
including display and panel.
Two variants exists, L10 and L16, with a height of 100 and 160 mm.
The heating function of the provided bed can enabled by soldering a
thermistor and some wires to it.

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-31 04:05:35 -05:00
Stefan Brüns
0fe57ad4f5 Add Support TinyBoy2 OLED/Encoder panel
The OLED is driven by an SSD1306, connected to the board via
I2C, the rotary encoder is connected to 3 GPIO pins.

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-31 04:05:34 -05:00
Scott Lahteine
baadb11536 Merge pull request #6174 from thinkyhead/rc_ubl_continued
UBL additional cleanup
2017-03-31 03:39:50 -05:00
Scott Lahteine
65ca6472ba Make G26 compatible with G92 and M206 2017-03-31 02:20:20 -05:00
Scott Lahteine
4902fd4e95 More data in UBL class, make it a static class
- Make all `unified_bed_leveling` data/methods static
- Move some UBL-related variables into the class
- Replace `map_[xy]_index_to_bed_location` with `mesh_index_to_[xy]pos`
2017-03-31 02:20:20 -05:00
Scott Lahteine
edbc024d76 Disable UBL_G26_MESH_EDITING by default 2017-03-31 02:20:20 -05:00
Scott Lahteine
9e4bd6b3b5 Further repairs to UBL, comments, spacing 2017-03-31 02:20:20 -05:00
Bob-the-Kuhn
f3618c3337 Reduce UBL RAM usage by making G26/G29 optional 2017-03-31 02:20:19 -05:00
Scott Lahteine
e746d68a12 Merge pull request #6176 from thinkyhead/rc_mbl_abl_optimize
Make MBL a static class, use lookup for index-to-point conversion
2017-03-31 02:12:49 -05:00
Scott Lahteine
c9eb1d6ab7 Make MBL a static class, use lookup for index-to-point conversion 2017-03-31 01:28:07 -05:00
Scott Lahteine
de9d2cddc3 Merge pull request #6152 from thinkyhead/rc_cleanup_6150_etc
UBL cleanup, optimization
2017-03-30 17:40:29 -05:00
Scott Lahteine
9217e4b8ec Various UBL cleanups and bug fixes 2017-03-30 17:09:49 -05:00
Scott Lahteine
9924199802 Merge pull request #5908 from thinkyhead/rc_fix_slowdown
General minor cleanup
2017-03-29 21:43:33 -05:00
Scott Lahteine
0e71e7b2fb Cleanup to planner.cpp 2017-03-29 06:48:07 -05:00
Scott Lahteine
f105cad43c Marlin: Slight cleanup to Marlin_main.cpp 2017-03-29 06:40:29 -05:00
Scott Lahteine
499f9e04e1 Marlin: Temperature soft-PWM cleanup 2017-03-29 06:37:27 -05:00
Scott Lahteine
7ddd94dc61 Merge pull request #5994 from StefanBruens/fix_Makefile_errors
Fix makefile errors, cleanup
2017-03-29 06:32:08 -05:00
Scott Lahteine
af09095f03 Merge pull request #6154 from thinkyhead/rc_fil_sensor_vs_sd
Show Filament Width on LCD when SD is disabled
2017-03-29 05:24:48 -05:00
Remo Kallio
d38b1bc4b1 Show filament width sensor values in LCD constantly if SD card support is not enabled. 2017-03-29 04:03:08 -05:00
Scott Lahteine
e3459ec178 Merge pull request #5989 from MagoKimbra/rc_fix_delta_angles
Fix delta_angles
2017-03-29 03:35:18 -05:00
Scott Lahteine
592300922c Merge pull request #6149 from thinkyhead/rc_scara_feedrate
Convert feedrate on SCARA from mm/s to deg/s
2017-03-29 03:31:44 -05:00
Scott Lahteine
f49aec057f Tweak "can not" => "can't" in RUMBA pins 2017-03-29 01:04:50 -05:00
Scott Lahteine
0a23a1bb3b Dynamic feedrate on SCARA, converting target mm/s to deg/s 2017-03-28 17:21:07 -05:00
Roxy-3D
d8724bb546 Get G29's P1 (Automated Probing) working again.
Incorrect optimizations of data types and ternary operators caused some
issues.
2017-03-28 17:11:02 -05:00
Scott Lahteine
8d53298a6d Merge pull request #6139 from thinkyhead/rc_a4jp_scoovo
Board A4JP should be SCOOVO_X9H
2017-03-28 14:06:39 -05:00
Scott Lahteine
c7f6ee9c93 Board A4JP should be SCOOVO_X9H 2017-03-27 22:22:13 -05:00
Scott Lahteine
8c07ac7f7c Merge pull request #6133 from thinkyhead/rc_use_safe_delay
Use safe_delay to ensure watchdog reset
2017-03-27 00:18:02 -05:00
Scott Lahteine
a9fc30ae2e Use safe_delay to ensure watchdog reset 2017-03-26 23:49:56 -05:00
Roxy-3D
171904b6c7 Make G29 What command print reliably and fix G29 P1 bug Waldo found 2017-03-26 17:05:58 -05:00
Roxy-3D
9d3ac66f73 Map clean up of UBL
UBL's maps are cleaner.   And with a 1 value, G29 O 1  will generate a
map suitable to be Cut & Pasted into Excel so a Suface Map can be
generated.
2017-03-25 18:55:05 -05:00
Roxy-3D
9a1949a91e Cleaned up G26 ready to replace existing one at MarlinFirmware/Marlin 2017-03-25 10:15:40 -05:00
Roxy-3D
aec85ad45a Start of process to get UBL running again.
The wait_for_user change totally broke UBL.   But there is stuff wrong
now in the thermal code and/or LCD Panel code.
2017-03-24 18:38:27 -05:00
Scott Lahteine
b47eaf14ae Merge pull request #6109 from thinkyhead/rc_soft_pwm_dither
PWM dithering followup
2017-03-24 18:21:07 -05:00
Scott Lahteine
34d1c41b5f Merge pull request #6111 from benlye/benlye-patch-echo_command
Fix type conversion issue with echo_command
2017-03-24 17:57:28 -05:00
Scott Lahteine
7d65911c00 Merge pull request #6110 from thinkyhead/rc_bilinear_and_m851
Adjust bilinear grid in M851
2017-03-24 17:51:25 -05:00
benlye
6a601aca35 Fix type conversion issue with echo_command
With the the current definition of echo_command I cannot compile RCBugFix (Arduino IDE 1.8.1) with the error "invalid conversion from 'const char*' to 'char*'".  This change resolves that.
2017-03-24 17:23:02 +00:00
Scott Lahteine
009a6ddd39 Adjust bilinear grid in M851 2017-03-24 06:28:59 -05:00
Scott Lahteine
eab7854a73 Merge pull request #6074 from thinkyhead/rc_immediate_shove
Immediate commands take precedence
2017-03-24 05:52:27 -05:00
Stefan Brüns
5699e2b881 Add SOFT_PWM_DITHER to other configurations 2017-03-24 05:02:24 -05:00
Scott Lahteine
5a2abeca78 Merge pull request #6100 from thinkyhead/rc_soft_pwm_dither
Enhancement of PWM, with dithering
2017-03-24 04:57:40 -05:00
Scott Lahteine
043be2856b Use "& 0x3F" instead of "% 64" 2017-03-24 04:13:50 -05:00
Stefan Brüns
6a040a6967 SOFT_PWM: Do not switch off heaters twice on pwm_count wraparound
After wraparound, pwm_count <= pwm_mask holds, thus soft_pwm_X <= pwm_count
guarantees soft_pwm_X < pwm_mask is true, and the heater will be switched
off in the first branch.
Do not evaluate the pwm conditions a second time, this reduces the
instruction count (4 instructions per PWM) and text size (6 byte).

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-24 04:13:50 -05:00
Stefan Brüns
0a74774af1 soft_pwm: avoid useless refetches of pwm_count
The compiler is not able to reuse the value of pwm_count, but reloads it
on every evaluation, if is stored in a static variable, as it cannot prove
it will be unchanged. A variable with local scope may not be modified from
the outside, so its value can be reused.
Doing so reduces text size and instruction count.

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-24 04:13:50 -05:00
Stefan Brüns
35a55d5757 SOFT_PWM: Implement dithering if SOFT_PWM_SCALE is 1 or more
If dithering is enabled, the remainder of the soft_pwm_X duty value at
turnoff time is added to the next cycle. If e.g. the duty is set to 9 and
SCALE is set to 2, the PWM will be active for 8 counts for 3 cycles and
12 counts on each fourth cycle, i.e. the average is 9 cycles.

This compensates the resolution loss at higher scales and allows running
fans with SOFT_PWM with significantly reduced noise.

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-24 04:13:36 -05:00
Stefan Brüns
2aed66a955 temperature: Fix SOFT_PWM off by one
A 128 step PWM has 127 intervals (0/127 ... 127/127 duty). Currently, a
PWM setting of 1/127 is active for 2/128, i.e. double the expected time,
or, in general n+1/128 instead of n/127.
Fixes issue#6003.

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-24 04:13:36 -05:00
Scott Lahteine
4433b63d7a Merge pull request #6099 from thinkyhead/rc_cleanup_ubl_1
Patch till UBL is integrated with planner-based leveling
2017-03-24 02:07:55 -05:00
Scott Lahteine
b5711a99a2 Patches to bring UBL closer to compliance 2017-03-24 01:37:52 -05:00
Scott Lahteine
d076c1b604 Apply some general cleanup to code 2017-03-24 01:37:51 -05:00
Scott Lahteine
d1e6b0e21a Reduce STEP_PULSE_CYCLES code slightly 2017-03-24 00:50:05 -05:00
Scott Lahteine
783338a0b8 Add UBL_MESH_EDIT_ENABLED to configs 2017-03-24 00:44:55 -05:00
Scott Lahteine
8d54ffbf05 Adjust vector_3 code with const, some optimization 2017-03-23 19:41:42 -05:00
Roxy-3D
8ee2612ebb The hex nibble routine can print again!
The code to print a hex nibble got broke.   SERIAL_ECHO( (char) ) isn't
suitable for its use.
2017-03-23 16:08:37 -05:00
Roxy-3D
b8e4a6970b Get UBL up and running again
All the changes to get the code into compliance with Marlin coding
standards made UBL sick.   This pretty much gets UBL back up and
running.
2017-03-23 16:08:37 -05:00
Roxy-3D
5de1da2b3c Make UBL honor the #define ENABLE_LEVELING_FADE_HEIGHT option 2017-03-23 16:08:37 -05:00
Scott Lahteine
8f9face956 Merge pull request #6088 from rafaljot/patch-3
Update Marlin_main.cpp
2017-03-23 01:51:51 -05:00
Scott Lahteine
782634b6c9 Merge pull request #6081 from Sebastianv650/MIN_STEPPER_PULSE_for_Babystepping
Add MINIMUM_STEPPER_PULSE ability to babystepping
2017-03-22 21:57:36 -05:00
Scott Lahteine
d29ab8f2a6 Merge pull request #6075 from thinkyhead/rc_cleanup_ubl_1
Additional cleanup of UBL code
2017-03-22 21:45:59 -05:00
Scott Lahteine
af2ea23e9c EXTRUDER_RUNOUT_PREVENT uses buffer_line_kinematic 2017-03-22 20:51:12 -05:00
Scott Lahteine
cd882b88db #if defined => #ifdef / PIN_EXISTS 2017-03-22 20:51:11 -05:00
Scott Lahteine
e244399766 Additional cleanup of UBL code 2017-03-22 20:51:10 -05:00
Bob-the-Kuhn
0934563b97 G38 optional double touch
Made the double touch portion a conditional compile based on the
PROBE_DOUBLE_TOUCH flag.

==============================================

Bugfix

The current G38 only stopped a move if it involved the Z axis.

Moved all the G38 code to it's own section and put it where it would
always be executed no matter what axis was moving or if the endstop was
enabled.

Also added a comment to configuration_adv to alert the user the double
tap had to be turned on.

==============================================

Change G38 back to using Z_MIN_PROBE

There's no Z_MIN endstop if Z_DUAL_ENDSTOPS is enabled and you have them
set to the top of the gantry.

G38 started out as using the Z_MIN_PROBE pin.  I don't remember why we
changed it to the Z_MIN endstop.
2017-03-22 15:08:49 -05:00
Scott Lahteine
cc3204509c UBL patch from Bob-the-Kuhn 2017-03-22 07:54:20 -05:00
Scott Lahteine
100c9bc52d Merge pull request #6079 from thinkyhead/rc_audio_feedback
Standard audio feedback. Use for settings store/load/reset
2017-03-22 07:35:57 -05:00
Scott Lahteine
b904b5ae8d Audible feedback for settings store/load/reset 2017-03-22 02:15:21 -05:00
Sebastianv650
bf57eb2447 Protect Babystepping against other ISRs
Especialy against stepper ISR.
This is even more important when a minimum pulse width is set,
increasing the runtime of a babystep.
2017-03-21 18:05:44 +01:00
Sebastianv650
80830919dc Add MINIMUM_STEPPER_PULSE ability to babystepping 2017-03-21 17:50:38 +01:00
rafaljot
6da949bbf0 Update Marlin_main.cpp
Sometimes after killing heaters are still on.
2017-03-21 15:06:01 +01:00
Roxy-3D
72f7b14e66 Make G29's Interactive Mesh Editor Work 2017-03-20 12:52:51 -05:00
Roxy-3D
3fd74b121f Get G29's Interactive Mesh Editor running
G29 P4 R O  should work now.
2017-03-20 12:52:51 -05:00
Roxy-3D
1d58558bec Spelling fix 2017-03-20 12:52:51 -05:00
Scott Lahteine
2573f4dd05 Merge pull request #6052 from thinkyhead/rc_lift_on_pause
Add PARK_HEAD_ON_PAUSE feature / M125
2017-03-20 03:36:31 -05:00
Scott Lahteine
48c6284c91 Immediate commands take precedence 2017-03-19 21:50:48 -05:00
Scott Lahteine
786fe2ba2a Include PARK_HEAD_ON_PAUSE in Travis testing 2017-03-19 18:34:58 -05:00
Roxy-3D
b3c4f71c6f Merge pull request #6071 from Roxy-3D/RCBugFix
Allow FWRETRACT with UBL Enabled
2017-03-19 16:54:57 -05:00
Roxy-3D
76c270fdf2 Allow FWRETRACT with UBL Enabled
The retraction flag in UBL's G26 was conflicting with the FWRETRACT option.

All fixed!
2017-03-19 15:43:12 -06:00
Roxy-3D
06c31daa53 Merge pull request #6070 from Roxy-3D/RCBugFix
Allow G29 P1 R to generate the mesh
2017-03-19 16:34:48 -05:00
Roxy-3D
c377c59d47 Allow G29 P1 R to generate the mesh
Fix the logic change that happened when UBL got merged.
2017-03-19 15:13:33 -06:00
Scott Lahteine
ff0dd162b7 PARK_HEAD_ON_PAUSE implementation 2017-03-19 07:27:35 -05:00
Scott Lahteine
26473cab6d Add PARK_HEAD_ON_PAUSE feature 2017-03-19 05:06:55 -05:00
Scott Lahteine
4cf51157b3 Use XYZE rather than NUM_AXIS 2017-03-19 01:14:39 -05:00
Scott Lahteine
4c7f14752a Add disable_e_steppers function 2017-03-19 01:14:39 -05:00
Scott Lahteine
8eb29f91e6 Patch filament change options and beep code 2017-03-19 01:14:39 -05:00
Scott Lahteine
56c9dfc83b Merge pull request #6066 from thinkyhead/rc_felix_fix
Update Felix config for UBL
2017-03-19 01:11:02 -05:00
Scott Lahteine
9b2b53f63a Merge pull request #6042 from thinkyhead/rc_fix_toolchange_z
Move Z last in tool-change for SWITCHING_EXTRUDER
2017-03-19 00:34:41 -05:00
Scott Lahteine
f98fb6b38e Update Felix config for UBL 2017-03-19 00:28:48 -05:00
Scott Lahteine
7cabe81373 Merge pull request #6057 from thinkyhead/rc_followup_6054
Followup 6054 with some cleanup
2017-03-18 13:49:20 -05:00
Scott Lahteine
4bca27ab89 Fix Kelvin conversion
Thanks to @ospalh -- #6056
2017-03-18 13:23:08 -05:00
Scott Lahteine
143ab8f329 Remove Roxy's personal configurations 2017-03-18 12:35:02 -05:00
Scott Lahteine
2512871a36 Patch configs UBL followup 2017-03-18 12:32:03 -05:00
Scott Lahteine
27b5666e15 Move Allen Key probe definition to the top 2017-03-18 12:27:37 -05:00
Scott Lahteine
77cf648ed3 Move menu selection past static items in 1 screen 2017-03-18 12:26:21 -05:00
Scott Lahteine
2c630a1b5c Merge pull request #6054 from thinkyhead/rc_ubl_renewal
UBL for RCBugFix — cleanup, rebase, patch
2017-03-18 12:07:57 -05:00
Scott Lahteine
0492a3a8f1 Merge pull request #6027 from Bob-the-Kuhn/add_kill_info
Message for every KILL and STOP
2017-03-18 11:49:35 -05:00
Scott Lahteine
fba22652fc Add UBL testing to Travis 2017-03-18 11:35:21 -05:00
Scott Lahteine
6618346148 Patches to work around "register spill" compiler bug 2017-03-18 11:35:21 -05:00
Scott Lahteine
be7dd90382 Add Thermistor 75: MGB18 silicon pad 2017-03-18 11:35:20 -05:00
Scott Lahteine
f890ceba9e Add 'tags' to .gitignore 2017-03-18 11:35:20 -05:00
Scott Lahteine
b0a9c82c31 Fix single-char echo and pinMode usage 2017-03-18 11:35:20 -05:00
Scott Lahteine
fb60aa3736 UBL implementation 2017-03-18 11:35:20 -05:00
Scott Lahteine
238b8fd2a3 UBL core and support files 2017-03-18 11:35:19 -05:00
Scott Lahteine
cf94688925 Univeral Bed Leveling - configuration 2017-03-18 11:35:19 -05:00
Scott Lahteine
03aa424ccb Merge pull request #6053 from thinkyhead/rc_clean
Remove extraneous whitespace
2017-03-18 03:26:45 -05:00
Scott Lahteine
af644871bf Merge pull request #6045 from thinkyhead/rc_remove_raw_kinematics
Remove delta optimization concepts… for now
2017-03-18 03:26:24 -05:00
Scott Lahteine
77491dd924 Remove extraneous whitespace 2017-03-18 03:17:39 -05:00
Scott Lahteine
ed4f9d7e1c Merge pull request #6046 from robbycandra/RCBugFix-ignore_visual_studio_files
Ignore Visual Studio Files
2017-03-17 22:25:01 -05:00
Scott Lahteine
d15f25539b Merge pull request #6031 from thinkyhead/rc_mbl_z_unhack
MBL: Disable sw endstops instead of altering Z
2017-03-17 17:20:35 -05:00
Robby Candra
0dada36e5a Ignore Visual Studio Files 2017-03-17 22:13:46 +07:00
Scott Lahteine
b865b21d32 Can't use Z fade height with DELTA 2017-03-17 08:34:47 -05:00
Scott Lahteine
1e57b0c269 Remove delta interpolation concept 2017-03-17 06:32:11 -05:00
Scott Lahteine
e46898f8e5 Remove kinematic optimizations 2017-03-17 06:30:22 -05:00
Scott Lahteine
11f1fdfab4 _lcd_level_bed_position => manual_probe_index 2017-03-17 06:05:17 -05:00
Scott Lahteine
0e410c9dfd Software endstop options as simple switches 2017-03-17 06:05:17 -05:00
Scott Lahteine
d01b915085 Implement soft_endstops_enabled for clamping 2017-03-17 06:05:17 -05:00
Scott Lahteine
e4649c9044 Add HAS_SOFTWARE_ENDSTOPS macro 2017-03-17 06:05:17 -05:00
Scott Lahteine
3e927ff204 Replace MBL Z hacking 2017-03-17 06:05:17 -05:00
Scott Lahteine
4e53124681 Merge pull request #6039 from Bob-the-Kuhn/M114-sync-with-stepper
M114 - wait for move completion before reporting position
2017-03-17 05:22:46 -05:00
Scott Lahteine
734f9ea133 Merge pull request #6040 from thinkyhead/rc_sanity_use_assert
Simplify some sanity checks with static_assert
2017-03-17 05:22:17 -05:00
Scott Lahteine
f02af83d42 Remove some extraneous spaces 2017-03-16 23:59:11 -05:00
Scott Lahteine
672e45652e Improved solution to tool-change bug 2017-03-16 23:59:10 -05:00
Scott Lahteine
23f1cfb46f Fix stuck CHDK pin as suggested in #6041 2017-03-16 21:49:39 -05:00
Scott Lahteine
0b22069e82 Merge pull request #6021 from Bob-the-Kuhn/BUG-FIX--Switching-extruder-tool-change-Z-height
Bug Fix: Switching extruder tool change leaves Z in wrong position
2017-03-16 21:15:20 -05:00
Scott Lahteine
e7e4500629 Simplify some sanity checks with static_assert 2017-03-16 16:31:34 -05:00
Bob-the-Kuhn
34ff0c3439 M114 - wait for move completion before reporting position 2017-03-16 15:10:45 -05:00
Bob-the-Kuhn
b31604a492 Message for every KILL and STOP
No more mystery halts & resets

Moved messages to language.h

Added current command to inactive timeout message
2017-03-15 21:05:11 -05:00
Roxy-3D
48925b7298 Merge pull request #6032 from Kaibob2/patch-7
Update language_de.h
2017-03-15 10:31:09 -05:00
Kai
13b44d019b Update language_de.h
Addition of missing strings to match language_en.h
2017-03-15 16:06:52 +01:00
Bob-the-Kuhn
685ed5393a Bug Fix: Switching extruder tool change leaves Z in wrong position
The tool_change function saves the current_position to the destination
array soon after starting.  Later in the switching extruder section, the
destination array is modified when moving the Z axis up & down.  A later
section of tool_change moves the head back to the “original location”
using the destination array.  This later section assumes that the
destination array hasn’t been modified.

The fix is to save the destination Z position and then restore it after
the Z movements have completed.

Going back to using the current_position array for the switching
extruder Z axis moves (and  leaving the destination array untouched)
doesn’t fix the problem.

This bug was introduced by the “Make tool_change kinematic compatible”
commit # 847429eff4 which was merged on 10
Oct 2016 as part of PR 4982.

This bug was discovered in Issue 5966.
2017-03-14 02:36:24 -05:00
Scott Lahteine
51353f8fea Merge pull request #6000 from trivalik/NoWorkspaceWarning
prevent warning with define of NO_WORKSPACE_OFFSETS
2017-03-12 00:00:51 -06:00
Scott Lahteine
54dada56a7 Merge pull request #6010 from MagoKimbra/rc_fix_bug_set_position_mm
Fix BUG set_position_mm
2017-03-12 00:00:16 -06:00
MagoKimbra
a4a9bd8bc9 Fix BUG set_position_mm
Set postion must have axis and not E_AXIS + active_extruder.
2017-03-11 14:13:39 +01:00
Trivalik
71ac6f9d42 prevent warning with define of NO_WORKSPACE_OFFSETS 2017-03-09 23:49:57 +01:00
Stefan Brüns
9ba6c051a1 Makefile: add nozzle.cpp too CXXSRC list
The file is required by the optional NOZZLE_PARK_FEATURE.

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-09 03:08:49 +01:00
Stefan Brüns
9cc8d495b8 Makefile: remove no longer existing search paths
ArduinoAddons has been removed from Marlin, remove any references to it.
Replace HARDWARE_SRC and HARDWARE_DIR with its expanded equivalents.

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-09 01:46:47 +01:00
Stefan Brüns
bf563e62c1 Makefile: add printcounter.cpp too CXXSRC list
The file is required by the optional PRINTCOUNTER feature.

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-09 01:45:54 +01:00
Stefan Brüns
ddecc1441d Makefile: Fix linker error
Instantiation of the static singleton instance thermalManager in general
requires locking, but we know its safe to do without.

Add -fno-threadsafe-statics to avoid using locking primitives, which
result in linking errors:
	undefined reference to `__cxa_guard_acquire'
	undefined reference to `__cxa_guard_release'

Signed-off-by: Stefan Brüns <stefan.bruens@rwth-aachen.de>
2017-03-09 01:45:38 +01:00
MagoKimbra
37a26dfc09 Fix delta_angles 2017-03-08 09:23:30 +01:00
Scott Lahteine
6caf0830ae Merge pull request #5985 from thinkyhead/rc_better_endstops_init
Use SET_INPUT_PULLUP where appropriate
2017-03-08 00:08:30 -06:00
Scott Lahteine
2defb1d748 Use SET_INPUT_PULLUP where appropriate 2017-03-07 23:43:33 -06:00
Scott Lahteine
deb9d0dabd Merge pull request #5984 from thinkyhead/rc_delta_angles
Add delta_tower_angle_trim
2017-03-07 19:41:24 -06:00
Scott Lahteine
58b3e98878 Use arrays for delta tower parameters 2017-03-07 19:00:22 -06:00
Scott Lahteine
47242a40bb Apply updated changes for delta_tower_angle_trim 2017-03-07 18:15:11 -06:00
Jimmy Envall
00b6b3da79 Added support for delta tower angle corrections. 2017-03-07 16:35:58 -06:00
Scott Lahteine
7c9e2e2a1a Merge pull request #5981 from thinkyhead/rc_tmc2130_redo
TMC2130 Library: @teemuatlut replaces @makertum
2017-03-07 16:23:52 -06:00
Scott Lahteine
5a456c832a Apply TMC2130 to example configurations 2017-03-07 04:22:06 -06:00
Scott Lahteine
45f949d833 TMC2130 Library: @teemuatlut replaces @makertum 2017-03-07 04:22:06 -06:00
Scott Lahteine
33f8a8a344 Merge pull request #5973 from thinkyhead/rc_circle_pattern
Add circle pattern to nozzle clean
2017-03-06 04:47:01 -06:00
Scott Lahteine
94b3e0a483 Merge pull request #5959 from benlye/benlye-fixm48
Remove extra carriage return in M48 V1 output
2017-03-06 04:24:28 -06:00
Scott Lahteine
a9a1971295 Merge pull request #5972 from thinkyhead/rc_cooldown_before
Fix preheat menu formatting
2017-03-06 03:21:29 -06:00
Scott Lahteine
6aa81255a9 Patch and clean up "flsun" kossel. Followup to #5911. 2017-03-06 03:15:00 -06:00
Scott Lahteine
b2270b3f3e Apply prior nozzle clean update 2017-03-06 03:14:59 -06:00
Marek Pikuła
7698c5617a Added circle nozzle cleaning parameters to example configurations 2017-03-06 03:04:58 -06:00
Marek Pikuła
6836b94eea Added circle pattern for nozzle cleaning feature 2017-03-06 03:03:00 -06:00
Scott Lahteine
3b75518ef6 Merge pull request #5911 from aphex3k/flsun_kossel_mini
Configuration.h and Configuration_adv.h for the kossel mini by flsun
2017-03-06 02:26:01 -06:00
Scott Lahteine
3830778852 Apply NO_WORKSPACE_OFFSETS to lcd menu 2017-03-06 02:21:42 -06:00
Scott Lahteine
7e3aab889d Fix preheat menu formatting 2017-03-06 02:07:07 -06:00
Scott Lahteine
fea0d3f20f Endstop and temp-isr general cleanup 2017-03-06 02:07:07 -06:00
Scott Lahteine
aef08e8780 Compact some macro substitutions 2017-03-06 02:07:07 -06:00
Scott Lahteine
2f620f86d9 Merge pull request #5970 from thinkyhead/rc_cooldown_before
Preheat Hotend Only menu items
2017-03-06 01:56:05 -06:00
Scott Lahteine
02de8e6f18 Merge pull request #5957 from MagoKimbra/rc_stepper_indirection_fix
Stepper indirection fix tmc driver
2017-03-06 01:16:40 -06:00
Scott Lahteine
6c5312559c Menu item to preheat only the hotend 2017-03-06 01:14:54 -06:00
Scott Lahteine
9d0142e8ae Move Change Filament above Cooldown 2017-03-06 01:13:12 -06:00
Scott Lahteine
0c55095c5e Move Cooldown above Preheat 2017-03-06 01:13:12 -06:00
Scott Lahteine
c15c65f18a Merge pull request #5971 from thinkyhead/rc_fix_e_factors
Patch DISTINCT_E_FACTORS bug
2017-03-06 01:11:17 -06:00
Scott Lahteine
bfb0007573 Patch DISTINCT_E_FACTORS bug 2017-03-05 23:19:31 -06:00
Scott Lahteine
be98016674 Merge pull request #5963 from thinkyhead/rc_no_offsets_optim
New option: NO_WORKSPACE_OFFSETS
2017-03-05 21:46:49 -06:00
Scott Lahteine
8e89a802f7 Document PROTOCOL_VERSION 2017-03-05 04:43:46 -06:00
Scott Lahteine
87b03b16bd Use a macro for array copies 2017-03-05 04:43:46 -06:00
Scott Lahteine
e141f3a03f Optimize coordinate transformation
Pre-compute the combined position shift and home offset to save a
single float fetch-and-add per conversion. Great for delta/scara and
bed leveling.
2017-03-05 04:43:16 -06:00
Scott Lahteine
5f7e85398b Implement NO_WORKSPACE_OFFSETS 2017-03-05 04:43:15 -06:00
Scott Lahteine
05abe853f9 New option: NO_WORKSPACE_OFFSETS 2017-03-05 04:43:15 -06:00
Scott Lahteine
20addc6e32 Merge pull request #5955 from thinkyhead/rc_eeprom_fail_better
Display a message for EEPROM version mismatch
2017-03-04 17:15:07 -06:00
benlye
dead89062a Update Marlin_main.cpp
Remove unnecessary line break from M48 V1 output.
2017-03-04 17:58:10 +00:00
MagoKimbra
ae277aebc6 Stepper indirection fix tmc driver 2017-03-04 12:17:39 +01:00
Scott Lahteine
8f4e4b1995 Display a message for EEPROM version mismatch 2017-03-04 01:20:36 -06:00
Scott Lahteine
177ad245f6 Merge pull request #5953 from thinkyhead/fix_fc_e_index
Fix submenu hotend status display
2017-03-04 00:12:29 -06:00
Scott Lahteine
cea3ea772c Fix submenu hotend status display 2017-03-03 22:12:22 -06:00
Scott Lahteine
b27f69ba51 Merge pull request #5813 from thinkyhead/rc_fix_makrpanel
Fix MAKRPANEL assignments
2017-03-03 21:40:49 -06:00
Scott Lahteine
1ef6ccd919 Merge pull request #5951 from thinkyhead/rc_print_2d_array
Reduce code size (40b, or 166b with bilinear subdivision)
2017-03-03 21:27:44 -06:00
Scott Lahteine
b9b203bfb2 Merge pull request #5950 from thinkyhead/rc_cleanup_mar3
General cleanup, const usage, var naming
2017-03-03 21:25:34 -06:00
Scott Lahteine
53f5086905 Fix MAKRPANEL assignments
MAKRPANEL is a DOGLCD+ULTRA_LCD+NEWPANEL so customize its pins within
that block.
2017-03-03 21:22:21 -06:00
Scott Lahteine
98c7b682ca General cleanup, const usage, var naming 2017-03-03 20:57:49 -06:00
jes
369bfc8a1e Reduce code size (40b, or 166b with bilinear subdivision) 2017-03-03 20:36:32 -06:00
Scott Lahteine
21fb347eee Merge pull request #5948 from thinkyhead/rc_fix_status_printf
Fix "Heating..." message
2017-03-03 12:28:27 -06:00
Scott Lahteine
0d13412105 Fix "Heating..." message 2017-03-03 12:12:51 -06:00
Scott Lahteine
5065636023 Merge pull request #5934 from thinkyhead/rc_advance_ed_ratio
LIN_ADVANCE: Fixed E/D ratio option
2017-03-03 03:24:41 -06:00
Scott Lahteine
903808bb97 Merge pull request #5943 from thinkyhead/catalan_march_2017
Update Catalan language
2017-03-03 03:13:51 -06:00
divendres
75ad82baab Update Catalan language 2017-03-02 20:40:06 -06:00
Scott Lahteine
34253497d4 Babysteps code tweak
As suggested by https://github.com/MarlinFirmware/Marlin/pull/5887#issuecomment-283832163
2017-03-02 20:35:45 -06:00
Scott Lahteine
e309e980ce Merge pull request #5942 from thinkyhead/rc_cleanup_finish_5887
Clean up and finish #5887
2017-03-02 20:26:13 -06:00
Scott Lahteine
fb4aead2b1 Clean up and finish #5887 2017-03-02 20:16:29 -06:00
Scott Lahteine
b3e2bd6f29 Reduce E_D_ratio code 2017-03-02 01:00:37 -06:00
Sebastianv650
de6c40ed8f Add option to fix E/D ratio
Work around for slicers producing buggy gcode.
2017-03-02 01:00:37 -06:00
Scott Lahteine
eeb490221f Remove BEEPER_PIN override in pins_RIGIDBOARD.h
Resolves #5926. This override is no longer needed since the RAMPS LCD controller pins were fixed.
2017-03-01 18:26:29 -06:00
Roxy-3D
11e892bd84 Merge pull request #5887 from Roxy-3D/RCBugFix
Double Click of Encoder Wheel Jumps to Z-BabyStepping
2017-03-01 17:15:02 -07:00
Scott Lahteine
cbeff12f8a Merge pull request #5933 from teemuatlut/lcd_days_hours
Fix formatting of SD print time hours above one day
2017-03-01 15:44:10 -06:00
Scott Lahteine
8a4e9d08a3 Merge pull request #5931 from thinkyhead/rc_core_endstop_fix
Fix CoreYX / YZ / ZX endstop logic
2017-03-01 15:32:11 -06:00
teemuatlut
9175d16660 Fix formatting of print time hours above one day 2017-03-01 18:55:25 +02:00
Scott Lahteine
b6d9eb229f Extend Core endstop commentary 2017-03-01 10:01:50 -06:00
Bob-the-Kuhn
c5e08e8761 CoreYX/YZ/ZX needs different endstop logic than CoreXY/YZ/XZ
In the endstop testing section, add the "reverse" logic in addition to "normal" core handling.

In CoreXY/YZ/XZ steppers rotating the same direction gives X movement. Opposing directions produces Y movement.

In CoreYX/ZY/ZX this is reversed. Same = Y, Opposite = X.

----

Fixes the issue where the Y endstop was being checked when moving in the X direction, etc.
2017-03-01 09:40:24 -06:00
Scott Lahteine
05b217c0d0 Merge pull request #5930 from thinkyhead/rc_lcd_timeout_config
Make LCD_TIMEOUT_TO_STATUS configurable
2017-02-28 19:42:27 -06:00
Scott Lahteine
c759c26cca Make LCD_TIMEOUT_TO_STATUS configurable
As suggested in
https://github.com/MarlinFirmware/Marlin/issues/5570#issuecomment-283059
065
2017-02-28 19:02:50 -06:00
Michael Henke
47729918fc enable ENSURE_SMOOTH_MOVES 2017-02-27 20:42:49 -08:00
Michael Henke
330b981912 created Configuration.h and Configuration_adv.h for the kossel mini sold by flsun 2017-02-25 21:31:37 -08:00
Scott Lahteine
493e738575 Merge pull request #5910 from thinkyhead/rc_more_nozzle_wipe
Bidirectional Zig-Zag Nozzle Wipe
2017-02-25 22:03:33 -06:00
Colin Gilgenbach
48b7e0f8d8 Nozzle Wipe Vertical Zig-Zag
- Add configuration support for zigzags in either the X or Y axis, for
wipe pads significantly longer in one dimension.
- Add configuration for default number of zig-zag triangles, vs. a
magic number in `Marlin_main.cpp`.
- Update description of auto nozzle wiping to match functionality
2017-02-25 21:52:43 -06:00
Scott Lahteine
f17b81b765 Add MAPPER_C2C3 to French language 2017-02-25 18:49:00 -06:00
Roxy-3D
7e607b06eb Better comments on DOUBLE_CLICK_TIME_WINDOW 2017-02-23 13:13:57 -07:00
Scott Lahteine
f9e4717f5b Merge pull request #5892 from thinkyhead/rc_msg_heating_pstr
Use PSTR for MSG_HEATING
2017-02-22 12:26:08 -06:00
Scott Lahteine
34cba42104 Use PSTR for MSG_HEATING 2017-02-22 11:30:19 -06:00
Roxy-3D
584d147a02 fixup the indentation 2017-02-22 07:23:54 -07:00
Roxy-3D
e443e0e2a9 Fix scoping issues for double click to Z-Babystepping 2017-02-21 18:15:28 -07:00
Roxy-3D
17d1cd7c09 Double Click of Encoder Wheel Jumps to Z-BabyStepping 2017-02-21 18:08:19 -07:00
Roxy-3D
48d862377a Double Click of Encoder Wheel Jumps to Z-BabyStepping 2017-02-21 18:04:31 -07:00
Scott Lahteine
cfdc189796 Merge pull request #5856 from thinkyhead/rc_fix_bad_comment
Remove non-applicable comment on MANUAL_Z_HOME_POS
2017-02-20 17:54:30 -06:00
Scott Lahteine
2efdc72aa5 Merge pull request #5876 from thinkyhead/rc_hotend_status
Add status_printf to print messages to the lcd status line.
2017-02-20 17:29:27 -06:00
dot-bob
cd68380ce6 Add status_printf to print messages to the lcd status line.
Also add a hotend indicator to the heating message displayed on the lcd status line.
2017-02-20 15:26:54 -06:00
Scott Lahteine
012aff6823 Merge pull request #5862 from thinkyhead/rc_fix_a_thing
Finish reducing of ABL_BILINEAR_SUBDIVISION
2017-02-18 21:36:28 -06:00
Scott Lahteine
b9187020c4 Finish reducing of ABL_BILINEAR_SUBDIVISION 2017-02-18 20:01:19 -06:00
Scott Lahteine
e282b72151 Remove non-applicable comment on MANUAL_Z_HOME_POS 2017-02-18 05:14:43 -06:00
Scott Lahteine
49d562d23d Merge pull request #5855 from thinkyhead/rc_followup_5840
Apply DISTINCT_E_FACTORS to sync_from_steppers
2017-02-18 04:51:01 -06:00
Scott Lahteine
57f92a4632 Apply DISTINCT_E_FACTORS to sync_from_steppers
Followup to #5840
2017-02-18 04:36:41 -06:00
Scott Lahteine
4da8b1494b Merge pull request #5854 from thinkyhead/rc_fixup_m600
M600 cleanup and bugfix
2017-02-18 04:27:13 -06:00
Scott Lahteine
dd02dba6e6 Merge pull request #5840 from MagoKimbra/rc_fix_lin_advanced_step_to_mm
Fix steps_to_mm for active extruders
2017-02-18 04:25:53 -06:00
Scott Lahteine
6e0b3fcc08 Optimize M600 heater status LCD items 2017-02-18 04:08:00 -06:00
Scott Lahteine
44b4e116bd Commentary / style in gcode_M600 2017-02-18 04:08:00 -06:00
Scott Lahteine
561904345f Tweak config ordering for M600 2017-02-18 00:01:31 -06:00
Scott Lahteine
7fdc620ef7 Merge pull request #5850 from thinkyhead/drop_some_comments
Remove some old code comments
2017-02-17 16:45:44 -06:00
Scott Lahteine
284d6de9da Remove some old code comments 2017-02-17 15:25:56 -06:00
MagoKimbra
3685224c1a Fix steps_to_mm for active extruders 2017-02-15 21:45:39 +01:00
Scott Lahteine
babe1d211c Merge pull request #5794 from thinkyhead/rc_m600_improve
M600 wait for heatup, prevent stepper timeout, etc.
2017-02-15 05:38:06 -06:00
Scott Lahteine
4578c573fe Pause the print job timer while in M600 2017-02-15 05:29:34 -06:00
Scott Lahteine
bfe6f71794 Simplify filament_change_beep function 2017-02-15 05:29:34 -06:00
Scott Lahteine
8289ea1316 Use a short name for the filament "endstop" 2017-02-15 05:29:34 -06:00
Scott Lahteine
d9dcef8a87 Spacing, coding standards 2017-02-15 05:29:34 -06:00
Scott Lahteine
931914e679 Apply M600 updates to all configs 2017-02-15 05:29:34 -06:00
Roxy-3D
8bf0b496b9 Improve M600 with timeout, wait for heatup. 2017-02-15 05:29:34 -06:00
Scott Lahteine
58b8e0cae7 Merge pull request #5837 from thinkyhead/rc_fix_mbl_homing
Fix broken homing in MBL
2017-02-15 04:48:30 -06:00
Tannoo
c40fe2113c Fix for broken MBL
LCD call was waiting forever, causing the system to hang.
2017-02-15 04:39:22 -06:00
Scott Lahteine
4d4745c0eb Parenthesize some menu defines for safety 2017-02-14 23:12:27 -06:00
Scott Lahteine
20ef0a6e27 Merge pull request #3152 from thinkyhead/sd_alpha_sort
SD files alphabetical sort in LCD menus
2017-02-14 21:48:57 -06:00
Scott Lahteine
47f9883b0f Dynamic allocation for SDCARD_SORT_ALPHA 2017-02-14 21:37:25 -06:00
Scott Lahteine
a561bd5e3a New feature: SDCARD_SORT_ALPHA 2017-02-14 21:37:24 -06:00
Scott Lahteine
c04d6b5aa6 Merge pull request #5829 from thinkyhead/rc_fix_isr_reentry
Combine fixes for LIN_ADVANCE and temperature ISR
2017-02-14 20:36:58 -06:00
Scott Lahteine
467f01435f Merge pull request #5816 from thinkyhead/rc_abl_virt_reduce
Reduce memory use by ABL_BILINEAR_SUBDIVISION slightly
2017-02-14 08:41:44 -06:00
Scott Lahteine
97b6fb6381 Reduce / optimize LIN_ADVANCE code 2017-02-14 07:52:03 -06:00
Sebastianv650
271ced7341 Prevent re-entering of temperature ISR
If Marlin is inside the temperature ISR, the stepper ISR is enabled. If
a stepper event is now happening Marlin will proceed with the stepper
ISR. Now, at the end of the stepper ISR, the temperatre ISR gets enabled
again. While Marlin proceed the rest of the temperature ISR, it's now
vulnerable to a second ISR call.
2017-02-14 07:52:03 -06:00
Sebastianv650
1b59766fcb Cleanup position_float
Hopefully fixes Marlin #5481
2017-02-12 13:09:06 +01:00
Scott Lahteine
a950c31e2d Merge pull request #5815 from thinkyhead/rc_pulses_per_step
Give encoder pulse/steps conditionals their own block
2017-02-12 04:14:00 -06:00
Scott Lahteine
7176de8605 Merge pull request #5814 from thinkyhead/hotend_loop_always
Make HOTEND_LOOP more consistent, let compiler optimize it
2017-02-12 04:13:14 -06:00
Scott Lahteine
adec219ca5 Merge pull request #5811 from thinkyhead/fix_two_strings
No space after X: or A: in M114 output
2017-02-12 04:11:51 -06:00
jes
eaa829b58c Reduce memory use by ABL_BILINEAR_SUBDIVISION slightly 2017-02-12 04:09:48 -06:00
Scott Lahteine
1c99ca82d8 Give encoder pulse/steps conditionals their own block 2017-02-12 03:57:57 -06:00
Scott Lahteine
e44294bb4d Make HOTEND_LOOP more consistent, let compiler optimize it 2017-02-12 02:50:38 -06:00
Scott Lahteine
701f4a6d9d Merge pull request #5729 from Bob-the-Kuhn/guaranteed-BLTouch-detection
guaranteed BLTouch detection
2017-02-12 01:13:35 -06:00
Scott Lahteine
c15b9a6a06 No space after X: or A: in M114 output 2017-02-12 00:10:03 -06:00
Scott Lahteine
e1702816f6 Fix SD_CHECK_AND_RETRY condition
Addressing #5806
2017-02-11 23:55:56 -06:00
Scott Lahteine
c64ecf95e2 Merge pull request #5808 from thinkyhead/rc_delta_float_radius
Cast DELTA_PRINTABLE_RADIUS to float in sq()
2017-02-11 23:43:46 -06:00
Scott Lahteine
1bc5be3bdf Cast DELTA_PRINTABLE_RADIUS to float in sq()
Addressing #5625
2017-02-11 23:28:39 -06:00
Bob-the-Kuhn
0369f97ec1 guaranteed BLTouch detection
To guarantee that the 5mS pulse from a BLTouch is recognized you need to
have the endstops.update() routine run twice in that 5mS period.

At 200 steps per mm, my system has problems  below a feedrate of 120 mm
per minute.

Two things were done to guarantee the two updates within 5mS:
1) In interrupt mode, a check was added to the temperature ISR.  If the
endstop interrupt flag/counter is active then it'll kick off the endstop
update routine every 1mS until the flag/counter is zero.  This
flag/counter is decremented by the temperature ISR AND by the stepper
ISR.

2) In poling mode, code was added to the stepper ISR that will make sure
the ISR runs about every 1.5mS.  The "extra" ISR runs only check the
endstops.  This was done by grabbing the intended ISR delay and, if it's
over 2.0mS, splitting the intended delay into multiple smaller delays.
The first delay can be up to 2.0mS, the next ones 1.5mS (as needed) and
the last no less than 0.5mS.

=========================================

BLTouch error state recovery

If BLTouch already active when deploying the probe then try to reset it
& clear the probe.

If that doesn't fix it then declare an error.

Also added BLTouch init routine to startup section
2017-02-11 12:01:34 -06:00
Scott Lahteine
1e4d4e5915 Fix typo in language_uk
Thanks to @pavlus for this one
2017-02-10 15:34:31 -06:00
Scott Lahteine
7fe7a0c8be Merge pull request #5793 from thinkyhead/rc_adjust_probe_output
Adjust probe_pt() terminal output to respect probe z-offset
2017-02-09 23:05:02 -06:00
Scott Lahteine
633c253bc1 Merge pull request #5792 from thinkyhead/rc_default_dac_vals
Default DAC values for RigidBoard V2
2017-02-09 22:56:03 -06:00
Florian Heilmann
7bbc31704c Adjust probe_pt() terminal output to respect probe z-offset 2017-02-09 22:54:22 -06:00
Scott Lahteine
6dac1fe07e Merge pull request #5701 from tohara/RCBugFixCmake
Updated CMakeLists
2017-02-09 22:45:05 -06:00
Scott Lahteine
a245656db3 Merge pull request #5713 from gege2b/RCBF-French
French translation : Added missing strings as well as missing accents
2017-02-09 22:43:56 -06:00
jaysonkelly
713931338a Default DAC values for RigidBoard V2 2017-02-09 22:39:00 -06:00
Scott Lahteine
fb11e52cd2 Merge pull request #5787 from thinkyhead/rc_bob_pins_added
pinsDebug for 644/1284 & USB646/1286 families
2017-02-09 15:07:55 -06:00
Bob-the-Kuhn
ae706233a8 pinsDebug for 644/1284 & USB646/1286 families
added conditional compilation for PWMs 1C & 3C

add Teensyduino compatibility

==========================================

changes per review - minor formatting changes

1) remove non-printable character at the end of line 687

2) split a really long comment into two lines

3) got rid of some trailing spaces

============================================

Made pinsDebug_Teensyduino.h the same between this PR and PR 5668 which
is for a re-written pinsDebug.h file.

The changes were:
1) added copyright @ GNU license header
2) a blank line crept in.
2017-02-09 07:24:02 -06:00
Gege2B
22dfcc9a71 French translation : Added missing strings as well as missing accents 2017-01-17 23:29:23 +01:00
Tom Haraldseid
1d65b4b316 Updated CMakeLists 2017-01-15 13:39:26 +08:00
Scott Lahteine
9b5515926a Merge pull request #5696 from thinkyhead/rc_volumetric_default
Allow enabling volumetric filament on config load
2017-01-14 05:48:51 -08:00
Robert Kirk
0d147ead66 Allow enabling volumetric filament on config load 2017-01-14 04:37:49 -08:00
Scott Lahteine
d3cb1a86be Merge pull request #5691 from AnHardt/fix5677
Fix M110 without leading N
2017-01-14 03:22:26 -08:00
AnHardt
fa26767efe Replace all remaining 'boolean' with 'bool' 2017-01-13 13:03:52 +01:00
AnHardt
f6858d9974 Fix M110 without leading N
Store N in the right variable.
This is too rarely used.

"mea culpa, mea culpa, mea maxima culpa"
2017-01-13 12:33:50 +01:00
Scott Lahteine
0c0c840ba8 Merge pull request #5683 from emartinez167/EMartinez-Changes
Updates to some incorrectly ended strings in the Spanish translation
2017-01-12 07:49:15 -08:00
Scott Lahteine
738b87091a Merge pull request #5684 from Kaibob2/patch-6
Update language_de.h
2017-01-12 07:48:41 -08:00
Kai
25dae3bccc Update language_de.h
Small corrections
2017-01-12 16:06:58 +01:00
emartinez167
7292145f4e Fix for some wrong strings
On last commit, some strings were ended with the incorrect character.
This fixes it.
2017-01-12 22:35:04 +08:00
emartinez167
3dee35888e Merge remote-tracking branch 'MarlinFirmware/RCBugFix' into EMartinez-Changes 2017-01-12 22:22:52 +08:00
Scott Lahteine
93a9aa6b76 Merge pull request #5682 from thinkyhead/rc_spanish_jan
Updates to Spanish language
2017-01-12 06:14:10 -08:00
Scott Lahteine
7a9c1a279b Merge pull request #5681 from thinkyhead/rc_prevent_boot_loop
Reset watchdog in SD init to prevent reboot
2017-01-12 06:13:56 -08:00
Scott Lahteine
e409c7f9e8 Merge pull request #5645 from esenapaj/From-microseconds-to-milliseconds
From "microseconds" to "milliseconds"
2017-01-12 06:02:55 -08:00
emartinez167
020c6af7b0 Updates to Spanish language
Add missing Spanish language definitions.
2017-01-12 05:53:39 -08:00
Hans Raaf
d29cc8f7bc Reset watchdog in SD init to prevent reboot
If the watchdog is enabled and bootscreen + SD card checks take too long, Marlin may hang at boot time because of the reset loop. We have this happen all the time with the Anet board if no SD card is inserted.
2017-01-12 05:33:38 -08:00
Scott Lahteine
7743849608 Merge pull request #5680 from thinkyhead/rc_configs_puhlease
code_value_float tweak
2017-01-12 05:22:47 -08:00
Scott Lahteine
16357fbfdf Merge pull request #5619 from Ocarthon/RCBugFix
Disable SD Detect for K8400
2017-01-12 05:22:03 -08:00
Scott Lahteine
e57c0fce66 Move MOSFET changes above #include for RIGIDBOARD
Correction to #5629
2017-01-12 04:46:49 -08:00
Scott Lahteine
c376f6a2cb code_value_float tweak 2017-01-12 04:38:09 -08:00
Scott Lahteine
fb3c30e24c Fix lcd_wait_for_homing causing menu to block
As a showcase function for how to do waiting in the lcd menu, this function should be preserved.
2017-01-12 04:37:23 -08:00
Scott Lahteine
f8ae0fd29f Merge pull request #5647 from manianac/RCBugFix-PrepareMenuFix
Fix empty Prepare menu
2017-01-12 04:20:18 -08:00
Robert Kirk
aab5118c6a Remove error causing break command
Use index macro instead of e
2017-01-01 17:47:01 -05:00
esenapaj
d38e335272 From "microseconds" to "milliseconds"
delay() is milliseconds
2017-01-02 01:19:33 +09:00
Scott Lahteine
34d5eb5201 Merge pull request #5589 from thinkyhead/rc_configs_puhlease
Better sanity check for FILAMENT_CHANGE_FEATURE, FILAMENT_RUNOUT_SCRIPT
2016-12-30 04:56:30 -08:00
emartinez167
a2fe24f319 Fix some errors and update a message 2016-12-29 23:34:42 +08:00
Philip Standt
8ae2bc7e2e Disable SD Detect for K8400 2016-12-28 23:21:18 +01:00
emartinez167
0844da794d Updates to Spanish language
Add missing Spanish language definitions.
2016-12-24 22:11:14 +08:00
Scott Lahteine
4061fca1ad Sanity checks for FILAMENT_CHANGE_FEATURE and FILAMENT_RUNOUT_SCRIPT 2016-12-23 19:55:12 -08:00
Scott Lahteine
5ab7b91615 Comment on filament runout sensor config 2016-12-23 19:50:27 -08:00
Scott Lahteine
922c67f17d Merge pull request #5588 from thinkyhead/rc_remove_biv25
Drop biv2.5 delta configurations
2016-12-23 19:14:50 -08:00
Scott Lahteine
78459d5de1 Merge pull request #5587 from thinkyhead/rc_never
Define ADV_NEVER, ADV_RATE
2016-12-23 19:00:57 -08:00
Scott Lahteine
8c6c048551 drop biv2.5 delta configurations 2016-12-23 18:56:07 -08:00
Scott Lahteine
92dbeebf40 Define ADV_NEVER, ADV_RATE 2016-12-23 18:43:23 -08:00
Scott Lahteine
71378f72af Merge pull request #5577 from manianac/RCBugFix-M600Dryrun
Allow M600 when dryrun debugging
2016-12-22 19:07:05 -08:00
Robert Kirk
306c184b1a Allow M600 when dryrun debugging 2016-12-21 20:30:51 -05:00
Scott Lahteine
fe2ea2906f Merge pull request #5573 from thinkyhead/rc_unify_stepper_isr
LIN_ADVANCE with unified stepper ISR
2016-12-21 02:53:32 -08:00
Sebastianv650
84c685f8b5 First draft of Unified Stepper / E Advance ISR 2016-12-21 01:34:39 -08:00
Scott Lahteine
83021d82c6 Merge pull request #5502 from AnHardt/symbol-strings
Add symbol-strings
2016-12-21 00:51:59 -08:00
Scott Lahteine
036eccfd6e Merge pull request #5572 from Kaibob2/patch-5
Update language_de.h
2016-12-21 00:50:40 -08:00
Scott Lahteine
b794b76836 Merge pull request #5567 from AnHardt/fix5194
Fix 5194
2016-12-21 00:49:52 -08:00
Scott Lahteine
451ba5df01 Merge pull request #5516 from esenapaj/Suppress-warning
Suppress warning
2016-12-21 00:00:35 -08:00
Scott Lahteine
92dbc63949 Merge pull request #5571 from esenapaj/Update-Japanese-translation
Update Japanese translation
2016-12-20 23:59:55 -08:00
Kai
ade72535c4 Update language_de.h
Added tarnslation for
```
#define MSG_DEBUG_MENU 
#define MSG_PROGRESS_BAR_TEST
```
2016-12-21 08:57:39 +01:00
Scott Lahteine
06153add6b Merge pull request #5565 from thinkyhead/rc_negative_retract_in_menu
Followup to #5550 - spacing before "mm"
2016-12-20 18:42:37 -08:00
esenapaj
ab6b005867 Suppress warning 2016-12-21 09:13:03 +09:00
AnHardt
61f15ef7e7 Fix 5194
I have been a bit too radical in cleaning up this section.
2016-12-21 00:45:29 +01:00
esenapaj
60515ff700 Update Japanese translation
・Add new translation
2016-12-21 08:44:07 +09:00
Scott Lahteine
1e419655f3 Followup to #5550 - spacing before "mm" 2016-12-20 02:27:54 -08:00
Scott Lahteine
1a26ce1cdc Merge pull request #5550 from FHeilmann/patch-2
Allow negative retract values in the LCD
2016-12-20 02:10:22 -08:00
Scott Lahteine
bec30c89e7 Merge pull request #5522 from esenapaj/Add-description-for-dual-x
Add description for choice of DEFAULT_DUAL_X_CARRIAGE_MODE
2016-12-20 01:31:53 -08:00
Florian Heilmann
780dabf32b Merge pull request #8 from thinkyhead/rc_negative_retract_in_menu
Replace "+mm" with "mm." Allow negative recover-swap length.
2016-12-20 10:31:07 +01:00
Scott Lahteine
7739c0affa Change "+mm" to "mm" in most languages
- Japanese and Chinese still need update
2016-12-20 01:16:51 -08:00
Scott Lahteine
1cba425308 Allow negative recover-swap length from LCD 2016-12-20 01:16:08 -08:00
Scott Lahteine
298a8c6a3c Merge pull request #5561 from thinkyhead/rc_no_case_light
Support for M335 case light "no case light"
2016-12-20 01:06:59 -08:00
Scott Lahteine
644f45cbd8 Merge pull request #5563 from akaJes/m600
FILAMENT_CHANGE_FEATURE allowed in idle mode
2016-12-20 01:06:10 -08:00
Scott Lahteine
4213330d22 Merge pull request #5562 from thinkyhead/rc_char_lcd_tweaks
Fix various LCD-related issues
2016-12-20 01:03:38 -08:00
Scott Lahteine
0d2fc13516 Place "Level Bed" closer to "Auto Home" 2016-12-20 00:51:03 -08:00
Scott Lahteine
b031d28ebf Encoder events should not skip stripes 2016-12-20 00:21:51 -08:00
Scott Lahteine
22881f38b9 Fix updating of "bool" menu items 2016-12-20 00:21:51 -08:00
Scott Lahteine
eb68715b94 No "Cooldown" menu if heaters are off 2016-12-20 00:21:51 -08:00
Jesus
4ed976b5ff m600 fixes 2016-12-20 09:47:46 +02:00
Damien
4e2639942b Support for M335 case light "no case light" 2016-12-19 23:23:08 -08:00
Scott Lahteine
18ba31e9b5 Add Debug Menu with LCD_PROGRESS_BAR_TEST as an example 2016-12-19 22:57:14 -08:00
Scott Lahteine
03af5961b0 Hide (or remove) custom character change on boot screen 2016-12-19 22:27:28 -08:00
Scott Lahteine
1642f5ed31 Add macro to some en strings 2016-12-19 22:27:28 -08:00
Scott Lahteine
dbb2d56c89 Correct comment on watchdog timer 2016-12-19 22:27:28 -08:00
Scott Lahteine
41a30923f3 Merge pull request #5559 from thinkyhead/rc_minimum_gcc_version
Throw an error for gcc before 4.7
2016-12-19 19:50:44 -08:00
Scott Lahteine
04f77df6c0 Merge pull request #5560 from thinkyhead/rc_bl_status
Have bed leveling status output current status, not requested.
2016-12-19 19:18:06 -08:00
Scott Lahteine
6d6a1db6ec Apply const to _EEPROM_writeData value param 2016-12-19 18:50:43 -08:00
Robert Kirk
f724ef5820 Have bed leveling status output current status, not requested. 2016-12-19 18:47:45 -08:00
Scott Lahteine
20218e553d Merge pull request #5527 from MagoKimbra/rc_configuration_store_fix_size
Fix size
2016-12-19 18:47:28 -08:00
Scott Lahteine
dcfbe2bd3c Throw an error for gcc before 4.7 2016-12-19 18:30:51 -08:00
Scott Lahteine
82fde7df2e Merge pull request #5512 from AnHardt/speed-compare-bbr
Optimize handling of block_buffer_runtime()
2016-12-19 18:21:06 -08:00
Scott Lahteine
64a44f697c Merge pull request #5557 from thinkyhead/rc_thermistor_breakup
Split up thermistor tables
2016-12-19 15:01:18 -08:00
Scott Lahteine
8986225752 Spacing, cleanup in speed_lookuptable.h 2016-12-19 14:52:45 -08:00
Scott Lahteine
e12c8e5cac Split up thermistor tables 2016-12-19 14:47:54 -08:00
Florian Heilmann
a7334fd2a0 Allow negative retract values in the LCD
This can already be done via G-Code, so adding the capability to the LCD should be straight forward.
2016-12-19 14:19:06 +01:00
AnHardt
292eb365c6 Optimize handling of block_buffer_runtime()
millis_t is long - divisions take for ever.

Return a kind of millisecond instead of microsecond -
divided by 1024 instead of 1000 for speed. (2.4% error)

That does not matter because block_buffer_runtime is
already a too short estimation.
Shrink the return-type.
2016-12-19 11:47:28 +01:00
esenapaj
6854f44bf2 Add description for choice of DEFAULT_DUAL_X_CARRIAGE_MODE 2016-12-19 02:21:10 +09:00
Scott Lahteine
3f6f036f7c Merge pull request #5524 from thinkyhead/rc_optional_dogm_splitup
Report EEPROM data size, not final index
2016-12-16 18:55:48 -08:00
MagoKimbra
86ba7e4542 Fix size
Fix size for writeData and readData.
For bilinear grid 11 x 11 for example, size is 4 (float) x 11 x 11 = 484. uint8_t max is 255.
2016-12-16 14:49:33 +01:00
Scott Lahteine
f9f75c8016 Fix USE_RAW_KINEMATICS in prepare_kinematic_move_to 2016-12-15 23:15:38 -08:00
Scott Lahteine
87921f390a Clarify what are "logical" positions in the planner 2016-12-15 23:15:38 -08:00
Scott Lahteine
a4f10f59c3 Write the E parameter length correctly 2016-12-15 23:15:38 -08:00
Scott Lahteine
2e904cb4f9 Merge pull request #5514 from esenapaj/Update-Japanese-translation
Update Japanese translation
2016-12-15 21:38:40 -08:00
Scott Lahteine
0b6817e0f9 Merge pull request #5505 from android444/patch-4
Update for translations language_pl.h
2016-12-15 21:38:18 -08:00
Scott Lahteine
3bd76f60e4 Report EEPROM data size, not final index 2016-12-15 20:26:28 -08:00
Scott Lahteine
78d6d6e076 Merge pull request #5452 from thinkyhead/rc_save_your_mesh
Save Bed Leveling to EEPROM
2016-12-15 20:23:01 -08:00
Scott Lahteine
0d0aa6c20d Patch type for max_acceleration_mm_per_s2 save/restore 2016-12-15 20:05:42 -08:00
Scott Lahteine
d4f5418802 Merge pull request #5517 from esenapaj/Fix-for-PR-#5255
Fix for the PR #5255 (Case light menu (3rd attempt))
2016-12-15 20:01:22 -08:00
Scott Lahteine
fa7010b0a1 Merge pull request #5515 from esenapaj/Remove-unnecessary-tabs-and-spaces
Remove unnecessary tabs and spaces
2016-12-15 19:58:32 -08:00
Scott Lahteine
6d7b1cdf6c Add M421 for ABL Bilinear 2016-12-15 19:39:11 -08:00
Scott Lahteine
32e65dc429 Extend M420 to print state and, with V, the matrix / mesh 2016-12-15 19:39:11 -08:00
Scott Lahteine
d04258753b Don't throw away the bed level matrix on G28 2016-12-15 19:21:18 -08:00
Scott Lahteine
8f0f225d10 Save ABL Planar Matrix to EEPROM 2016-12-15 19:21:15 -08:00
Scott Lahteine
e2429a9da1 Generalize Bed Leveling flag in EEPROM 2016-12-15 19:20:52 -08:00
Scott Lahteine
e42fd7813a Save ABL Bilinear Grid to EEPROM 2016-12-15 19:20:48 -08:00
Scott Lahteine
492b68f8e3 Better EEPROM read/write error handling 2016-12-15 19:08:44 -08:00
Scott Lahteine
55722c09da Use "UNPROBED" for un-probed bed_level_grid points 2016-12-15 19:08:44 -08:00
Scott Lahteine
2643404ac8 Throw an error in M420 if can't enable 2016-12-15 19:08:43 -08:00
Scott Lahteine
b1539394fd Use planner.unapply_leveling to undo tilt in G29 2016-12-15 19:08:43 -08:00
Scott Lahteine
04636f78eb Re-enable MBL/ABL after M48 2016-12-15 19:08:43 -08:00
Scott Lahteine
9b41638672 Minor tweak to G29 grid points 2016-12-15 19:08:42 -08:00
Scott Lahteine
daa2cad21f Fix comment on G29 to include 'Z' 2016-12-15 19:08:42 -08:00
Scott Lahteine
8244fefcc2 Tweak call to reset_bed_level in G29 2016-12-15 19:08:42 -08:00
Scott Lahteine
0995a5d734 Fixup reset_bed_level 2016-12-15 19:08:42 -08:00
Scott Lahteine
1b2fb2bdc7 ABL_GRID_POINTS_* => ABL_GRID_MAX_POINTS_* 2016-12-15 19:08:41 -08:00
Scott Lahteine
b091c9ceb7 Merge pull request #5520 from esenapaj/Fix-for-commented-section
Fix for commented section of Config_RetrieveSettings()
2016-12-15 18:16:30 -08:00
esenapaj
d486361c69 Fix for commented section of Config_RetrieveSettings() 2016-12-16 04:34:47 +09:00
esenapaj
88157ba529 Fix for the PR #5255 (Case light menu (3rd attempt)) 2016-12-16 00:57:32 +09:00
esenapaj
069c6b38dd Remove unnecessary tabs and spaces 2016-12-16 00:21:32 +09:00
esenapaj
9c8116aedf Update Japanese translation
・Add new translation
2016-12-16 00:06:58 +09:00
AnHardt
57b1275cde Add symbol-string to _de
Add symbol-string for _de
to reduce the frquencey of regenerating 'mappers' and 'fonts'
with the new utf-system.
2016-12-15 14:37:18 +01:00
android444
3363d2c937 Update for translations language_pl.h 2016-12-14 17:32:33 +01:00
Scott Lahteine
7ca4f16a5c Merge pull request #5430 from thinkyhead/rc_optional_dogm_splitup
Move Hollow Frame options to config-adv
2016-12-14 04:55:15 -08:00
Scott Lahteine
06af3b62ba Move HOLLOW_FRAME options to config_adv 2016-12-14 04:31:27 -08:00
Scott Lahteine
67ca6c7bfe Codestyle tweaks to ultralcd.cpp 2016-12-14 04:20:33 -08:00
Scott Lahteine
8d9fcd8e6f Merge pull request #5495 from AnHardt/autoadjusting_display-updates
Adaptive screen updates for all kinds of displays
2016-12-14 04:16:26 -08:00
Scott Lahteine
77a360912d Merge pull request #5491 from yhfudev/devel-rcbugfix-language-headers
UTF-8 language header files
2016-12-14 02:23:09 -08:00
Scott Lahteine
efb8b8425c Merge pull request #5493 from thinkyhead/rc_fix_recover_unhop
Prevent retract un-hop at wrong height
2016-12-14 02:20:08 -08:00
AnHardt
d0e24e0876 Adaptive screen updates for all kinds of displays
The target here is to update the screens of graphical and char base
displays as fast as possible, without draining the planner buffer too much.

For that measure the time it takes to draw and transfer one
(partial) screen to the display. Build a max. value from that.
Because ther can be large differences, depending on how much the display
updates are interrupted, the max value is decreased by one ms/s. This way
it can shrink again.
On the other side we keep track on how much time it takes to empty the
planner buffer.
Now we draw the next (partial) display update only then, when we do not
drain the planner buffer to much. We draw only when the time in the
buffer is two times larger than a update takes, or the buffer is empty anyway.

When we have begun to draw a screen we do not wait until the next 100ms
time slot comes. We draw the next partial screen as fast as possible, but
give the system a chance to refill the buffers a bit.

When we see, during drawing a screen, the screen contend has changed,
we stop the current draw and begin to draw the new content from the top.
2016-12-13 18:44:34 +01:00
yhfudev
2dbd38ce16 tag the utf-8 strings 2016-12-13 11:54:35 -05:00
Scott Lahteine
94ffb58da7 Prevent retract un-hop at wrong height 2016-12-13 08:24:12 -08:00
Scott Lahteine
0772c8e55f Merge pull request #5487 from thinkyhead/rc_easier_move_axis
Rearrange Move Menu, Fix up Delta Calibration
2016-12-13 07:07:05 -08:00
Scott Lahteine
b2c8de856b Merge pull request #5478 from AnHardt/stepspermm
Replace ftostr62sign with ftostr62rj
2016-12-13 07:05:42 -08:00
Scott Lahteine
1fd8185d37 Merge pull request #5492 from thinkyhead/rc_fix_language_es
Fix multiple definitions of message macros in the language-es.h
2016-12-13 06:57:52 -08:00
yhfudev
1cdffdede7 fix multiple definitions of message macros in the language-es.h 2016-12-13 06:48:38 -08:00
Scott Lahteine
b67f8cb499 Merge pull request #5490 from jbrazio/update-bqhp2
Update the bq Hephestos 2 example configuration
2016-12-13 05:04:24 -08:00
Scott Lahteine
93b2833347 Move Menu: Select axis first, resolution after 2016-12-13 03:11:14 -08:00
Scott Lahteine
48aa0f6475 Merge pull request #5475 from AnHardt/utf-mapper-tr
utf8-mapper for Turkish
2016-12-13 03:03:22 -08:00
Scott Lahteine
b9ee0d7bd3 Merge pull request #5488 from thinkyhead/rc_fade_compiler_warn
Patch fade_factor compiler warning
2016-12-13 03:00:47 -08:00
Scott Lahteine
641e0936d4 Patch up Delta Calibration Menu 2016-12-13 02:42:28 -08:00
Scott Lahteine
b4dbf4d18a Non-reentrant "Moving..." screen to safely wait in LCD 2016-12-13 02:42:27 -08:00
Scott Lahteine
7b625e0048 Patch fade_factor compiler warning 2016-12-13 02:29:01 -08:00
Scott Lahteine
6fa8fd15e2 Add negative temperatures for Thermistor 1
Changes from #5485 by @AndKe
2016-12-13 02:06:16 -08:00
Scott Lahteine
2b5d424394 Use handle_reprapworld_keypad for keypad handling 2016-12-13 01:41:08 -08:00
Scott Lahteine
887ed73c9b Expose delta_clip_start_height for use by others 2016-12-13 01:41:08 -08:00
João Brázio
3f75edb1d6 Updated bq Hephestos 2 example configuration 2016-12-13 09:26:07 +00:00
Scott Lahteine
6080ac566a Merge pull request #5483 from thinkyhead/rc_aragonese_fixup
Update Aragonese translation
2016-12-12 18:26:07 -08:00
Daniel Martinez
b796e7031d Update Aragonese translation 2016-12-12 17:36:33 -08:00
AnHardt
cd2b74e88d Replace ftostr62sign with ftostr62rj
`ftostr62sign()` is used only when displaing/editing
Steps/mm. A sign is not needed - the value is always positive.
Because the number part is long there is no't much place for the values name.
With this PR the is one more char for the name possible.
2016-12-12 20:25:20 +01:00
AnHardt
795541f87e utf8-mapper for Turkish
The non utf8 version of turkish is a bit unhandy.

Delete `language_tr.h`
Rename `language_tr_utf.h` to `language_tr.h`
Provide a propper utf8-mapper for Turkish and use it.
2016-12-12 15:56:59 +01:00
Scott Lahteine
7c71bb2900 Merge pull request #5471 from thinkyhead/rc_planner_report_m503
Patch to show E factors in M503
2016-12-11 17:47:41 -08:00
Scott Lahteine
39401b7472 Patch to show E factors in M503 2016-12-11 17:37:29 -08:00
Scott Lahteine
6b50230022 Merge pull request #5447 from thinkyhead/rc_update_dutch
Dutch cleanup, ordering, placeholders
2016-12-10 22:13:20 -08:00
Scott Lahteine
2c97c11731 Merge pull request #5454 from thinkyhead/rc_fix_delta_g29
Fix G29 starting height on DELTA
2016-12-10 22:10:33 -08:00
Scott Lahteine
8239c45b30 Merge pull request #5448 from thinkyhead/rc_eeprom_bump
EEPROM: Prolong life. Better support for `DISTINCT_E_FACTORS`.
2016-12-10 22:06:00 -08:00
Scott Lahteine
21ed43df5f New Dutch terms 2016-12-10 21:59:45 -08:00
Scott Lahteine
4bc6536f54 Move to safe zone on DELTA if using do_blocking_move_to* 2016-12-10 21:28:24 -08:00
Scott Lahteine
6f389158d7 Compile less code with EEPROM off 2016-12-09 06:05:32 -08:00
Scott Lahteine
f2301a2a04 Add e-stepper count to EEPROM (for planner vars) 2016-12-09 06:05:31 -08:00
Scott Lahteine
53c9fca0f6 Only write to EEPROM when a byte changes 2016-12-09 06:05:31 -08:00
Scott Lahteine
72fe995c42 Merge pull request #5449 from AnHardt/volatile-bbru
Make block_buffer_runtime_us volatile
2016-12-09 05:57:45 -08:00
AnHardt
13eebd11cf volatile_block_buffer_runtime_us
`block_buffer_runtime_us` is mangled in the planner and in the stepper-ISR.
So it needs to be volatile and interrupt protected.
2016-12-09 14:49:02 +01:00
Scott Lahteine
8383f35b40 Merge pull request #5445 from thinkyhead/rc_reduce_jerk_code
Slightly shrink jerk and advance code
2016-12-09 02:54:03 -08:00
Scott Lahteine
52f8924f6e Merge pull request #5446 from gege2b/RCBugFix-french
Update french translation (LIGHTS str)
2016-12-09 02:49:32 -08:00
Gege2B
40453c1b9a Update french translation (LIGHTS str) 2016-12-09 11:18:29 +01:00
Scott Lahteine
fc2fc828b3 Prettify LIN_ADVANCE code with the positive condition 2016-12-09 00:29:07 -08:00
Scott Lahteine
1929502e15 Add const to some variables 2016-12-09 00:29:06 -08:00
Scott Lahteine
2da4d22520 Pretty up ADVANCE code 2016-12-08 22:51:28 -08:00
Scott Lahteine
af024e1d7c Pretty up coast / reverse jerk code 2016-12-08 22:50:25 -08:00
Scott Lahteine
3f3b5c86d8 Slightly shrink code for jerk-based reduction of safe_speed 2016-12-08 22:24:29 -08:00
Scott Lahteine
dfdb180db4 Merge pull request #5440 from AnHardt/simplify-long_move
Simplify long_move()
2016-12-08 18:03:20 -08:00
AnHardt
87fe20b5f5 Simplify long_move()
We are not really interested in, if there are blocks.
All information we need is in `block_buffer_runtime_us`.
2016-12-09 00:13:35 +01:00
Scott Lahteine
574d9c7d3d Merge pull request #5432 from Kaibob2/patch-2
Update language_de.h
2016-12-08 13:14:04 -08:00
Scott Lahteine
f089279263 Merge pull request #5431 from esenapaj/Suppress-warnings,-etc
Suppress warnings, etc
2016-12-08 13:10:12 -08:00
Scott Lahteine
d92ccb230c Merge pull request #5438 from AnHardt/patch-long_move
Patch long_move()
2016-12-08 13:08:36 -08:00
Scott Lahteine
a1e0842c8b Merge pull request #5436 from esenapaj/Remove-redundant-E,-etc-plan-B
Remove redundant "E", etc plan B
2016-12-08 13:06:07 -08:00
AnHardt
706b240251 Patch long_move()
While the last move in the planner_buffer is running
it's duration is already subtracted from block_buffer_runtime_us.
2016-12-08 21:03:26 +01:00
esenapaj
a298a58684 Remove redundant "E" 2016-12-09 02:27:34 +09:00
Kai
390a6d976a Update language_de.h
#define MSG_ENDSTOP_ABORT  doesn't fit in Display 
See https://github.com/MarlinFirmware/Marlin/issues/5401#issuecomment-265714487
2016-12-08 12:18:19 +01:00
esenapaj
e9393c3634 Suppress warnings, etc
・Suppress warnings
・Remove unused variable "did_update"
2016-12-08 17:47:59 +09:00
Scott Lahteine
4ea87b8f34 Merge pull request #5414 from thinkyhead/rc_sanitycheck_inverting
Sanity-check inverting for Z probe and Z endstop
2016-12-08 00:28:33 -08:00
Scott Lahteine
da6a094424 Sanity-check inverting and pullups for Z probe and Z endstop
`Z_MIN_ENDSTOP_INVERTING` must match `Z_MIN_PROBE_ENDSTOP_INVERTING`
when using `Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN`.
This is easy to overlook.
2016-12-08 00:12:19 -08:00
Scott Lahteine
a9f64537ff Merge pull request #5429 from thinkyhead/rc_mention_M205
Fix compile error with LCD_I2C_VIKI
2016-12-07 22:16:57 -08:00
Scott Lahteine
3fb43c11fc Fix compile error with LCD_I2C_VIKI 2016-12-07 23:29:45 -06:00
Scott Lahteine
c1e1f63ffa Merge pull request #5424 from thinkyhead/rc_mention_M205
Include M205 note in configurations
2016-12-07 18:18:59 -06:00
Scott Lahteine
aa241c63b3 Include M205 note in configurations 2016-12-07 14:45:44 -06:00
243 changed files with 56308 additions and 25788 deletions

20
.gitattributes vendored Normal file
View File

@@ -0,0 +1,20 @@
# Set the default behavior, in case people don't have core.autocrlf set.
* text=auto
# Files with Unix line endings
*.c text eol=lf
*.cpp text eol=lf
*.h text eol=lf
*.ino text eol=lf
*.py text eol=lf
*.sh text eol=lf
*.scad text eol=lf
# Files with native line endings
# *.sln text
# Binary files
*.png binary
*.jpg binary
*.fon binary

18
.gitignore vendored
View File

@@ -1,6 +1,6 @@
# #
# Marlin 3D Printer Firmware # Marlin 3D Printer Firmware
# Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] # Copyright (C) 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
# #
# Based on Sprinter and grbl. # Based on Sprinter and grbl.
# Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm # Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
@@ -42,7 +42,7 @@ applet/
*.i *.i
*.ii *.ii
*.swp *.swp
tags
# #
# C++ # C++
@@ -118,3 +118,17 @@ applet/
#PlatformIO files/dirs #PlatformIO files/dirs
.pioenvs .pioenvs
.piolib .piolib
.piolibdeps
#Visual Studio
*.sln
*.vcxproj
*.vcxproj.filters
Marlin/Release/
Marlin/Debug/
Marlin/__vm/
Marlin/.vs/
#cmake
CMakeLists.txt
Marlin/CMakeLists.txt

View File

@@ -47,8 +47,8 @@ install:
# - sudo mv TMC26XStepper /usr/local/share/arduino/libraries/TMC26XStepper # - sudo mv TMC26XStepper /usr/local/share/arduino/libraries/TMC26XStepper
# #
# Install: TMC2130 Stepper Motor Controller library # Install: TMC2130 Stepper Motor Controller library
- git clone https://github.com/MarlinFirmware/Trinamic_TMC2130.git - git clone https://github.com/teemuatlut/TMC2130Stepper.git
- sudo mv Trinamic_TMC2130/Trinamic_TMC2130 /usr/local/share/arduino/libraries/Trinamic_TMC2130 - sudo mv TMC2130Stepper /usr/local/share/arduino/libraries/TMC2130Stepper
# #
before_script: before_script:
# #
@@ -83,18 +83,23 @@ script:
- opt_set TEMP_SENSOR_1 1 - opt_set TEMP_SENSOR_1 1
- build_marlin - build_marlin
# #
# Test 3 extruders on RUMBA (can use any board with >=3 extruders defined) # Test 5 extruders on AZTEEG_X3_PRO (can use any board with >=5 extruders defined)
# Include a test for LIN_ADVANCE here also # Include a test for LIN_ADVANCE here also
# #
- opt_set MOTHERBOARD BOARD_RUMBA - opt_set MOTHERBOARD BOARD_AZTEEG_X3_PRO
- opt_set EXTRUDERS 3 - opt_set EXTRUDERS 5
- opt_set TEMP_SENSOR_2 1 - opt_set TEMP_SENSOR_1 1
- opt_set TEMP_SENSOR_2 5
- opt_set TEMP_SENSOR_3 20
- opt_set TEMP_SENSOR_4 999
- opt_set TEMP_SENSOR_BED 1
- opt_enable_adv LIN_ADVANCE - opt_enable_adv LIN_ADVANCE
- build_marlin - build_marlin
# #
# Test PIDTEMPBED # Test PIDTEMPBED
# #
- restore_configs - restore_configs
- opt_set TEMP_SENSOR_BED 1
- opt_enable PIDTEMPBED - opt_enable PIDTEMPBED
- build_marlin - build_marlin
# #
@@ -117,47 +122,53 @@ script:
- opt_set ABL_GRID_POINTS_Y 16 - opt_set ABL_GRID_POINTS_Y 16
- build_marlin - build_marlin
# #
# Test a Sled Z Probe # Test a simple build of AUTO_BED_LEVELING_UBL
# #
- restore_configs - restore_configs
- opt_enable Z_PROBE_SLED - opt_enable AUTO_BED_LEVELING_UBL UBL_G26_MESH_EDITING ENABLE_LEVELING_FADE_HEIGHT FIX_MOUNTED_PROBE EEPROM_SETTINGS G3D_PANEL
- build_marlin - build_marlin
# #
# Test a Sled Z Probe
# ...with AUTO_BED_LEVELING_LINEAR, DEBUG_LEVELING_FEATURE, EEPROM_SETTINGS, and EEPROM_CHITCHAT # ...with AUTO_BED_LEVELING_LINEAR, DEBUG_LEVELING_FEATURE, EEPROM_SETTINGS, and EEPROM_CHITCHAT
# #
- opt_enable AUTO_BED_LEVELING_LINEAR DEBUG_LEVELING_FEATURE EEPROM_SETTINGS EEPROM_CHITCHAT - restore_configs
- opt_enable Z_PROBE_SLED AUTO_BED_LEVELING_LINEAR DEBUG_LEVELING_FEATURE EEPROM_SETTINGS EEPROM_CHITCHAT
- build_marlin - build_marlin
# #
# Test a Servo Probe # Test a Servo Probe
# ...with AUTO_BED_LEVELING_3POINT, DEBUG_LEVELING_FEATURE, EEPROM_SETTINGS, EEPROM_CHITCHAT, EXTENDED_CAPABILITIES_REPORT, and AUTO_REPORT_TEMPERATURES
# #
- restore_configs - restore_configs
- opt_enable NUM_SERVOS Z_ENDSTOP_SERVO_NR Z_SERVO_ANGLES DEACTIVATE_SERVOS_AFTER_MOVE - opt_enable NUM_SERVOS Z_ENDSTOP_SERVO_NR Z_SERVO_ANGLES DEACTIVATE_SERVOS_AFTER_MOVE
- build_marlin
#
# ...with AUTO_BED_LEVELING_3POINT, DEBUG_LEVELING_FEATURE, EEPROM_SETTINGS, EEPROM_CHITCHAT, EXTENDED_CAPABILITIES_REPORT, and AUTO_REPORT_TEMPERATURES
#
- opt_enable AUTO_BED_LEVELING_3POINT DEBUG_LEVELING_FEATURE EEPROM_SETTINGS EEPROM_CHITCHAT - opt_enable AUTO_BED_LEVELING_3POINT DEBUG_LEVELING_FEATURE EEPROM_SETTINGS EEPROM_CHITCHAT
- opt_enable_adv EXTENDED_CAPABILITIES_REPORT AUTO_REPORT_TEMPERATURES - opt_enable_adv EXTENDED_CAPABILITIES_REPORT AUTO_REPORT_TEMPERATURES AUTOTEMP
- build_marlin - build_marlin
# #
# Test MESH_BED_LEVELING feature, with LCD # Test MESH_BED_LEVELING feature, with LCD
# #
- restore_configs - restore_configs
- opt_enable MESH_BED_LEVELING MESH_G28_REST_ORIGIN MANUAL_BED_LEVELING ULTIMAKERCONTROLLER - opt_enable MESH_BED_LEVELING MESH_G28_REST_ORIGIN LCD_BED_LEVELING ULTIMAKERCONTROLLER
- build_marlin
#
# Test PROBE_MANUALLY feature, with LCD support
#
- restore_configs
- opt_enable PROBE_MANUALLY AUTO_BED_LEVELING_BILINEAR LCD_BED_LEVELING ULTIMAKERCONTROLLER
- build_marlin - build_marlin
# #
# Test EEPROM_SETTINGS, EEPROM_CHITCHAT, M100_FREE_MEMORY_WATCHER, # Test EEPROM_SETTINGS, EEPROM_CHITCHAT, M100_FREE_MEMORY_WATCHER,
# INCH_MODE_SUPPORT, TEMPERATURE_UNITS_SUPPORT # INCH_MODE_SUPPORT, TEMPERATURE_UNITS_SUPPORT
# #
- restore_configs - restore_configs
- opt_enable EEPROM_SETTINGS EEPROM_CHITCHAT M100_FREE_MEMORY_WATCHER INCH_MODE_SUPPORT TEMPERATURE_UNITS_SUPPORT - opt_enable EEPROM_SETTINGS EEPROM_CHITCHAT M100_FREE_MEMORY_WATCHER M100_FREE_MEMORY_DUMPER M100_FREE_MEMORY_CORRUPTOR INCH_MODE_SUPPORT TEMPERATURE_UNITS_SUPPORT
- build_marlin - build_marlin
# #
# Mixing Extruder # Mixing Extruder with 5 steppers
# #
- restore_configs - restore_configs
- opt_set MOTHERBOARD BOARD_AZTEEG_X3_PRO
- opt_enable MIXING_EXTRUDER - opt_enable MIXING_EXTRUDER
- opt_set MIXING_STEPPERS 2 - opt_set MIXING_STEPPERS 5
- build_marlin - build_marlin
# #
# Test DUAL_X_CARRIAGE # Test DUAL_X_CARRIAGE
@@ -195,11 +206,11 @@ script:
- opt_set MOTHERBOARD BOARD_MINIRAMBO - opt_set MOTHERBOARD BOARD_MINIRAMBO
- build_marlin - build_marlin
# #
# Test FILAMENT_CHANGE_FEATURE and LCD_INFO_MENU # Test FILAMENT_CHANGE_FEATURE, PARK_HEAD_ON_PAUSE, and LCD_INFO_MENU
# #
- restore_configs - restore_configs
- opt_enable ULTIMAKERCONTROLLER - opt_enable ULTIMAKERCONTROLLER
- opt_enable_adv FILAMENT_CHANGE_FEATURE LCD_INFO_MENU - opt_enable_adv FILAMENT_CHANGE_FEATURE PARK_HEAD_ON_PAUSE LCD_INFO_MENU
- build_marlin - build_marlin
# #
# Enable filament sensor # Enable filament sensor
@@ -226,10 +237,10 @@ script:
- opt_enable COREXY - opt_enable COREXY
- build_marlin - build_marlin
# #
# Enable COREXZ # Enable COREYX (swapped)
# #
- restore_configs - restore_configs
- opt_enable COREXZ - opt_enable COREYX
- build_marlin - build_marlin
# #
# Enable Z_DUAL_STEPPER_DRIVERS, Z_DUAL_ENDSTOPS # Enable Z_DUAL_STEPPER_DRIVERS, Z_DUAL_ENDSTOPS
@@ -298,6 +309,15 @@ script:
- opt_enable G3D_PANEL SDSUPPORT - opt_enable G3D_PANEL SDSUPPORT
- build_marlin - build_marlin
# #
# Add SDCARD_SORT_ALPHA, test G3D_PANEL again
#
- opt_enable_adv SDCARD_SORT_ALPHA
- opt_set_adv SDSORT_GCODE true
- opt_set_adv SDSORT_USES_RAM true
- opt_set_adv SDSORT_USES_STACK true
- opt_set_adv SDSORT_CACHE_NAMES true
- build_marlin
#
# REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER # REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER
# #
- restore_configs - restore_configs
@@ -314,7 +334,7 @@ script:
# RA_CONTROL_PANEL # RA_CONTROL_PANEL
# #
- restore_configs - restore_configs
- opt_enable RA_CONTROL_PANEL - opt_enable RA_CONTROL_PANEL PINS_DEBUGGING
- build_marlin - build_marlin
# #
######## I2C LCD/PANELS ############## ######## I2C LCD/PANELS ##############
@@ -368,9 +388,9 @@ script:
- opt_enable AUTO_BED_LEVELING_BILINEAR Z_PROBE_ALLEN_KEY - opt_enable AUTO_BED_LEVELING_BILINEAR Z_PROBE_ALLEN_KEY
- build_marlin - build_marlin
# #
# Delta Config (Mini Kossel) # Delta Config (FLSUN AC because it's complex)
# #
- use_example_configs delta/kossel_mini - use_example_configs delta/FLSUN/auto_calibrate
- build_marlin - build_marlin
# #
# Makibox Config need to check board type for Teensy++ 2.0 # Makibox Config need to check board type for Teensy++ 2.0
@@ -387,7 +407,9 @@ script:
# TMC2130 Config # TMC2130 Config
# #
- restore_configs - restore_configs
- opt_enable_adv HAVE_TMC2130DRIVER X_IS_TMC2130 Y_IS_TMC2130 Z_IS_TMC2130 E0_IS_TMC2130 - opt_enable_adv HAVE_TMC2130 X_IS_TMC2130 Y_IS_TMC2130 Z_IS_TMC2130
- build_marlin
- opt_enable_adv AUTOMATIC_CURRENT_CONTROL STEALTHCHOP HYBRID_THRESHOLD SENSORLESS_HOMING
- build_marlin - build_marlin
# #
# tvrrug Config need to check board type for sanguino atmega644p # tvrrug Config need to check board type for sanguino atmega644p

View File

@@ -65,12 +65,14 @@
#define SD_DETECT_INVERTED #define SD_DETECT_INVERTED
#endif #endif
#ifndef ENCODER_PULSES_PER_STEP #endif
#define ENCODER_PULSES_PER_STEP 4
#endif #if ENABLED(OLED_PANEL_TINYBOY2)
#ifndef ENCODER_STEPS_PER_MENU_ITEM #define U8GLIB_SSD1306
#define ENCODER_STEPS_PER_MENU_ITEM 1 #define ULTIPANEL
#endif #define NEWPANEL
#define REVERSE_ENCODER_DIRECTION
#define REVERSE_MENU_DIRECTION
#endif #endif
// Generic support for SSD1306 / SH1106 OLED based LCDs. // Generic support for SSD1306 / SH1106 OLED based LCDs.
@@ -85,14 +87,6 @@
#if ENABLED(BQ_LCD_SMART_CONTROLLER) #if ENABLED(BQ_LCD_SMART_CONTROLLER)
#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER #define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER
#ifndef ENCODER_PULSES_PER_STEP
#define ENCODER_PULSES_PER_STEP 4
#endif
#ifndef ENCODER_STEPS_PER_MENU_ITEM
#define ENCODER_STEPS_PER_MENU_ITEM 1
#endif
#ifndef LONG_FILENAME_HOST_SUPPORT #ifndef LONG_FILENAME_HOST_SUPPORT
#define LONG_FILENAME_HOST_SUPPORT #define LONG_FILENAME_HOST_SUPPORT
#endif #endif
@@ -145,14 +139,6 @@
#define LCD_I2C_TYPE_MCP23017 #define LCD_I2C_TYPE_MCP23017
#define LCD_I2C_ADDRESS 0x20 // I2C Address of the port expander #define LCD_I2C_ADDRESS 0x20 // I2C Address of the port expander
#define LCD_USE_I2C_BUZZER //comment out to disable buzzer on LCD #define LCD_USE_I2C_BUZZER //comment out to disable buzzer on LCD
#ifndef ENCODER_PULSES_PER_STEP
#define ENCODER_PULSES_PER_STEP 4
#endif
#ifndef ENCODER_STEPS_PER_MENU_ITEM
#define ENCODER_STEPS_PER_MENU_ITEM 1
#endif
#define ULTIPANEL #define ULTIPANEL
#define NEWPANEL #define NEWPANEL
#endif #endif
@@ -179,6 +165,17 @@
#endif #endif
#endif #endif
// Set encoder detents for well-known controllers
#if ENABLED(miniVIKI) || ENABLED(VIKI2) || ENABLED(ELB_FULL_GRAPHIC_CONTROLLER) || ENABLED(OLED_PANEL_TINYBOY2) \
|| ENABLED(BQ_LCD_SMART_CONTROLLER) || ENABLED(LCD_I2C_PANELOLU2) || ENABLED(REPRAP_DISCOUNT_SMART_CONTROLLER)
#ifndef ENCODER_PULSES_PER_STEP
#define ENCODER_PULSES_PER_STEP 4
#endif
#ifndef ENCODER_STEPS_PER_MENU_ITEM
#define ENCODER_STEPS_PER_MENU_ITEM 1
#endif
#endif
// Shift register panels // Shift register panels
// --------------------- // ---------------------
// 2 wire Non-latching LCD SR from: // 2 wire Non-latching LCD SR from:
@@ -233,8 +230,12 @@
#define LCD_STR_DEGREE "\x09" #define LCD_STR_DEGREE "\x09"
#define LCD_STR_SPECIAL_MAX '\x09' #define LCD_STR_SPECIAL_MAX '\x09'
// Maximum here is 0x1f because 0x20 is ' ' (space) and the normal charsets begin. // Maximum here is 0x1F because 0x20 is ' ' (space) and the normal charsets begin.
// Better stay below 0x10 because DISPLAY_CHARSET_HD44780_WESTERN begins here. // Better stay below 0x10 because DISPLAY_CHARSET_HD44780_WESTERN begins here.
// Symbol characters
#define LCD_STR_FILAM_DIA "\xf8"
#define LCD_STR_FILAM_MUL "\xa4"
#else #else
/* Custom characters defined in the first 8 characters of the LCD */ /* Custom characters defined in the first 8 characters of the LCD */
#define LCD_STR_BEDTEMP "\x00" // Print only as a char. This will have 'unexpected' results when used in a string! #define LCD_STR_BEDTEMP "\x00" // Print only as a char. This will have 'unexpected' results when used in a string!
@@ -278,6 +279,8 @@
#define BOOTSCREEN_TIMEOUT 2500 #define BOOTSCREEN_TIMEOUT 2500
#endif #endif
#define HAS_DEBUG_MENU ENABLED(LCD_PROGRESS_BAR_TEST)
/** /**
* Extruders have some combination of stepper motors and hotends * Extruders have some combination of stepper motors and hotends
* so we separate these concepts into the defines: * so we separate these concepts into the defines:
@@ -342,6 +345,9 @@
#undef DEACTIVATE_SERVOS_AFTER_MOVE #undef DEACTIVATE_SERVOS_AFTER_MOVE
#undef SERVO_DELAY #undef SERVO_DELAY
#define SERVO_DELAY 50 #define SERVO_DELAY 50
#ifndef BLTOUCH_DELAY
#define BLTOUCH_DELAY 375
#endif
#undef Z_SERVO_ANGLES #undef Z_SERVO_ANGLES
#define Z_SERVO_ANGLES { BLTOUCH_DEPLOY, BLTOUCH_STOW } #define Z_SERVO_ANGLES { BLTOUCH_DEPLOY, BLTOUCH_STOW }
@@ -368,14 +374,18 @@
/** /**
* Set a flag for any enabled probe * Set a flag for any enabled probe
*/ */
#define PROBE_SELECTED (ENABLED(FIX_MOUNTED_PROBE) || ENABLED(Z_PROBE_ALLEN_KEY) || HAS_Z_SERVO_ENDSTOP || ENABLED(Z_PROBE_SLED)) #define PROBE_SELECTED (ENABLED(PROBE_MANUALLY) || ENABLED(FIX_MOUNTED_PROBE) || ENABLED(Z_PROBE_ALLEN_KEY) || HAS_Z_SERVO_ENDSTOP || ENABLED(Z_PROBE_SLED) || ENABLED(SOLENOID_PROBE))
/** /**
* Clear probe pin settings when no probe is selected * Clear probe pin settings when no probe is selected
*/ */
#if !PROBE_SELECTED #if !PROBE_SELECTED || ENABLED(PROBE_MANUALLY)
#undef Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN #undef Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN
#undef Z_MIN_PROBE_ENDSTOP #undef Z_MIN_PROBE_ENDSTOP
#endif #endif
#define HAS_SOFTWARE_ENDSTOPS (ENABLED(MIN_SOFTWARE_ENDSTOPS) || ENABLED(MAX_SOFTWARE_ENDSTOPS))
#define HAS_RESUME_CONTINUE (ENABLED(NEWPANEL) || ENABLED(EMERGENCY_PARSER))
#define HAS_COLOR_LEDS (ENABLED(BLINKM) || ENABLED(RGB_LED) || ENABLED(RGBW_LED))
#endif //CONDITIONALS_LCD_H #endif //CONDITIONALS_LCD_H

View File

@@ -119,6 +119,13 @@
#define Z_HOME_POS (Z_HOME_DIR < 0 ? Z_MIN_POS : Z_MAX_POS) #define Z_HOME_POS (Z_HOME_DIR < 0 ? Z_MIN_POS : Z_MAX_POS)
#endif #endif
/**
* If DELTA_HEIGHT isn't defined use the old setting
*/
#if ENABLED(DELTA) && !defined(DELTA_HEIGHT)
#define DELTA_HEIGHT Z_HOME_POS
#endif
/** /**
* Auto Bed Leveling and Z Probe Repeatability Test * Auto Bed Leveling and Z Probe Repeatability Test
*/ */
@@ -184,7 +191,7 @@
*/ */
#if ENABLED(ADVANCE) #if ENABLED(ADVANCE)
#define EXTRUSION_AREA (0.25 * (D_FILAMENT) * (D_FILAMENT) * M_PI) #define EXTRUSION_AREA (0.25 * (D_FILAMENT) * (D_FILAMENT) * M_PI)
#define STEPS_PER_CUBIC_MM_E (axis_steps_per_mm[E_AXIS] / (EXTRUSION_AREA)) #define STEPS_PER_CUBIC_MM_E (axis_steps_per_mm[E_AXIS_N] / (EXTRUSION_AREA))
#endif #endif
#if ENABLED(ULTIPANEL) && DISABLED(ELB_FULL_GRAPHIC_CONTROLLER) #if ENABLED(ULTIPANEL) && DISABLED(ELB_FULL_GRAPHIC_CONTROLLER)
@@ -279,6 +286,18 @@
#define HEATER_3_USES_THERMISTOR #define HEATER_3_USES_THERMISTOR
#endif #endif
#if TEMP_SENSOR_4 <= -2
#error "MAX6675 / MAX31855 Thermocouples not supported for TEMP_SENSOR_4"
#elif TEMP_SENSOR_4 == -1
#define HEATER_4_USES_AD595
#elif TEMP_SENSOR_4 == 0
#undef HEATER_4_MINTEMP
#undef HEATER_4_MAXTEMP
#elif TEMP_SENSOR_4 > 0
#define THERMISTORHEATER_4 TEMP_SENSOR_4
#define HEATER_4_USES_THERMISTOR
#endif
#if TEMP_SENSOR_BED <= -2 #if TEMP_SENSOR_BED <= -2
#error "MAX6675 / MAX31855 Thermocouples not supported for TEMP_SENSOR_BED" #error "MAX6675 / MAX31855 Thermocouples not supported for TEMP_SENSOR_BED"
#elif TEMP_SENSOR_BED == -1 #elif TEMP_SENSOR_BED == -1
@@ -394,7 +413,10 @@
#endif #endif
#endif #endif
#define IS_Z2_OR_PROBE(P) (P == Z2_MIN_PIN || P == Z2_MAX_PIN || P == Z_MIN_PROBE_PIN) // Is an endstop plug used for the Z2 endstop or the bed probe?
#define IS_Z2_OR_PROBE(A,M) ( \
(ENABLED(Z_DUAL_ENDSTOPS) && Z2_USE_ENDSTOP == _##A##M##_) \
|| (ENABLED(Z_MIN_PROBE_ENDSTOP) && Z_MIN_PROBE_PIN == A##_##M##_PIN ) )
/** /**
* Set ENDSTOPPULLUPS for active endstop switches * Set ENDSTOPPULLUPS for active endstop switches
@@ -423,20 +445,105 @@
/** /**
* Shorthand for pin tests, used wherever needed * Shorthand for pin tests, used wherever needed
*/ */
// Steppers
#define HAS_X_ENABLE (PIN_EXISTS(X_ENABLE))
#define HAS_X_DIR (PIN_EXISTS(X_DIR))
#define HAS_X_STEP (PIN_EXISTS(X_STEP))
#define HAS_X_MICROSTEPS (PIN_EXISTS(X_MS1))
#define HAS_X2_ENABLE (PIN_EXISTS(X2_ENABLE))
#define HAS_X2_DIR (PIN_EXISTS(X2_DIR))
#define HAS_X2_STEP (PIN_EXISTS(X2_STEP))
#define HAS_Y_MICROSTEPS (PIN_EXISTS(Y_MS1))
#define HAS_Y_ENABLE (PIN_EXISTS(Y_ENABLE))
#define HAS_Y_DIR (PIN_EXISTS(Y_DIR))
#define HAS_Y_STEP (PIN_EXISTS(Y_STEP))
#define HAS_Z_MICROSTEPS (PIN_EXISTS(Z_MS1))
#define HAS_Y2_ENABLE (PIN_EXISTS(Y2_ENABLE))
#define HAS_Y2_DIR (PIN_EXISTS(Y2_DIR))
#define HAS_Y2_STEP (PIN_EXISTS(Y2_STEP))
#define HAS_Z_ENABLE (PIN_EXISTS(Z_ENABLE))
#define HAS_Z_DIR (PIN_EXISTS(Z_DIR))
#define HAS_Z_STEP (PIN_EXISTS(Z_STEP))
#define HAS_Z2_ENABLE (PIN_EXISTS(Z2_ENABLE))
#define HAS_Z2_DIR (PIN_EXISTS(Z2_DIR))
#define HAS_Z2_STEP (PIN_EXISTS(Z2_STEP))
// Extruder steppers and solenoids
#define HAS_E0_ENABLE (PIN_EXISTS(E0_ENABLE))
#define HAS_E0_DIR (PIN_EXISTS(E0_DIR))
#define HAS_E0_STEP (PIN_EXISTS(E0_STEP))
#define HAS_E0_MICROSTEPS (PIN_EXISTS(E0_MS1))
#define HAS_SOLENOID_0 (PIN_EXISTS(SOL0))
#define HAS_E1_ENABLE (PIN_EXISTS(E1_ENABLE))
#define HAS_E1_DIR (PIN_EXISTS(E1_DIR))
#define HAS_E1_STEP (PIN_EXISTS(E1_STEP))
#define HAS_E1_MICROSTEPS (PIN_EXISTS(E1_MS1))
#define HAS_SOLENOID_1 (PIN_EXISTS(SOL1))
#define HAS_E2_ENABLE (PIN_EXISTS(E2_ENABLE))
#define HAS_E2_DIR (PIN_EXISTS(E2_DIR))
#define HAS_E2_STEP (PIN_EXISTS(E2_STEP))
#define HAS_E2_MICROSTEPS (PIN_EXISTS(E2_MS1))
#define HAS_SOLENOID_2 (PIN_EXISTS(SOL2))
#define HAS_E3_ENABLE (PIN_EXISTS(E3_ENABLE))
#define HAS_E3_DIR (PIN_EXISTS(E3_DIR))
#define HAS_E3_STEP (PIN_EXISTS(E3_STEP))
#define HAS_E3_MICROSTEPS (PIN_EXISTS(E3_MS1))
#define HAS_SOLENOID_3 (PIN_EXISTS(SOL3))
#define HAS_E4_ENABLE (PIN_EXISTS(E4_ENABLE))
#define HAS_E4_DIR (PIN_EXISTS(E4_DIR))
#define HAS_E4_STEP (PIN_EXISTS(E4_STEP))
#define HAS_E4_MICROSTEPS (PIN_EXISTS(E4_MS1))
#define HAS_SOLENOID_4 (PIN_EXISTS(SOL4))
// Endstops and bed probe
#define HAS_X_MIN (PIN_EXISTS(X_MIN) && !IS_Z2_OR_PROBE(X,MIN))
#define HAS_X_MAX (PIN_EXISTS(X_MAX) && !IS_Z2_OR_PROBE(X,MAX))
#define HAS_Y_MIN (PIN_EXISTS(Y_MIN) && !IS_Z2_OR_PROBE(Y,MIN))
#define HAS_Y_MAX (PIN_EXISTS(Y_MAX) && !IS_Z2_OR_PROBE(Y,MAX))
#define HAS_Z_MIN (PIN_EXISTS(Z_MIN) && !IS_Z2_OR_PROBE(Z,MIN))
#define HAS_Z_MAX (PIN_EXISTS(Z_MAX) && !IS_Z2_OR_PROBE(Z,MAX))
#define HAS_Z2_MIN (PIN_EXISTS(Z2_MIN))
#define HAS_Z2_MAX (PIN_EXISTS(Z2_MAX))
#define HAS_Z_MIN_PROBE_PIN (PIN_EXISTS(Z_MIN_PROBE))
// Thermistors
#define HAS_TEMP_0 (PIN_EXISTS(TEMP_0) && TEMP_SENSOR_0 != 0 && TEMP_SENSOR_0 > -2) #define HAS_TEMP_0 (PIN_EXISTS(TEMP_0) && TEMP_SENSOR_0 != 0 && TEMP_SENSOR_0 > -2)
#define HAS_TEMP_1 (PIN_EXISTS(TEMP_1) && TEMP_SENSOR_1 != 0 && TEMP_SENSOR_1 > -2) #define HAS_TEMP_1 (PIN_EXISTS(TEMP_1) && TEMP_SENSOR_1 != 0 && TEMP_SENSOR_1 > -2)
#define HAS_TEMP_2 (PIN_EXISTS(TEMP_2) && TEMP_SENSOR_2 != 0 && TEMP_SENSOR_2 > -2) #define HAS_TEMP_2 (PIN_EXISTS(TEMP_2) && TEMP_SENSOR_2 != 0 && TEMP_SENSOR_2 > -2)
#define HAS_TEMP_3 (PIN_EXISTS(TEMP_3) && TEMP_SENSOR_3 != 0 && TEMP_SENSOR_3 > -2) #define HAS_TEMP_3 (PIN_EXISTS(TEMP_3) && TEMP_SENSOR_3 != 0 && TEMP_SENSOR_3 > -2)
#define HAS_TEMP_4 (PIN_EXISTS(TEMP_4) && TEMP_SENSOR_4 != 0 && TEMP_SENSOR_4 > -2)
#define HAS_TEMP_HOTEND (HAS_TEMP_0 || ENABLED(HEATER_0_USES_MAX6675))
#define HAS_TEMP_BED (PIN_EXISTS(TEMP_BED) && TEMP_SENSOR_BED != 0 && TEMP_SENSOR_BED > -2) #define HAS_TEMP_BED (PIN_EXISTS(TEMP_BED) && TEMP_SENSOR_BED != 0 && TEMP_SENSOR_BED > -2)
// Heaters
#define HAS_HEATER_0 (PIN_EXISTS(HEATER_0)) #define HAS_HEATER_0 (PIN_EXISTS(HEATER_0))
#define HAS_HEATER_1 (PIN_EXISTS(HEATER_1)) #define HAS_HEATER_1 (PIN_EXISTS(HEATER_1))
#define HAS_HEATER_2 (PIN_EXISTS(HEATER_2)) #define HAS_HEATER_2 (PIN_EXISTS(HEATER_2))
#define HAS_HEATER_3 (PIN_EXISTS(HEATER_3)) #define HAS_HEATER_3 (PIN_EXISTS(HEATER_3))
#define HAS_HEATER_4 (PIN_EXISTS(HEATER_4))
#define HAS_HEATER_BED (PIN_EXISTS(HEATER_BED)) #define HAS_HEATER_BED (PIN_EXISTS(HEATER_BED))
// Thermal protection
#define HAS_THERMALLY_PROTECTED_BED (ENABLED(THERMAL_PROTECTION_BED) && HAS_TEMP_BED && HAS_HEATER_BED)
#define WATCH_HOTENDS (ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0)
#define WATCH_THE_BED (HAS_THERMALLY_PROTECTED_BED && WATCH_BED_TEMP_PERIOD > 0)
// Auto fans
#define HAS_AUTO_FAN_0 (PIN_EXISTS(E0_AUTO_FAN)) #define HAS_AUTO_FAN_0 (PIN_EXISTS(E0_AUTO_FAN))
#define HAS_AUTO_FAN_1 (HOTENDS > 1 && PIN_EXISTS(E1_AUTO_FAN)) #define HAS_AUTO_FAN_1 (HOTENDS > 1 && PIN_EXISTS(E1_AUTO_FAN))
#define HAS_AUTO_FAN_2 (HOTENDS > 2 && PIN_EXISTS(E2_AUTO_FAN)) #define HAS_AUTO_FAN_2 (HOTENDS > 2 && PIN_EXISTS(E2_AUTO_FAN))
#define HAS_AUTO_FAN_3 (HOTENDS > 3 && PIN_EXISTS(E3_AUTO_FAN)) #define HAS_AUTO_FAN_3 (HOTENDS > 3 && PIN_EXISTS(E3_AUTO_FAN))
#define HAS_AUTO_FAN_4 (HOTENDS > 4 && PIN_EXISTS(E4_AUTO_FAN))
#define HAS_AUTO_FAN (HAS_AUTO_FAN_0 || HAS_AUTO_FAN_1 || HAS_AUTO_FAN_2 || HAS_AUTO_FAN_3) #define HAS_AUTO_FAN (HAS_AUTO_FAN_0 || HAS_AUTO_FAN_1 || HAS_AUTO_FAN_2 || HAS_AUTO_FAN_3)
#define AUTO_1_IS_0 (E1_AUTO_FAN_PIN == E0_AUTO_FAN_PIN) #define AUTO_1_IS_0 (E1_AUTO_FAN_PIN == E0_AUTO_FAN_PIN)
#define AUTO_2_IS_0 (E2_AUTO_FAN_PIN == E0_AUTO_FAN_PIN) #define AUTO_2_IS_0 (E2_AUTO_FAN_PIN == E0_AUTO_FAN_PIN)
@@ -444,84 +551,42 @@
#define AUTO_3_IS_0 (E3_AUTO_FAN_PIN == E0_AUTO_FAN_PIN) #define AUTO_3_IS_0 (E3_AUTO_FAN_PIN == E0_AUTO_FAN_PIN)
#define AUTO_3_IS_1 (E3_AUTO_FAN_PIN == E1_AUTO_FAN_PIN) #define AUTO_3_IS_1 (E3_AUTO_FAN_PIN == E1_AUTO_FAN_PIN)
#define AUTO_3_IS_2 (E3_AUTO_FAN_PIN == E2_AUTO_FAN_PIN) #define AUTO_3_IS_2 (E3_AUTO_FAN_PIN == E2_AUTO_FAN_PIN)
#define AUTO_4_IS_0 (E4_AUTO_FAN_PIN == E0_AUTO_FAN_PIN)
#define AUTO_4_IS_1 (E4_AUTO_FAN_PIN == E1_AUTO_FAN_PIN)
#define AUTO_4_IS_2 (E4_AUTO_FAN_PIN == E2_AUTO_FAN_PIN)
#define AUTO_4_IS_3 (E4_AUTO_FAN_PIN == E3_AUTO_FAN_PIN)
// Other fans
#define HAS_FAN0 (PIN_EXISTS(FAN)) #define HAS_FAN0 (PIN_EXISTS(FAN))
#define HAS_FAN1 (PIN_EXISTS(FAN1) && CONTROLLERFAN_PIN != FAN1_PIN && E0_AUTO_FAN_PIN != FAN1_PIN && E1_AUTO_FAN_PIN != FAN1_PIN && E2_AUTO_FAN_PIN != FAN1_PIN && E3_AUTO_FAN_PIN != FAN1_PIN) #define HAS_FAN1 (PIN_EXISTS(FAN1) && CONTROLLER_FAN_PIN != FAN1_PIN && E0_AUTO_FAN_PIN != FAN1_PIN && E1_AUTO_FAN_PIN != FAN1_PIN && E2_AUTO_FAN_PIN != FAN1_PIN && E3_AUTO_FAN_PIN != FAN1_PIN)
#define HAS_FAN2 (PIN_EXISTS(FAN2) && CONTROLLERFAN_PIN != FAN2_PIN && E0_AUTO_FAN_PIN != FAN2_PIN && E1_AUTO_FAN_PIN != FAN2_PIN && E2_AUTO_FAN_PIN != FAN2_PIN && E3_AUTO_FAN_PIN != FAN2_PIN) #define HAS_FAN2 (PIN_EXISTS(FAN2) && CONTROLLER_FAN_PIN != FAN2_PIN && E0_AUTO_FAN_PIN != FAN2_PIN && E1_AUTO_FAN_PIN != FAN2_PIN && E2_AUTO_FAN_PIN != FAN2_PIN && E3_AUTO_FAN_PIN != FAN2_PIN)
#define HAS_CONTROLLERFAN (PIN_EXISTS(CONTROLLERFAN)) #define HAS_CONTROLLER_FAN (PIN_EXISTS(CONTROLLER_FAN))
// Servos
#define HAS_SERVOS (defined(NUM_SERVOS) && NUM_SERVOS > 0) #define HAS_SERVOS (defined(NUM_SERVOS) && NUM_SERVOS > 0)
#define HAS_SERVO_0 (PIN_EXISTS(SERVO0)) #define HAS_SERVO_0 (PIN_EXISTS(SERVO0))
#define HAS_SERVO_1 (PIN_EXISTS(SERVO1)) #define HAS_SERVO_1 (PIN_EXISTS(SERVO1))
#define HAS_SERVO_2 (PIN_EXISTS(SERVO2)) #define HAS_SERVO_2 (PIN_EXISTS(SERVO2))
#define HAS_SERVO_3 (PIN_EXISTS(SERVO3)) #define HAS_SERVO_3 (PIN_EXISTS(SERVO3))
// Sensors
#define HAS_FILAMENT_WIDTH_SENSOR (PIN_EXISTS(FILWIDTH)) #define HAS_FILAMENT_WIDTH_SENSOR (PIN_EXISTS(FILWIDTH))
#define HAS_FIL_RUNOUT (PIN_EXISTS(FIL_RUNOUT)) #define HAS_FIL_RUNOUT (PIN_EXISTS(FIL_RUNOUT))
// User Interface
#define HAS_HOME (PIN_EXISTS(HOME)) #define HAS_HOME (PIN_EXISTS(HOME))
#define HAS_KILL (PIN_EXISTS(KILL)) #define HAS_KILL (PIN_EXISTS(KILL))
#define HAS_SUICIDE (PIN_EXISTS(SUICIDE)) #define HAS_SUICIDE (PIN_EXISTS(SUICIDE))
#define HAS_PHOTOGRAPH (PIN_EXISTS(PHOTOGRAPH)) #define HAS_PHOTOGRAPH (PIN_EXISTS(PHOTOGRAPH))
#define HAS_X_MIN (PIN_EXISTS(X_MIN) && !IS_Z2_OR_PROBE(X_MIN_PIN))
#define HAS_X_MAX (PIN_EXISTS(X_MAX) && !IS_Z2_OR_PROBE(X_MAX_PIN))
#define HAS_Y_MIN (PIN_EXISTS(Y_MIN) && !IS_Z2_OR_PROBE(Y_MIN_PIN))
#define HAS_Y_MAX (PIN_EXISTS(Y_MAX) && !IS_Z2_OR_PROBE(Y_MAX_PIN))
#define HAS_Z_MIN (PIN_EXISTS(Z_MIN) && !IS_Z2_OR_PROBE(Z_MIN_PIN))
#define HAS_Z_MAX (PIN_EXISTS(Z_MAX) && !IS_Z2_OR_PROBE(Z_MAX_PIN))
#define HAS_Z2_MIN (PIN_EXISTS(Z2_MIN))
#define HAS_Z2_MAX (PIN_EXISTS(Z2_MAX))
#define HAS_Z_MIN_PROBE_PIN (PIN_EXISTS(Z_MIN_PROBE))
#define HAS_SOLENOID_1 (PIN_EXISTS(SOL1))
#define HAS_SOLENOID_2 (PIN_EXISTS(SOL2))
#define HAS_SOLENOID_3 (PIN_EXISTS(SOL3))
#define HAS_MICROSTEPS_X (PIN_EXISTS(X_MS1))
#define HAS_MICROSTEPS_Y (PIN_EXISTS(Y_MS1))
#define HAS_MICROSTEPS_Z (PIN_EXISTS(Z_MS1))
#define HAS_MICROSTEPS_E0 (PIN_EXISTS(E0_MS1))
#define HAS_MICROSTEPS_E1 (PIN_EXISTS(E1_MS1))
#define HAS_MICROSTEPS_E2 (PIN_EXISTS(E2_MS1))
#define HAS_MICROSTEPS (HAS_MICROSTEPS_X || HAS_MICROSTEPS_Y || HAS_MICROSTEPS_Z || HAS_MICROSTEPS_E0 || HAS_MICROSTEPS_E1 || HAS_MICROSTEPS_E2)
#define HAS_STEPPER_RESET (PIN_EXISTS(STEPPER_RESET))
#define HAS_X_ENABLE (PIN_EXISTS(X_ENABLE))
#define HAS_X2_ENABLE (PIN_EXISTS(X2_ENABLE))
#define HAS_Y_ENABLE (PIN_EXISTS(Y_ENABLE))
#define HAS_Y2_ENABLE (PIN_EXISTS(Y2_ENABLE))
#define HAS_Z_ENABLE (PIN_EXISTS(Z_ENABLE))
#define HAS_Z2_ENABLE (PIN_EXISTS(Z2_ENABLE))
#define HAS_E0_ENABLE (PIN_EXISTS(E0_ENABLE))
#define HAS_E1_ENABLE (PIN_EXISTS(E1_ENABLE))
#define HAS_E2_ENABLE (PIN_EXISTS(E2_ENABLE))
#define HAS_E3_ENABLE (PIN_EXISTS(E3_ENABLE))
#define HAS_E4_ENABLE (PIN_EXISTS(E4_ENABLE))
#define HAS_X_DIR (PIN_EXISTS(X_DIR))
#define HAS_X2_DIR (PIN_EXISTS(X2_DIR))
#define HAS_Y_DIR (PIN_EXISTS(Y_DIR))
#define HAS_Y2_DIR (PIN_EXISTS(Y2_DIR))
#define HAS_Z_DIR (PIN_EXISTS(Z_DIR))
#define HAS_Z2_DIR (PIN_EXISTS(Z2_DIR))
#define HAS_E0_DIR (PIN_EXISTS(E0_DIR))
#define HAS_E1_DIR (PIN_EXISTS(E1_DIR))
#define HAS_E2_DIR (PIN_EXISTS(E2_DIR))
#define HAS_E3_DIR (PIN_EXISTS(E3_DIR))
#define HAS_E4_DIR (PIN_EXISTS(E4_DIR))
#define HAS_X_STEP (PIN_EXISTS(X_STEP))
#define HAS_X2_STEP (PIN_EXISTS(X2_STEP))
#define HAS_Y_STEP (PIN_EXISTS(Y_STEP))
#define HAS_Y2_STEP (PIN_EXISTS(Y2_STEP))
#define HAS_Z_STEP (PIN_EXISTS(Z_STEP))
#define HAS_Z2_STEP (PIN_EXISTS(Z2_STEP))
#define HAS_E0_STEP (PIN_EXISTS(E0_STEP))
#define HAS_E1_STEP (PIN_EXISTS(E1_STEP))
#define HAS_E2_STEP (PIN_EXISTS(E2_STEP))
#define HAS_E3_STEP (PIN_EXISTS(E3_STEP))
#define HAS_E4_STEP (PIN_EXISTS(E4_STEP))
#define HAS_DIGIPOTSS (PIN_EXISTS(DIGIPOTSS))
#define HAS_BUZZER (PIN_EXISTS(BEEPER) || ENABLED(LCD_USE_I2C_BUZZER)) #define HAS_BUZZER (PIN_EXISTS(BEEPER) || ENABLED(LCD_USE_I2C_BUZZER))
#define HAS_CASE_LIGHT (PIN_EXISTS(CASE_LIGHT)) #define HAS_CASE_LIGHT (PIN_EXISTS(CASE_LIGHT))
// Digital control
#define HAS_MICROSTEPS (HAS_X_MICROSTEPS || HAS_Y_MICROSTEPS || HAS_Z_MICROSTEPS || HAS_E0_MICROSTEPS || HAS_E1_MICROSTEPS || HAS_E2_MICROSTEPS || HAS_E3_MICROSTEPS || HAS_E4_MICROSTEPS)
#define HAS_STEPPER_RESET (PIN_EXISTS(STEPPER_RESET))
#define HAS_DIGIPOTSS (PIN_EXISTS(DIGIPOTSS))
#define HAS_MOTOR_CURRENT_PWM (PIN_EXISTS(MOTOR_CURRENT_PWM_XY) || PIN_EXISTS(MOTOR_CURRENT_PWM_Z) || PIN_EXISTS(MOTOR_CURRENT_PWM_E)) #define HAS_MOTOR_CURRENT_PWM (PIN_EXISTS(MOTOR_CURRENT_PWM_XY) || PIN_EXISTS(MOTOR_CURRENT_PWM_Z) || PIN_EXISTS(MOTOR_CURRENT_PWM_E))
#define HAS_TEMP_HOTEND (HAS_TEMP_0 || ENABLED(HEATER_0_USES_MAX6675))
#define HAS_THERMALLY_PROTECTED_BED (HAS_TEMP_BED && HAS_HEATER_BED && ENABLED(THERMAL_PROTECTION_BED))
/** /**
* This setting is also used by M109 when trying to calculate * This setting is also used by M109 when trying to calculate
* a ballpark safe margin to prevent wait-forever situation. * a ballpark safe margin to prevent wait-forever situation.
@@ -540,9 +605,12 @@
#define WRITE_HEATER_2(v) WRITE(HEATER_2_PIN, v) #define WRITE_HEATER_2(v) WRITE(HEATER_2_PIN, v)
#if HOTENDS > 3 #if HOTENDS > 3
#define WRITE_HEATER_3(v) WRITE(HEATER_3_PIN, v) #define WRITE_HEATER_3(v) WRITE(HEATER_3_PIN, v)
#endif #if HOTENDS > 4
#endif #define WRITE_HEATER_4(v) WRITE(HEATER_4_PIN, v)
#endif #endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
#endif // HOTENDS > 1
#if ENABLED(HEATERS_PARALLEL) #if ENABLED(HEATERS_PARALLEL)
#define WRITE_HEATER_0(v) { WRITE_HEATER_0P(v); WRITE_HEATER_1(v); } #define WRITE_HEATER_0(v) { WRITE_HEATER_0P(v); WRITE_HEATER_1(v); }
#else #else
@@ -577,6 +645,15 @@
#endif #endif
#define WRITE_FAN_N(n, v) WRITE_FAN##n(v) #define WRITE_FAN_N(n, v) WRITE_FAN##n(v)
/**
* Heater & Fan Pausing
*/
#if ENABLED(PROBING_FANS_OFF) && FAN_COUNT == 0
#undef PROBING_FANS_OFF
#endif
#define QUIET_PROBING (ENABLED(PROBING_HEATERS_OFF) || ENABLED(PROBING_FANS_OFF))
/** /**
* Servos and probes * Servos and probes
*/ */
@@ -589,7 +666,7 @@
#define PROBE_PIN_CONFIGURED (HAS_Z_MIN_PROBE_PIN || (HAS_Z_MIN && ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN))) #define PROBE_PIN_CONFIGURED (HAS_Z_MIN_PROBE_PIN || (HAS_Z_MIN && ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN)))
#define HAS_BED_PROBE (PROBE_SELECTED && PROBE_PIN_CONFIGURED) #define HAS_BED_PROBE (PROBE_SELECTED && PROBE_PIN_CONFIGURED && DISABLED(PROBE_MANUALLY))
#if ENABLED(Z_PROBE_ALLEN_KEY) #if ENABLED(Z_PROBE_ALLEN_KEY)
#define PROBE_IS_TRIGGERED_WHEN_STOWED_TEST #define PROBE_IS_TRIGGERED_WHEN_STOWED_TEST
@@ -630,39 +707,35 @@
#endif #endif
/** /**
* Delta radius/rod trimmers * Delta radius/rod trimmers/angle trimmers
*/ */
#if ENABLED(DELTA) #if ENABLED(DELTA)
#ifndef DELTA_RADIUS_TRIM_TOWER_1 #ifndef DELTA_CALIBRATION_RADIUS
#define DELTA_RADIUS_TRIM_TOWER_1 0.0 #define DELTA_CALIBRATION_RADIUS DELTA_PRINTABLE_RADIUS - 10
#endif #endif
#ifndef DELTA_RADIUS_TRIM_TOWER_2 #ifndef DELTA_ENDSTOP_ADJ
#define DELTA_RADIUS_TRIM_TOWER_2 0.0 #define DELTA_ENDSTOP_ADJ { 0, 0, 0 }
#endif #endif
#ifndef DELTA_RADIUS_TRIM_TOWER_3 #ifndef DELTA_TOWER_ANGLE_TRIM
#define DELTA_RADIUS_TRIM_TOWER_3 0.0 #define DELTA_TOWER_ANGLE_TRIM {0, 0, 0}
#endif #endif
#ifndef DELTA_DIAGONAL_ROD_TRIM_TOWER_1 #ifndef DELTA_RADIUS_TRIM_TOWER
#define DELTA_DIAGONAL_ROD_TRIM_TOWER_1 0.0 #define DELTA_RADIUS_TRIM_TOWER {0, 0, 0}
#endif #endif
#ifndef DELTA_DIAGONAL_ROD_TRIM_TOWER_2 #ifndef DELTA_DIAGONAL_ROD_TRIM_TOWER
#define DELTA_DIAGONAL_ROD_TRIM_TOWER_2 0.0 #define DELTA_DIAGONAL_ROD_TRIM_TOWER {0, 0, 0}
#endif
#ifndef DELTA_DIAGONAL_ROD_TRIM_TOWER_3
#define DELTA_DIAGONAL_ROD_TRIM_TOWER_3 0.0
#endif #endif
#endif #endif
/** /**
* Set ABL options based on the specific type of leveling * Set granular options based on the specific type of leveling
*/ */
#define ABL_PLANAR (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT)) #define ABL_PLANAR (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_3POINT))
#define ABL_GRID (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR)) #define ABL_GRID (ENABLED(AUTO_BED_LEVELING_LINEAR) || ENABLED(AUTO_BED_LEVELING_BILINEAR))
#define HAS_ABL (ABL_PLANAR || ABL_GRID) #define HAS_ABL (ABL_PLANAR || ABL_GRID || ENABLED(AUTO_BED_LEVELING_UBL))
#define HAS_LEVELING (HAS_ABL || ENABLED(MESH_BED_LEVELING))
#define PLANNER_LEVELING (HAS_ABL || ENABLED(MESH_BED_LEVELING)) #define PLANNER_LEVELING (ABL_PLANAR || ABL_GRID || ENABLED(MESH_BED_LEVELING))
#define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)) #define HAS_PROBING_PROCEDURE (HAS_ABL || ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST))
#if HAS_PROBING_PROCEDURE #if HAS_PROBING_PROCEDURE
#define PROBE_BED_WIDTH abs(RIGHT_PROBE_BED_POSITION - (LEFT_PROBE_BED_POSITION)) #define PROBE_BED_WIDTH abs(RIGHT_PROBE_BED_POSITION - (LEFT_PROBE_BED_POSITION))
#define PROBE_BED_HEIGHT abs(BACK_PROBE_BED_POSITION - (FRONT_PROBE_BED_POSITION)) #define PROBE_BED_HEIGHT abs(BACK_PROBE_BED_POSITION - (FRONT_PROBE_BED_POSITION))
@@ -700,6 +773,11 @@
#ifndef Z_CLEARANCE_BETWEEN_PROBES #ifndef Z_CLEARANCE_BETWEEN_PROBES
#define Z_CLEARANCE_BETWEEN_PROBES Z_HOMING_HEIGHT #define Z_CLEARANCE_BETWEEN_PROBES Z_HOMING_HEIGHT
#endif #endif
#if Z_CLEARANCE_BETWEEN_PROBES > Z_HOMING_HEIGHT
#define MANUAL_PROBE_HEIGHT Z_CLEARANCE_BETWEEN_PROBES
#else
#define MANUAL_PROBE_HEIGHT Z_HOMING_HEIGHT
#endif
#if IS_KINEMATIC #if IS_KINEMATIC
// Check for this in the code instead // Check for this in the code instead
@@ -718,8 +796,22 @@
// Stepper pulse duration, in cycles // Stepper pulse duration, in cycles
#define STEP_PULSE_CYCLES ((MINIMUM_STEPPER_PULSE) * CYCLES_PER_MICROSECOND) #define STEP_PULSE_CYCLES ((MINIMUM_STEPPER_PULSE) * CYCLES_PER_MICROSECOND)
#ifndef DELTA_ENDSTOP_ADJ #if ENABLED(SDCARD_SORT_ALPHA)
#define DELTA_ENDSTOP_ADJ { 0 } #define HAS_FOLDER_SORTING (FOLDER_SORTING || ENABLED(SDSORT_GCODE))
#endif
// Updated G92 behavior shifts the workspace
#define HAS_POSITION_SHIFT DISABLED(NO_WORKSPACE_OFFSETS)
// The home offset also shifts the coordinate space
#define HAS_HOME_OFFSET (DISABLED(NO_WORKSPACE_OFFSETS) || ENABLED(DELTA))
// Either offset yields extra calculations on all moves
#define HAS_WORKSPACE_OFFSET (HAS_POSITION_SHIFT || HAS_HOME_OFFSET)
// M206 doesn't apply to DELTA
#define HAS_M206_COMMAND (HAS_HOME_OFFSET && DISABLED(DELTA))
// LCD timeout to status screen default is 15s
#ifndef LCD_TIMEOUT_TO_STATUS
#define LCD_TIMEOUT_TO_STATUS 15000
#endif #endif
#endif // CONDITIONALS_POST_H #endif // CONDITIONALS_POST_H

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine/test this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -425,6 +443,9 @@
// On the Info Screen, display XY with one decimal place when possible // On the Info Screen, display XY with one decimal place when possible
//#define LCD_DECIMAL_SMALL_XY //#define LCD_DECIMAL_SMALL_XY
// The timeout (in ms) to return to the status screen from sub-menus
//#define LCD_TIMEOUT_TO_STATUS 15000
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
// Some RAMPS and other boards don't detect when an SD card is inserted. You can work // Some RAMPS and other boards don't detect when an SD card is inserted. You can work
@@ -442,6 +463,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +511,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +525,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +572,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +611,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +656,15 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.
#define UBL_SAVE_ACTIVE_ON_M500
#endif #endif
// @section extras // @section extras
@@ -596,6 +678,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +760,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +820,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +862,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +895,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1040,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1092,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1133,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1147,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

View File

@@ -0,0 +1,881 @@
/**
* 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/>.
*
*/
/**
* Marlin Firmware -- G26 - Mesh Validation Tool
*/
#include "MarlinConfig.h"
#if ENABLED(AUTO_BED_LEVELING_UBL) && ENABLED(UBL_G26_MESH_EDITING)
#include "ubl.h"
#include "Marlin.h"
#include "planner.h"
#include "stepper.h"
#include "temperature.h"
#include "ultralcd.h"
#define EXTRUSION_MULTIPLIER 1.0
#define RETRACTION_MULTIPLIER 1.0
#define NOZZLE 0.4
#define FILAMENT 1.75
#define LAYER_HEIGHT 0.2
#define PRIME_LENGTH 10.0
#define BED_TEMP 60.0
#define HOTEND_TEMP 205.0
#define OOZE_AMOUNT 0.3
#define SIZE_OF_INTERSECTION_CIRCLES 5
#define SIZE_OF_CROSSHAIRS 3
#if SIZE_OF_CROSSHAIRS >= SIZE_OF_INTERSECTION_CIRCLES
#error "SIZE_OF_CROSSHAIRS must be less than SIZE_OF_INTERSECTION_CIRCLES."
#endif
/**
* G26 Mesh Validation Tool
*
* G26 is a Mesh Validation Tool intended to provide support for the Marlin Unified Bed Leveling System.
* In order to fully utilize and benefit from the Marlin Unified Bed Leveling System an accurate Mesh must
* be defined. G29 is designed to allow the user to quickly validate the correctness of her Mesh. It will
* first heat the bed and nozzle. It will then print lines and circles along the Mesh Cell boundaries and
* the intersections of those lines (respectively).
*
* This action allows the user to immediately see where the Mesh is properly defined and where it needs to
* be edited. The command will generate the Mesh lines closest to the nozzle's starting position. Alternatively
* the user can specify the X and Y position of interest with command parameters. This allows the user to
* focus on a particular area of the Mesh where attention is needed.
*
* B # Bed Set the Bed Temperature. If not specified, a default of 60 C. will be assumed.
*
* C Current When searching for Mesh Intersection points to draw, use the current nozzle location
* as the base for any distance comparison.
*
* D Disable Disable the Unified Bed Leveling System. In the normal case the user is invoking this
* command to see how well a Mesh as been adjusted to match a print surface. In order to do
* this the Unified Bed Leveling System is turned on by the G26 command. The D parameter
* alters the command's normal behaviour and disables the Unified Bed Leveling System even if
* it is on.
*
* H # Hotend Set the Nozzle Temperature. If not specified, a default of 205 C. will be assumed.
*
* F # Filament Used to specify the diameter of the filament being used. If not specified
* 1.75mm filament is assumed. If you are not getting acceptable results by using the
* 'correct' numbers, you can scale this number up or down a little bit to change the amount
* of filament that is being extruded during the printing of the various lines on the bed.
*
* K Keep-On Keep the heaters turned on at the end of the command.
*
* L # Layer Layer height. (Height of nozzle above bed) If not specified .20mm will be used.
*
* Q # Multiplier Retraction Multiplier. Normally not needed. Retraction defaults to 1.0mm and
* un-retraction is at 1.2mm These numbers will be scaled by the specified amount
*
* N # Nozzle Used to control the size of nozzle diameter. If not specified, a .4mm nozzle is assumed.
* 'n' can be used instead if your host program does not appreciate you using 'N'.
*
* O # Ooooze How much your nozzle will Ooooze filament while getting in position to print. This
* is over kill, but using this parameter will let you get the very first 'cicle' perfect
* so you have a trophy to peel off of the bed and hang up to show how perfectly you have your
* Mesh calibrated. If not specified, a filament length of .3mm is assumed.
*
* P # Prime Prime the nozzle with specified length of filament. If this parameter is not
* given, no prime action will take place. If the parameter specifies an amount, that much
* will be purged before continuing. If no amount is specified the command will start
* purging filament until the user provides an LCD Click and then it will continue with
* printing the Mesh. You can carefully remove the spent filament with a needle nose
* pliers while holding the LCD Click wheel in a depressed state.
*
* R # Random Randomize the order that the circles are drawn on the bed. The search for the closest
* undrawn cicle is still done. But the distance to the location for each circle has a
* random number of the size specified added to it. Specifying R50 will give an interesting
* deviation from the normal behaviour on a 10 x 10 Mesh.
*
* X # X coordinate Specify the starting location of the drawing activity.
*
* Y # Y coordinate Specify the starting location of the drawing activity.
*/
// External references
extern float feedrate;
extern Planner planner;
#if ENABLED(ULTRA_LCD)
extern char lcd_status_message[];
#endif
extern float destination[XYZE];
void set_destination_to_current();
void set_current_to_destination();
float code_value_float();
float code_value_linear_units();
float code_value_axis_units(const AxisEnum axis);
bool code_value_bool();
bool code_has_value();
void lcd_init();
void lcd_setstatuspgm(const char* const message, const uint8_t level);
bool prepare_move_to_destination_cartesian();
void line_to_destination();
void line_to_destination(float);
void sync_plan_position_e();
void chirp_at_user();
// Private functions
void un_retract_filament(float where[XYZE]);
void retract_filament(float where[XYZE]);
void look_for_lines_to_connect();
bool parse_G26_parameters();
void move_to(const float&, const float&, const float&, const float&) ;
void print_line_from_here_to_there(const float&, const float&, const float&, const float&, const float&, const float&);
bool turn_on_heaters();
bool prime_nozzle();
static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16], continue_with_closest = 0;
float g26_e_axis_feedrate = 0.020,
random_deviation = 0.0,
layer_height = LAYER_HEIGHT;
static bool g26_retracted = false; // Track the retracted state of the nozzle so mismatched
// retracts/recovers won't result in a bad state.
float valid_trig_angle(float);
mesh_index_pair find_closest_circle_to_print(const float&, const float&);
static float extrusion_multiplier = EXTRUSION_MULTIPLIER,
retraction_multiplier = RETRACTION_MULTIPLIER,
nozzle = NOZZLE,
filament_diameter = FILAMENT,
prime_length = PRIME_LENGTH,
x_pos, y_pos,
ooze_amount = OOZE_AMOUNT;
static int16_t bed_temp = BED_TEMP,
hotend_temp = HOTEND_TEMP;
static int8_t prime_flag = 0;
static bool keep_heaters_on = false;
/**
* G26: Mesh Validation Pattern generation.
*
* Used to interactively edit UBL's Mesh by placing the
* nozzle in a problem area and doing a G29 P4 R command.
*/
void gcode_G26() {
SERIAL_ECHOLNPGM("G26 command started. Waiting for heater(s).");
float tmp, start_angle, end_angle;
int i, xi, yi;
mesh_index_pair location;
// Don't allow Mesh Validation without homing first,
// or if the parameter parsing did not go OK, abort
if (axis_unhomed_error(true, true, true) || parse_G26_parameters()) return;
if (current_position[Z_AXIS] < Z_CLEARANCE_BETWEEN_PROBES) {
do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES);
stepper.synchronize();
set_current_to_destination();
}
if (turn_on_heaters()) goto LEAVE;
current_position[E_AXIS] = 0.0;
sync_plan_position_e();
if (prime_flag && prime_nozzle()) goto LEAVE;
/**
* Bed is preheated
*
* Nozzle is at temperature
*
* Filament is primed!
*
* It's "Show Time" !!!
*/
ZERO(circle_flags);
ZERO(horizontal_mesh_line_flags);
ZERO(vertical_mesh_line_flags);
// Move nozzle to the specified height for the first layer
set_destination_to_current();
destination[Z_AXIS] = layer_height;
move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0.0);
move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], ooze_amount);
ubl.has_control_of_lcd_panel = true;
//debug_current_and_destination(PSTR("Starting G26 Mesh Validation Pattern."));
/**
* Declare and generate a sin() & cos() table to be used during the circle drawing. This will lighten
* the CPU load and make the arc drawing faster and more smooth
*/
float sin_table[360 / 30 + 1], cos_table[360 / 30 + 1];
for (i = 0; i <= 360 / 30; i++) {
cos_table[i] = SIZE_OF_INTERSECTION_CIRCLES * cos(RADIANS(valid_trig_angle(i * 30.0)));
sin_table[i] = SIZE_OF_INTERSECTION_CIRCLES * sin(RADIANS(valid_trig_angle(i * 30.0)));
}
do {
if (ubl_lcd_clicked()) { // Check if the user wants to stop the Mesh Validation
#if ENABLED(ULTRA_LCD)
lcd_setstatuspgm(PSTR("Mesh Validation Stopped."), 99);
lcd_quick_feedback();
#endif
while (!ubl_lcd_clicked()) { // Wait until the user is done pressing the
idle(); // Encoder Wheel if that is why we are leaving
lcd_reset_alert_level();
lcd_setstatuspgm(PSTR(""));
}
while (ubl_lcd_clicked()) { // Wait until the user is done pressing the
idle(); // Encoder Wheel if that is why we are leaving
lcd_setstatuspgm(PSTR("Unpress Wheel"), 99);
}
goto LEAVE;
}
location = continue_with_closest
? find_closest_circle_to_print(current_position[X_AXIS], current_position[Y_AXIS])
: find_closest_circle_to_print(x_pos, y_pos); // Find the closest Mesh Intersection to where we are now.
if (location.x_index >= 0 && location.y_index >= 0) {
const float circle_x = pgm_read_float(&ubl.mesh_index_to_xpos[location.x_index]),
circle_y = pgm_read_float(&ubl.mesh_index_to_ypos[location.y_index]);
// Let's do a couple of quick sanity checks. We can pull this code out later if we never see it catch a problem
#ifdef DELTA
if (HYPOT2(circle_x, circle_y) > sq(DELTA_PRINTABLE_RADIUS)) {
SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Attempt to print outside of DELTA_PRINTABLE_RADIUS.");
goto LEAVE;
}
#endif
// TODO: Change this to use `position_is_reachable`
if (!WITHIN(circle_x, X_MIN_POS, X_MAX_POS) || !WITHIN(circle_y, Y_MIN_POS, Y_MAX_POS)) {
SERIAL_ERROR_START;
SERIAL_ERRORLNPGM("Attempt to print off the bed.");
goto LEAVE;
}
xi = location.x_index; // Just to shrink the next few lines and make them easier to understand
yi = location.y_index;
if (ubl.g26_debug_flag) {
SERIAL_ECHOPAIR(" Doing circle at: (xi=", xi);
SERIAL_ECHOPAIR(", yi=", yi);
SERIAL_CHAR(')');
SERIAL_EOL;
}
start_angle = 0.0; // assume it is going to be a full circle
end_angle = 360.0;
if (xi == 0) { // Check for bottom edge
start_angle = -90.0;
end_angle = 90.0;
if (yi == 0) // it is an edge, check for the two left corners
start_angle = 0.0;
else if (yi == GRID_MAX_POINTS_Y - 1)
end_angle = 0.0;
}
else if (xi == GRID_MAX_POINTS_X - 1) { // Check for top edge
start_angle = 90.0;
end_angle = 270.0;
if (yi == 0) // it is an edge, check for the two right corners
end_angle = 180.0;
else if (yi == GRID_MAX_POINTS_Y - 1)
start_angle = 180.0;
}
else if (yi == 0) {
start_angle = 0.0; // only do the top side of the cirlce
end_angle = 180.0;
}
else if (yi == GRID_MAX_POINTS_Y - 1) {
start_angle = 180.0; // only do the bottom side of the cirlce
end_angle = 360.0;
}
for (tmp = start_angle; tmp < end_angle - 0.1; tmp += 30.0) {
int tmp_div_30 = tmp / 30.0;
if (tmp_div_30 < 0) tmp_div_30 += 360 / 30;
if (tmp_div_30 > 11) tmp_div_30 -= 360 / 30;
float x = circle_x + cos_table[tmp_div_30], // for speed, these are now a lookup table entry
y = circle_y + sin_table[tmp_div_30],
xe = circle_x + cos_table[tmp_div_30 + 1],
ye = circle_y + sin_table[tmp_div_30 + 1];
#ifdef DELTA
if (HYPOT2(x, y) > sq(DELTA_PRINTABLE_RADIUS)) // Check to make sure this part of
continue; // the 'circle' is on the bed. If
#else // not, we need to skip
x = constrain(x, X_MIN_POS + 1, X_MAX_POS - 1); // This keeps us from bumping the endstops
y = constrain(y, Y_MIN_POS + 1, Y_MAX_POS - 1);
xe = constrain(xe, X_MIN_POS + 1, X_MAX_POS - 1);
ye = constrain(ye, Y_MIN_POS + 1, Y_MAX_POS - 1);
#endif
//if (ubl.g26_debug_flag) {
// char ccc, *cptr, seg_msg[50], seg_num[10];
// strcpy(seg_msg, " segment: ");
// strcpy(seg_num, " \n");
// cptr = (char*) "01234567890ABCDEF????????";
// ccc = cptr[tmp_div_30];
// seg_num[1] = ccc;
// strcat(seg_msg, seg_num);
// debug_current_and_destination(seg_msg);
//}
print_line_from_here_to_there(LOGICAL_X_POSITION(x), LOGICAL_Y_POSITION(y), layer_height, LOGICAL_X_POSITION(xe), LOGICAL_Y_POSITION(ye), layer_height);
}
//debug_current_and_destination(PSTR("Looking for lines to connect."));
look_for_lines_to_connect();
//debug_current_and_destination(PSTR("Done with line connect."));
}
//debug_current_and_destination(PSTR("Done with current circle."));
} while (location.x_index >= 0 && location.y_index >= 0);
LEAVE:
lcd_reset_alert_level();
lcd_setstatuspgm(PSTR("Leaving G26"));
retract_filament(destination);
destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES;
//debug_current_and_destination(PSTR("ready to do Z-Raise."));
move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0); // Raise the nozzle
//debug_current_and_destination(PSTR("done doing Z-Raise."));
destination[X_AXIS] = x_pos; // Move back to the starting position
destination[Y_AXIS] = y_pos;
//destination[Z_AXIS] = Z_CLEARANCE_BETWEEN_PROBES; // Keep the nozzle where it is
move_to(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], 0); // Move back to the starting position
//debug_current_and_destination(PSTR("done doing X/Y move."));
ubl.has_control_of_lcd_panel = false; // Give back control of the LCD Panel!
if (!keep_heaters_on) {
#if HAS_TEMP_BED
thermalManager.setTargetBed(0);
#endif
thermalManager.setTargetHotend(0, 0);
}
}
float valid_trig_angle(float d) {
while (d > 360.0) d -= 360.0;
while (d < 0.0) d += 360.0;
return d;
}
mesh_index_pair find_closest_circle_to_print(const float &X, const float &Y) {
float closest = 99999.99;
mesh_index_pair return_val;
return_val.x_index = return_val.y_index = -1;
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; j++) {
if (!is_bit_set(circle_flags, i, j)) {
const float mx = pgm_read_float(&ubl.mesh_index_to_xpos[i]), // We found a circle that needs to be printed
my = pgm_read_float(&ubl.mesh_index_to_ypos[j]);
// Get the distance to this intersection
float f = HYPOT(X - mx, Y - my);
// It is possible that we are being called with the values
// to let us find the closest circle to the start position.
// But if this is not the case, add a small weighting to the
// distance calculation to help it choose a better place to continue.
f += HYPOT(x_pos - mx, y_pos - my) / 15.0;
// Add in the specified amount of Random Noise to our search
if (random_deviation > 1.0)
f += random(0.0, random_deviation);
if (f < closest) {
closest = f; // We found a closer location that is still
return_val.x_index = i; // un-printed --- save the data for it
return_val.y_index = j;
return_val.distance = closest;
}
}
}
}
bit_set(circle_flags, return_val.x_index, return_val.y_index); // Mark this location as done.
return return_val;
}
void look_for_lines_to_connect() {
float sx, sy, ex, ey;
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
for (uint8_t j = 0; j < GRID_MAX_POINTS_Y; j++) {
if (i < GRID_MAX_POINTS_X) { // We can't connect to anything to the right than GRID_MAX_POINTS_X.
// This is already a half circle because we are at the edge of the bed.
if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i + 1, j)) { // check if we can do a line to the left
if (!is_bit_set(horizontal_mesh_line_flags, i, j)) {
//
// We found two circles that need a horizontal line to connect them
// Print it!
//
sx = pgm_read_float(&ubl.mesh_index_to_xpos[ i ]) + (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // right edge
ex = pgm_read_float(&ubl.mesh_index_to_xpos[i + 1]) - (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // left edge
sx = constrain(sx, X_MIN_POS + 1, X_MAX_POS - 1);
sy = ey = constrain(pgm_read_float(&ubl.mesh_index_to_ypos[j]), Y_MIN_POS + 1, Y_MAX_POS - 1);
ex = constrain(ex, X_MIN_POS + 1, X_MAX_POS - 1);
if (ubl.g26_debug_flag) {
SERIAL_ECHOPAIR(" Connecting with horizontal line (sx=", sx);
SERIAL_ECHOPAIR(", sy=", sy);
SERIAL_ECHOPAIR(") -> (ex=", ex);
SERIAL_ECHOPAIR(", ey=", ey);
SERIAL_CHAR(')');
SERIAL_EOL;
//debug_current_and_destination(PSTR("Connecting horizontal line."));
}
print_line_from_here_to_there(LOGICAL_X_POSITION(sx), LOGICAL_Y_POSITION(sy), layer_height, LOGICAL_X_POSITION(ex), LOGICAL_Y_POSITION(ey), layer_height);
bit_set(horizontal_mesh_line_flags, i, j); // Mark it as done so we don't do it again
}
}
if (j < GRID_MAX_POINTS_Y) { // We can't connect to anything further back than GRID_MAX_POINTS_Y.
// This is already a half circle because we are at the edge of the bed.
if (is_bit_set(circle_flags, i, j) && is_bit_set(circle_flags, i, j + 1)) { // check if we can do a line straight down
if (!is_bit_set( vertical_mesh_line_flags, i, j)) {
//
// We found two circles that need a vertical line to connect them
// Print it!
//
sy = pgm_read_float(&ubl.mesh_index_to_ypos[ j ]) + (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // top edge
ey = pgm_read_float(&ubl.mesh_index_to_ypos[j + 1]) - (SIZE_OF_INTERSECTION_CIRCLES - (SIZE_OF_CROSSHAIRS)); // bottom edge
sx = ex = constrain(pgm_read_float(&ubl.mesh_index_to_xpos[i]), X_MIN_POS + 1, X_MAX_POS - 1);
sy = constrain(sy, Y_MIN_POS + 1, Y_MAX_POS - 1);
ey = constrain(ey, Y_MIN_POS + 1, Y_MAX_POS - 1);
if (ubl.g26_debug_flag) {
SERIAL_ECHOPAIR(" Connecting with vertical line (sx=", sx);
SERIAL_ECHOPAIR(", sy=", sy);
SERIAL_ECHOPAIR(") -> (ex=", ex);
SERIAL_ECHOPAIR(", ey=", ey);
SERIAL_CHAR(')');
SERIAL_EOL;
debug_current_and_destination(PSTR("Connecting vertical line."));
}
print_line_from_here_to_there(LOGICAL_X_POSITION(sx), LOGICAL_Y_POSITION(sy), layer_height, LOGICAL_X_POSITION(ex), LOGICAL_Y_POSITION(ey), layer_height);
bit_set(vertical_mesh_line_flags, i, j); // Mark it as done so we don't do it again
}
}
}
}
}
}
}
void move_to(const float &x, const float &y, const float &z, const float &e_delta) {
float feed_value;
static float last_z = -999.99;
bool has_xy_component = (x != current_position[X_AXIS] || y != current_position[Y_AXIS]); // Check if X or Y is involved in the movement.
//if (ubl.g26_debug_flag) SERIAL_ECHOLNPAIR("in move_to() has_xy_component:", (int)has_xy_component);
if (z != last_z) {
//if (ubl.g26_debug_flag) SERIAL_ECHOLNPAIR("in move_to() changing Z to ", (int)z);
last_z = z;
feed_value = planner.max_feedrate_mm_s[Z_AXIS]/(3.0); // Base the feed rate off of the configured Z_AXIS feed rate
destination[X_AXIS] = current_position[X_AXIS];
destination[Y_AXIS] = current_position[Y_AXIS];
destination[Z_AXIS] = z; // We know the last_z==z or we wouldn't be in this block of code.
destination[E_AXIS] = current_position[E_AXIS];
ubl_line_to_destination(feed_value, 0);
stepper.synchronize();
set_destination_to_current();
//if (ubl.g26_debug_flag) debug_current_and_destination(PSTR(" in move_to() done with Z move"));
}
// Check if X or Y is involved in the movement.
// Yes: a 'normal' movement. No: a retract() or un_retract()
feed_value = has_xy_component ? PLANNER_XY_FEEDRATE() / 10.0 : planner.max_feedrate_mm_s[E_AXIS] / 1.5;
if (ubl.g26_debug_flag) SERIAL_ECHOLNPAIR("in move_to() feed_value for XY:", feed_value);
destination[X_AXIS] = x;
destination[Y_AXIS] = y;
destination[E_AXIS] += e_delta;
//if (ubl.g26_debug_flag) debug_current_and_destination(PSTR(" in move_to() doing last move"));
ubl_line_to_destination(feed_value, 0);
//if (ubl.g26_debug_flag) debug_current_and_destination(PSTR(" in move_to() after last move"));
stepper.synchronize();
set_destination_to_current();
}
void retract_filament(float where[XYZE]) {
if (!g26_retracted) { // Only retract if we are not already retracted!
g26_retracted = true;
//if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM(" Decided to do retract.");
move_to(where[X_AXIS], where[Y_AXIS], where[Z_AXIS], -1.0 * retraction_multiplier);
//if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM(" Retraction done.");
}
}
void un_retract_filament(float where[XYZE]) {
if (g26_retracted) { // Only un-retract if we are retracted.
move_to(where[X_AXIS], where[Y_AXIS], where[Z_AXIS], 1.2 * retraction_multiplier);
g26_retracted = false;
//if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM(" unretract done.");
}
}
/**
* print_line_from_here_to_there() takes two cartesian coordinates and draws a line from one
* to the other. But there are really three sets of coordinates involved. The first coordinate
* is the present location of the nozzle. We don't necessarily want to print from this location.
* We first need to move the nozzle to the start of line segment where we want to print. Once
* there, we can use the two coordinates supplied to draw the line.
*
* Note: Although we assume the first set of coordinates is the start of the line and the second
* set of coordinates is the end of the line, it does not always work out that way. This function
* optimizes the movement to minimize the travel distance before it can start printing. This saves
* a lot of time and eleminates a lot of non-sensical movement of the nozzle. However, it does
* cause a lot of very little short retracement of th nozzle when it draws the very first line
* segment of a 'circle'. The time this requires is very short and is easily saved by the other
* cases where the optimization comes into play.
*/
void print_line_from_here_to_there(const float &sx, const float &sy, const float &sz, const float &ex, const float &ey, const float &ez) {
const float dx_s = current_position[X_AXIS] - sx, // find our distance from the start of the actual line segment
dy_s = current_position[Y_AXIS] - sy,
dist_start = HYPOT2(dx_s, dy_s), // We don't need to do a sqrt(), we can compare the distance^2
// to save computation time
dx_e = current_position[X_AXIS] - ex, // find our distance from the end of the actual line segment
dy_e = current_position[Y_AXIS] - ey,
dist_end = HYPOT2(dx_e, dy_e),
line_length = HYPOT(ex - sx, ey - sy);
// If the end point of the line is closer to the nozzle, flip the direction,
// moving from the end to the start. On very small lines the optimization isn't worth it.
if (dist_end < dist_start && (SIZE_OF_INTERSECTION_CIRCLES) < abs(line_length)) {
//if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM(" Reversing start and end of print_line_from_here_to_there()");
return print_line_from_here_to_there(ex, ey, ez, sx, sy, sz);
}
// Decide whether to retract.
if (dist_start > 2.0) {
retract_filament(destination);
//if (ubl.g26_debug_flag) SERIAL_ECHOLNPGM(" filament retracted.");
}
move_to(sx, sy, sz, 0.0); // Get to the starting point with no extrusion
const float e_pos_delta = line_length * g26_e_axis_feedrate * extrusion_multiplier;
un_retract_filament(destination);
//if (ubl.g26_debug_flag) {
// SERIAL_ECHOLNPGM(" doing printing move.");
// debug_current_and_destination(PSTR("doing final move_to() inside print_line_from_here_to_there()"));
//}
move_to(ex, ey, ez, e_pos_delta); // Get to the ending point with an appropriate amount of extrusion
}
/**
* This function used to be inline code in G26. But there are so many
* parameters it made sense to turn them into static globals and get
* this code out of sight of the main routine.
*/
bool parse_G26_parameters() {
extrusion_multiplier = EXTRUSION_MULTIPLIER;
retraction_multiplier = RETRACTION_MULTIPLIER;
nozzle = NOZZLE;
filament_diameter = FILAMENT;
layer_height = LAYER_HEIGHT;
prime_length = PRIME_LENGTH;
bed_temp = BED_TEMP;
hotend_temp = HOTEND_TEMP;
ooze_amount = OOZE_AMOUNT;
prime_flag = 0;
keep_heaters_on = false;
if (code_seen('B')) {
bed_temp = code_value_temp_abs();
if (!WITHIN(bed_temp, 15, 140)) {
SERIAL_PROTOCOLLNPGM("?Specified bed temperature not plausible.");
return UBL_ERR;
}
}
if (code_seen('C')) continue_with_closest++;
if (code_seen('L')) {
layer_height = code_value_linear_units();
if (!WITHIN(layer_height, 0.0, 2.0)) {
SERIAL_PROTOCOLLNPGM("?Specified layer height not plausible.");
return UBL_ERR;
}
}
if (code_seen('Q')) {
if (code_has_value()) {
retraction_multiplier = code_value_float();
if (!WITHIN(retraction_multiplier, 0.05, 15.0)) {
SERIAL_PROTOCOLLNPGM("?Specified Retraction Multiplier not plausible.");
return UBL_ERR;
}
}
else {
SERIAL_PROTOCOLLNPGM("?Retraction Multiplier must be specified.");
return UBL_ERR;
}
}
if (code_seen('N') || code_seen('n')) {
nozzle = code_value_float();
if (!WITHIN(nozzle, 0.1, 1.0)) {
SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible.");
return UBL_ERR;
}
}
if (code_seen('K')) keep_heaters_on++;
if (code_seen('O') && code_has_value())
ooze_amount = code_value_linear_units();
if (code_seen('P')) {
if (!code_has_value())
prime_flag = -1;
else {
prime_flag++;
prime_length = code_value_linear_units();
if (!WITHIN(prime_length, 0.0, 25.0)) {
SERIAL_PROTOCOLLNPGM("?Specified prime length not plausible.");
return UBL_ERR;
}
}
}
if (code_seen('F')) {
filament_diameter = code_value_linear_units();
if (!WITHIN(filament_diameter, 1.0, 4.0)) {
SERIAL_PROTOCOLLNPGM("?Specified filament size not plausible.");
return UBL_ERR;
}
}
extrusion_multiplier *= sq(1.75) / sq(filament_diameter); // If we aren't using 1.75mm filament, we need to
// scale up or down the length needed to get the
// same volume of filament
extrusion_multiplier *= filament_diameter * sq(nozzle) / sq(0.3); // Scale up by nozzle size
if (code_seen('H')) {
hotend_temp = code_value_temp_abs();
if (!WITHIN(hotend_temp, 165, 280)) {
SERIAL_PROTOCOLLNPGM("?Specified nozzle temperature not plausible.");
return UBL_ERR;
}
}
if (code_seen('R')) {
randomSeed(millis());
random_deviation = code_has_value() ? code_value_float() : 50.0;
}
x_pos = current_position[X_AXIS];
y_pos = current_position[Y_AXIS];
if (code_seen('X')) {
x_pos = code_value_axis_units(X_AXIS);
if (!WITHIN(x_pos, X_MIN_POS, X_MAX_POS)) {
SERIAL_PROTOCOLLNPGM("?Specified X coordinate not plausible.");
return UBL_ERR;
}
}
else
if (code_seen('Y')) {
y_pos = code_value_axis_units(Y_AXIS);
if (!WITHIN(y_pos, Y_MIN_POS, Y_MAX_POS)) {
SERIAL_PROTOCOLLNPGM("?Specified Y coordinate not plausible.");
return UBL_ERR;
}
}
/**
* We save the question of what to do with the Unified Bed Leveling System's Activation until the very
* end. The reason is, if one of the parameters specified up above is incorrect, we don't want to
* alter the system's status. We wait until we know everything is correct before altering the state
* of the system.
*/
ubl.state.active = !code_seen('D');
return UBL_OK;
}
bool exit_from_g26() {
//strcpy(lcd_status_message, "Leaving G26"); // We can't do lcd_setstatus() without having it continue;
lcd_reset_alert_level();
lcd_setstatuspgm(PSTR("Leaving G26"));
while (ubl_lcd_clicked()) idle();
return UBL_ERR;
}
/**
* Turn on the bed and nozzle heat and
* wait for them to get up to temperature.
*/
bool turn_on_heaters() {
millis_t next;
#if HAS_TEMP_BED
#if ENABLED(ULTRA_LCD)
if (bed_temp > 25) {
lcd_setstatuspgm(PSTR("G26 Heating Bed."), 99);
lcd_quick_feedback();
#endif
ubl.has_control_of_lcd_panel = true;
thermalManager.setTargetBed(bed_temp);
next = millis() + 5000UL;
while (abs(thermalManager.degBed() - bed_temp) > 3) {
if (ubl_lcd_clicked()) return exit_from_g26();
if (PENDING(millis(), next)) {
next = millis() + 5000UL;
print_heaterstates();
}
idle();
}
#if ENABLED(ULTRA_LCD)
}
lcd_setstatuspgm(PSTR("G26 Heating Nozzle."), 99);
lcd_quick_feedback();
#endif
#endif
// Start heating the nozzle and wait for it to reach temperature.
thermalManager.setTargetHotend(hotend_temp, 0);
while (abs(thermalManager.degHotend(0) - hotend_temp) > 3) {
if (ubl_lcd_clicked()) return exit_from_g26();
if (PENDING(millis(), next)) {
next = millis() + 5000UL;
print_heaterstates();
}
idle();
}
#if ENABLED(ULTRA_LCD)
lcd_reset_alert_level();
lcd_setstatuspgm(PSTR(""));
lcd_quick_feedback();
#endif
return UBL_OK;
}
/**
* Prime the nozzle if needed. Return true on error.
*/
bool prime_nozzle() {
float Total_Prime = 0.0;
if (prime_flag == -1) { // The user wants to control how much filament gets purged
ubl.has_control_of_lcd_panel = true;
lcd_setstatuspgm(PSTR("User-Controlled Prime"), 99);
chirp_at_user();
set_destination_to_current();
un_retract_filament(destination); // Make sure G26 doesn't think the filament is retracted().
while (!ubl_lcd_clicked()) {
chirp_at_user();
destination[E_AXIS] += 0.25;
#ifdef PREVENT_LENGTHY_EXTRUDE
Total_Prime += 0.25;
if (Total_Prime >= EXTRUDE_MAXLENGTH) return UBL_ERR;
#endif
ubl_line_to_destination(planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0);
stepper.synchronize(); // Without this synchronize, the purge is more consistent,
// but because the planner has a buffer, we won't be able
// to stop as quickly. So we put up with the less smooth
// action to give the user a more responsive 'Stop'.
set_destination_to_current();
idle();
}
while (ubl_lcd_clicked()) idle(); // Debounce Encoder Wheel
#if ENABLED(ULTRA_LCD)
strcpy_P(lcd_status_message, PSTR("Done Priming")); // We can't do lcd_setstatuspgm() without having it continue;
// So... We cheat to get a message up.
lcd_setstatuspgm(PSTR("Done Priming"), 99);
lcd_quick_feedback();
#endif
ubl.has_control_of_lcd_panel = false;
}
else {
#if ENABLED(ULTRA_LCD)
lcd_setstatuspgm(PSTR("Fixed Length Prime."), 99);
lcd_quick_feedback();
#endif
set_destination_to_current();
destination[E_AXIS] += prime_length;
ubl_line_to_destination(planner.max_feedrate_mm_s[E_AXIS] / 15.0, 0);
stepper.synchronize();
set_destination_to_current();
retract_filament(destination);
}
return UBL_OK;
}
#endif // AUTO_BED_LEVELING_UBL && UBL_G26_MESH_EDITING

View File

@@ -26,223 +26,310 @@
* This code watches the free memory block between the bottom of the heap and the top of the stack. * This code watches the free memory block between the bottom of the heap and the top of the stack.
* This memory block is initialized and watched via the M100 command. * This memory block is initialized and watched via the M100 command.
* *
* M100 I Initializes the free memory block and prints vitals statistics about the area * M100 I Initializes the free memory block and prints vitals statistics about the area
* M100 F Identifies how much of the free memory block remains free and unused. It also
* detects and reports any corruption within the free memory block that may have
* happened due to errant firmware.
* M100 D Does a hex display of the free memory block along with a flag for any errant
* data that does not match the expected value.
* M100 C x Corrupts x locations within the free memory block. This is useful to check the
* correctness of the M100 F and M100 D commands.
* *
* Initial version by Roxy-3DPrintBoard * M100 F Identifies how much of the free memory block remains free and unused. It also
* detects and reports any corruption within the free memory block that may have
* happened due to errant firmware.
*
* M100 D Does a hex display of the free memory block along with a flag for any errant
* data that does not match the expected value.
*
* M100 C x Corrupts x locations within the free memory block. This is useful to check the
* correctness of the M100 F and M100 D commands.
*
* Also, there are two support functions that can be called from a developer's C code.
*
* uint16_t check_for_free_memory_corruption(const char * const ptr);
* void M100_dump_routine(const char * const title, const char *start, const char *end);
*
* Initial version by Roxy-3D
*/ */
#define M100_FREE_MEMORY_DUMPER // Comment out to remove Dump sub-command #define M100_FREE_MEMORY_DUMPER // Enable for the `M110 D` Dump sub-command
#define M100_FREE_MEMORY_CORRUPTOR // Comment out to remove Corrupt sub-command #define M100_FREE_MEMORY_CORRUPTOR // Enable for the `M100 C` Corrupt sub-command
#include "Marlin.h" #include "MarlinConfig.h"
#if ENABLED(M100_FREE_MEMORY_WATCHER) #if ENABLED(M100_FREE_MEMORY_WATCHER)
#define TEST_BYTE ((char) 0xE5)
extern char command_queue[BUFSIZE][MAX_CMD_SIZE];
extern char* __brkval; extern char* __brkval;
extern size_t __heap_start, __heap_end, __flp; extern size_t __heap_start, __heap_end, __flp;
extern char __bss_end; extern char __bss_end;
#include "Marlin.h"
#include "hex_print_routines.h"
// //
// Utility functions used by M100 to get its work done. // Utility functions
// //
char* top_of_stack(); #define END_OF_HEAP() (__brkval ? __brkval : &__bss_end)
void prt_hex_nibble(unsigned int); int check_for_free_memory_corruption(const char * const title);
void prt_hex_byte(unsigned int);
void prt_hex_word(unsigned int);
int how_many_E5s_are_here(char*);
void gcode_M100() {
static bool m100_not_initialized = true;
char* sp, *ptr;
int i, j, n;
//
// M100 D dumps the free memory block from __brkval to the stack pointer.
// malloc() eats memory from the start of the block and the stack grows
// up from the bottom of the block. Solid 0xE5's indicate nothing has
// used that memory yet. There should not be anything but 0xE5's within
// the block of 0xE5's. If there is, that would indicate memory corruption
// probably caused by bad pointers. Any unexpected values will be flagged in
// the right hand column to help spotting them.
//
#if ENABLED(M100_FREE_MEMORY_DUMPER) // Disable to remove Dump sub-command
if (code_seen('D')) {
ptr = __brkval ? __brkval : &__bss_end;
//
// We want to start and end the dump on a nice 16 byte boundry even though
// the values we are using are not 16 byte aligned.
//
SERIAL_ECHOPGM("\nbss_end : ");
prt_hex_word((unsigned int) ptr);
ptr = (char*)((unsigned long) ptr & 0xfff0);
sp = top_of_stack();
SERIAL_ECHOPGM("\nStack Pointer : ");
prt_hex_word((unsigned int) sp);
SERIAL_EOL;
sp = (char*)((unsigned long) sp | 0x000f);
n = sp - ptr;
//
// This is the main loop of the Dump command.
//
while (ptr < sp) {
prt_hex_word((unsigned int) ptr); // Print the address
SERIAL_CHAR(':');
for (i = 0; i < 16; i++) { // and 16 data bytes
prt_hex_byte(*(ptr + i));
SERIAL_CHAR(' ');
}
SERIAL_CHAR('|'); // now show where non 0xE5's are
for (i = 0; i < 16; i++) {
if (*(ptr + i) == (char)0xe5)
SERIAL_CHAR(' ');
else
SERIAL_CHAR('?');
}
SERIAL_EOL;
ptr += 16;
}
return;
}
#endif
//
// M100 F requests the code to return the number of free bytes in the memory pool along with
// other vital statistics that define the memory pool.
//
if (code_seen('F')) {
#if 0
int max_addr = (int) __brkval ? __brkval : &__bss_end;
int max_cnt = 0;
#endif
int block_cnt = 0;
ptr = __brkval ? __brkval : &__bss_end;
sp = top_of_stack();
n = sp - ptr;
// Scan through the range looking for the biggest block of 0xE5's we can find
for (i = 0; i < n; i++) {
if (*(ptr + i) == (char)0xe5) {
j = how_many_E5s_are_here(ptr + i);
if (j > 8) {
SERIAL_ECHOPAIR("Found ", j);
SERIAL_ECHOPGM(" bytes free at 0x");
prt_hex_word((int) ptr + i);
SERIAL_EOL;
i += j;
block_cnt++;
}
#if 0
if (j > max_cnt) { // We don't do anything with this information yet
max_cnt = j; // but we do know where the biggest free memory block is.
max_addr = (int) ptr + i;
}
#endif
}
}
if (block_cnt > 1)
SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.");
return;
}
//
// M100 C x Corrupts x locations in the free memory pool and reports the locations of the corruption.
// This is useful to check the correctness of the M100 D and the M100 F commands.
//
#if ENABLED(M100_FREE_MEMORY_CORRUPTOR)
if (code_seen('C')) {
int x = code_value_int(); // x gets the # of locations to corrupt within the memory pool
SERIAL_ECHOLNPGM("Corrupting free memory block.\n");
ptr = __brkval ? __brkval : &__bss_end;
SERIAL_ECHOPAIR("\nbss_end : ", ptr);
ptr += 8;
sp = top_of_stack();
SERIAL_ECHOPAIR("\nStack Pointer : ", sp);
SERIAL_ECHOLNPGM("\n");
n = sp - ptr - 64; // -64 just to keep us from finding interrupt activity that
// has altered the stack.
j = n / (x + 1);
for (i = 1; i <= x; i++) {
*(ptr + (i * j)) = i;
SERIAL_ECHOPGM("\nCorrupting address: 0x");
prt_hex_word((unsigned int)(ptr + (i * j)));
}
SERIAL_ECHOLNPGM("\n");
return;
}
#endif
//
// M100 I Initializes the free memory pool so it can be watched and prints vital
// statistics that define the free memory pool.
//
if (m100_not_initialized || code_seen('I')) { // If no sub-command is specified, the first time
SERIAL_ECHOLNPGM("Initializing free memory block.\n"); // this happens, it will Initialize.
ptr = __brkval ? __brkval : &__bss_end; // Repeated M100 with no sub-command will not destroy the
SERIAL_ECHOPAIR("\nbss_end : ", ptr); // state of the initialized free memory pool.
ptr += 8;
sp = top_of_stack();
SERIAL_ECHOPAIR("\nStack Pointer : ", sp);
SERIAL_ECHOLNPGM("\n");
n = sp - ptr - 64; // -64 just to keep us from finding interrupt activity that
// has altered the stack.
SERIAL_ECHO(n);
SERIAL_ECHOLNPGM(" bytes of memory initialized.\n");
for (i = 0; i < n; i++)
*(ptr + i) = (char)0xe5;
for (i = 0; i < n; i++) {
if (*(ptr + i) != (char)0xe5) {
SERIAL_ECHOPAIR("? address : ", ptr + i);
SERIAL_ECHOPAIR("=", *(ptr + i));
SERIAL_ECHOLNPGM("\n");
}
}
m100_not_initialized = false;
return;
}
return;
}
// top_of_stack() returns the location of a variable on its stack frame. The value returned is above
// the stack once the function returns to the caller.
// Location of a variable on its stack frame. Returns a value above
// the stack (once the function returns to the caller).
char* top_of_stack() { char* top_of_stack() {
char x; char x;
return &x + 1; // x is pulled on return; return &x + 1; // x is pulled on return;
} }
// // Count the number of test bytes at the specified location.
// 3 support routines to print hex numbers. We can print a nibble, byte and word int16_t count_test_bytes(const uint8_t * const ptr) {
// for (uint16_t i = 0; i < 32000; i++)
if (((char) ptr[i]) != TEST_BYTE)
return i - 1;
void prt_hex_nibble(unsigned int n) {
if (n <= 9)
SERIAL_ECHO(n);
else
SERIAL_ECHO((char)('A' + n - 10));
}
void prt_hex_byte(unsigned int b) {
prt_hex_nibble((b & 0xf0) >> 4);
prt_hex_nibble(b & 0x0f);
}
void prt_hex_word(unsigned int w) {
prt_hex_byte((w & 0xff00) >> 8);
prt_hex_byte(w & 0x0ff);
}
// how_many_E5s_are_here() is a utility function to easily find out how many 0xE5's are
// at the specified location. Having this logic as a function simplifies the search code.
//
int how_many_E5s_are_here(char* p) {
int n;
for (n = 0; n < 32000; n++) {
if (*(p + n) != (char)0xe5)
return n - 1;
}
return -1; return -1;
} }
#endif //
// M100 sub-commands
//
#if ENABLED(M100_FREE_MEMORY_DUMPER)
/**
* M100 D
* Dump the free memory block from __brkval to the stack pointer.
* malloc() eats memory from the start of the block and the stack grows
* up from the bottom of the block. Solid test bytes indicate nothing has
* used that memory yet. There should not be anything but test bytes within
* the block. If so, it may indicate memory corruption due to a bad pointer.
* Unexpected bytes are flagged in the right column.
*/
void dump_free_memory(const uint8_t *ptr, const uint8_t *sp) {
//
// Start and end the dump on a nice 16 byte boundary
// (even though the values are not 16-byte aligned).
//
ptr = (uint8_t *)((uint16_t)ptr & 0xFFF0); // Align to 16-byte boundary
sp = (uint8_t *)((uint16_t)sp | 0x000F); // Align sp to the 15th byte (at or above sp)
// Dump command main loop
while (ptr < sp) {
print_hex_word((uint16_t)ptr); // Print the address
SERIAL_CHAR(':');
for (uint8_t i = 0; i < 16; i++) { // and 16 data bytes
if (i == 8) SERIAL_CHAR('-');
print_hex_byte(ptr[i]);
SERIAL_CHAR(' ');
}
safe_delay(25);
SERIAL_CHAR('|'); // Point out non test bytes
for (uint8_t i = 0; i < 16; i++) {
char ccc = (char)ptr[i]; // cast to char before automatically casting to char on assignment, in case the compiler is broken
if (&ptr[i] >= command_queue && &ptr[i] < &command_queue[BUFSIZE][MAX_CMD_SIZE]) { // Print out ASCII in the command buffer area
if (!WITHIN(ccc, ' ', 0x7E)) ccc = ' ';
}
else { // If not in the command buffer area, flag bytes that don't match the test byte
ccc = (ccc == TEST_BYTE) ? ' ' : '?';
}
SERIAL_CHAR(ccc);
}
SERIAL_EOL;
ptr += 16;
safe_delay(25);
idle();
}
}
void M100_dump_routine(const char * const title, const char *start, const char *end) {
SERIAL_ECHOLN(title);
//
// Round the start and end locations to produce full lines of output
//
start = (char*)((uint16_t) start & 0xFFF0);
end = (char*)((uint16_t) end | 0x000F);
dump_free_memory(start, end);
}
#endif // M100_FREE_MEMORY_DUMPER
/**
* M100 F
* Return the number of free bytes in the memory pool,
* with other vital statistics defining the pool.
*/
void free_memory_pool_report(const char * const ptr, const uint16_t size) {
int16_t max_cnt = -1;
uint16_t block_cnt = 0;
char *max_addr = NULL;
// Find the longest block of test bytes in the buffer
for (uint16_t i = 0; i < size; i++) {
char * const addr = ptr + i;
if (*addr == TEST_BYTE) {
const uint16_t j = count_test_bytes(addr);
if (j > 8) {
SERIAL_ECHOPAIR("Found ", j);
SERIAL_ECHOLNPAIR(" bytes free at ", hex_address(addr));
if (j > max_cnt) {
max_cnt = j;
max_addr = addr;
}
i += j;
block_cnt++;
}
}
}
if (block_cnt > 1) {
SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.");
SERIAL_ECHOPAIR("\nLargest free block is ", max_cnt);
SERIAL_ECHOLNPAIR(" bytes at ", hex_address(max_addr));
}
SERIAL_ECHOLNPAIR("check_for_free_memory_corruption() = ", check_for_free_memory_corruption("M100 F "));
}
#if ENABLED(M100_FREE_MEMORY_CORRUPTOR)
/**
* M100 C<num>
* Corrupt <num> locations in the free memory pool and report the corrupt addresses.
* This is useful to check the correctness of the M100 D and the M100 F commands.
*/
void corrupt_free_memory(char *ptr, const uint16_t size) {
if (code_seen('C')) {
ptr += 8;
const uint16_t near_top = top_of_stack() - ptr - 250, // -250 to avoid interrupt activity that's altered the stack.
j = near_top / (size + 1);
SERIAL_ECHOLNPGM("Corrupting free memory block.\n");
for (uint16_t i = 1; i <= size; i++) {
char * const addr = ptr + i * j;
*addr = i;
SERIAL_ECHOPAIR("\nCorrupting address: ", hex_address(addr));
}
SERIAL_EOL;
}
}
#endif // M100_FREE_MEMORY_CORRUPTOR
/**
* M100 I
* Init memory for the M100 tests. (Automatically applied on the first M100.)
*/
void init_free_memory(uint8_t *ptr, int16_t size) {
SERIAL_ECHOLNPGM("Initializing free memory block.\n\n");
size -= 250; // -250 to avoid interrupt activity that's altered the stack.
if (size < 0) {
SERIAL_ECHOLNPGM("Unable to initialize.\n");
return;
}
ptr += 8; // move a few bytes away from the heap just because we don't want
// to be altering memory that close to it.
memset(ptr, TEST_BYTE, size);
SERIAL_ECHO(size);
SERIAL_ECHOLNPGM(" bytes of memory initialized.\n");
for (uint16_t i = 0; i < size; i++) {
if ((char)ptr[i] != TEST_BYTE) {
SERIAL_ECHOPAIR("? address : ", hex_address(ptr + i));
SERIAL_ECHOLNPAIR("=", hex_byte(ptr[i]));
SERIAL_EOL;
}
}
}
/**
* M100: Free Memory Check
*/
void gcode_M100() {
SERIAL_ECHOPAIR("\n__brkval : ", hex_address(__brkval));
SERIAL_ECHOPAIR("\n__bss_end : ", hex_address(&__bss_end));
char *ptr = END_OF_HEAP(), *sp = top_of_stack();
SERIAL_ECHOPAIR("\nstart of free space : ", hex_address(ptr));
SERIAL_ECHOLNPAIR("\nStack Pointer : ", hex_address(sp));
// Always init on the first invocation of M100
static bool m100_not_initialized = true;
if (m100_not_initialized || code_seen('I')) {
m100_not_initialized = false;
init_free_memory(ptr, sp - ptr);
}
#if ENABLED(M100_FREE_MEMORY_DUMPER)
if (code_seen('D'))
return dump_free_memory(ptr, sp);
#endif
if (code_seen('F'))
return free_memory_pool_report(ptr, sp - ptr);
#if ENABLED(M100_FREE_MEMORY_CORRUPTOR)
if (code_seen('C'))
return corrupt_free_memory(ptr, code_value_int());
#endif
}
int check_for_free_memory_corruption(const char * const title) {
SERIAL_ECHO(title);
char *ptr = END_OF_HEAP(), *sp = top_of_stack();
int n = sp - ptr;
SERIAL_ECHOPAIR("\nfmc() n=", n);
SERIAL_ECHOPAIR("\n&__brkval: ", hex_address(&__brkval));
SERIAL_ECHOPAIR("=", hex_address(__brkval));
SERIAL_ECHOPAIR("\n__bss_end: ", hex_address(&__bss_end));
SERIAL_ECHOPAIR(" sp=", hex_address(sp));
if (sp < ptr) {
SERIAL_ECHOPGM(" sp < Heap ");
// SET_INPUT_PULLUP(63); // if the developer has a switch wired up to their controller board
// safe_delay(5); // this code can be enabled to pause the display as soon as the
// while ( READ(63)) // malfunction is detected. It is currently defaulting to a switch
// idle(); // being on pin-63 which is unassigend and available on most controller
// safe_delay(20); // boards.
// while ( !READ(63))
// idle();
safe_delay(20);
#ifdef M100_FREE_MEMORY_DUMPER
M100_dump_routine(" Memory corruption detected with sp<Heap\n", (char*)0x1B80, 0x21FF);
#endif
}
// Scan through the range looking for the biggest block of 0xE5's we can find
int block_cnt = 0;
for (int i = 0; i < n; i++) {
if (ptr[i] == TEST_BYTE) {
int16_t j = count_test_bytes(ptr + i);
if (j > 8) {
// SERIAL_ECHOPAIR("Found ", j);
// SERIAL_ECHOLNPAIR(" bytes free at ", hex_address(ptr + i));
i += j;
block_cnt++;
SERIAL_ECHOPAIR(" (", block_cnt);
SERIAL_ECHOPAIR(") found=", j);
SERIAL_ECHOPGM(" ");
}
}
}
SERIAL_ECHOPAIR(" block_found=", block_cnt);
if (block_cnt != 1 || __brkval != 0x0000)
SERIAL_ECHOLNPGM("\nMemory Corruption detected in free memory area.");
if (block_cnt == 0) // Make sure the special case of no free blocks shows up as an
block_cnt = -1; // error to the calling code!
SERIAL_ECHOPGM(" return=");
if (block_cnt == 1) {
SERIAL_CHAR('0'); // if the block_cnt is 1, nothing has broken up the free memory
SERIAL_EOL; // area and it is appropriate to say 'no corruption'.
return 0;
}
SERIAL_ECHOLNPGM("true");
return block_cnt;
}
#endif // M100_FREE_MEMORY_WATCHER

View File

@@ -247,16 +247,6 @@ F_CPU ?= 16000000
# Libraries, the "hardware variant" are for boards # Libraries, the "hardware variant" are for boards
# that derives from that, and their source are present in # that derives from that, and their source are present in
# the main Marlin source directory # the main Marlin source directory
ifeq ($(HARDWARE_VARIANT), $(filter $(HARDWARE_VARIANT),arduino Sanguino))
HARDWARE_DIR = $(ARDUINO_INSTALL_DIR)/hardware
else
ifeq ($(shell [ $(ARDUINO_VERSION) -ge 100 ] && echo true), true)
HARDWARE_DIR = ../ArduinoAddons/Arduino_1.x.x
else
HARDWARE_DIR = ../ArduinoAddons/Arduino_0.xx
endif
endif
HARDWARE_SRC= $(HARDWARE_DIR)/arduino/avr/cores/arduino
TARGET = $(notdir $(CURDIR)) TARGET = $(notdir $(CURDIR))
@@ -266,12 +256,10 @@ TARGET = $(notdir $(CURDIR))
VPATH = . VPATH = .
VPATH += $(BUILD_DIR) VPATH += $(BUILD_DIR)
VPATH += $(HARDWARE_SRC) VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/cores/arduino
ifeq ($(HARDWARE_VARIANT), $(filter $(HARDWARE_VARIANT),arduino Teensy Sanguino))
VPATH += $(HARDWARE_DIR)/marlin/avr/libraries/LiquidCrystal/src VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
VPATH += $(HARDWARE_DIR)/marlin/avr/libraries/SPI VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
VPATH += $(HARDWARE_DIR)/arduino/avr/libraries/SPI
VPATH += $(HARDWARE_DIR)/arduino/avr/libraries/SPI/src
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/LiquidCrystal/src VPATH += $(ARDUINO_INSTALL_DIR)/libraries/LiquidCrystal/src
ifeq ($(LIQUID_TWI2), 1) ifeq ($(LIQUID_TWI2), 1)
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire
@@ -282,22 +270,9 @@ ifeq ($(WIRE), 1)
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire
VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire/utility VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire/utility
endif endif
else
VPATH += $(HARDWARE_DIR)/libraries/LiquidCrystal
VPATH += $(HARDWARE_DIR)/libraries/SPI
ifeq ($(LIQUID_TWI2), 1)
VPATH += $(HARDWARE_DIR)/libraries/Wire
VPATH += $(HARDWARE_DIR)/libraries/Wire/utility
VPATH += $(HARDWARE_DIR)/libraries/LiquidTWI2
endif
ifeq ($(WIRE), 1)
VPATH += $(HARDWARE_DIR)/libraries/Wire
VPATH += $(HARDWARE_DIR)/libraries/Wire/utility
endif
endif
ifeq ($(HARDWARE_VARIANT), arduino) ifeq ($(HARDWARE_VARIANT), arduino)
HARDWARE_SUB_VARIANT ?= mega HARDWARE_SUB_VARIANT ?= mega
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/variants/$(HARDWARE_SUB_VARIANT)
VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/variants/$(HARDWARE_SUB_VARIANT) VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/variants/$(HARDWARE_SUB_VARIANT)
else else
ifeq ($(HARDWARE_VARIANT), Sanguino) ifeq ($(HARDWARE_VARIANT), Sanguino)
@@ -320,7 +295,8 @@ CXXSRC = WMath.cpp WString.cpp Print.cpp Marlin_main.cpp \
SdFile.cpp SdVolume.cpp planner.cpp stepper.cpp \ SdFile.cpp SdVolume.cpp planner.cpp stepper.cpp \
temperature.cpp cardreader.cpp configuration_store.cpp \ temperature.cpp cardreader.cpp configuration_store.cpp \
watchdog.cpp SPI.cpp servo.cpp Tone.cpp ultralcd.cpp digipot_mcp4451.cpp \ watchdog.cpp SPI.cpp servo.cpp Tone.cpp ultralcd.cpp digipot_mcp4451.cpp \
dac_mcp4728.cpp vector_3.cpp qr_solve.cpp endstops.cpp stopwatch.cpp utility.cpp dac_mcp4728.cpp vector_3.cpp qr_solve.cpp endstops.cpp stopwatch.cpp utility.cpp \
printcounter.cpp nozzle.cpp serial.cpp
ifeq ($(LIQUID_TWI2), 0) ifeq ($(LIQUID_TWI2), 0)
CXXSRC += LiquidCrystal.cpp CXXSRC += LiquidCrystal.cpp
else else
@@ -393,7 +369,7 @@ ifneq ($(HARDWARE_MOTHERBOARD),)
CTUNING += -DMOTHERBOARD=${HARDWARE_MOTHERBOARD} CTUNING += -DMOTHERBOARD=${HARDWARE_MOTHERBOARD}
endif endif
#CEXTRA = -Wa,-adhlns=$(<:.c=.lst) #CEXTRA = -Wa,-adhlns=$(<:.c=.lst)
CEXTRA = -fno-use-cxa-atexit CEXTRA = -fno-use-cxa-atexit -fno-threadsafe-statics
CFLAGS := $(CDEBUG) $(CDEFS) $(CINCS) -O$(OPT) $(CWARN) $(CEXTRA) $(CTUNING) $(CSTANDARD) CFLAGS := $(CDEBUG) $(CDEFS) $(CINCS) -O$(OPT) $(CWARN) $(CEXTRA) $(CTUNING) $(CSTANDARD)
CXXFLAGS := $(CDEFS) $(CINCS) -O$(OPT) -Wall $(CEXTRA) $(CTUNING) $(CXXSTANDARD) CXXFLAGS := $(CDEFS) $(CINCS) -O$(OPT) -Wall $(CEXTRA) $(CTUNING) $(CXXSTANDARD)

View File

@@ -39,20 +39,7 @@
#include "types.h" #include "types.h"
#include "fastio.h" #include "fastio.h"
#include "utility.h" #include "utility.h"
#include "serial.h"
#ifdef USBCON
#include "HardwareSerial.h"
#if ENABLED(BLUETOOTH)
#define MYSERIAL bluetoothSerial
#else
#define MYSERIAL Serial
#endif // BLUETOOTH
#else
#include "MarlinSerial.h"
#define MYSERIAL customizedSerial
#endif
#include "WString.h"
#if ENABLED(PRINTCOUNTER) #if ENABLED(PRINTCOUNTER)
#include "printcounter.h" #include "printcounter.h"
@@ -60,52 +47,6 @@
#include "stopwatch.h" #include "stopwatch.h"
#endif #endif
extern const char echomagic[] PROGMEM;
extern const char errormagic[] PROGMEM;
#define SERIAL_CHAR(x) (MYSERIAL.write(x))
#define SERIAL_EOL SERIAL_CHAR('\n')
#define SERIAL_PROTOCOLCHAR(x) SERIAL_CHAR(x)
#define SERIAL_PROTOCOL(x) (MYSERIAL.print(x))
#define SERIAL_PROTOCOL_F(x,y) (MYSERIAL.print(x,y))
#define SERIAL_PROTOCOLPGM(x) (serialprintPGM(PSTR(x)))
#define SERIAL_PROTOCOLLN(x) do{ MYSERIAL.print(x); SERIAL_EOL; }while(0)
#define SERIAL_PROTOCOLLNPGM(x) (serialprintPGM(PSTR(x "\n")))
#define SERIAL_PROTOCOLPAIR(name, value) (serial_echopair_P(PSTR(name),(value)))
#define SERIAL_PROTOCOLLNPAIR(name, value) do{ SERIAL_PROTOCOLPAIR(name, value); SERIAL_EOL; }while(0)
#define SERIAL_ECHO_START (serialprintPGM(echomagic))
#define SERIAL_ECHO(x) SERIAL_PROTOCOL(x)
#define SERIAL_ECHOPGM(x) SERIAL_PROTOCOLPGM(x)
#define SERIAL_ECHOLN(x) SERIAL_PROTOCOLLN(x)
#define SERIAL_ECHOLNPGM(x) SERIAL_PROTOCOLLNPGM(x)
#define SERIAL_ECHOPAIR(name,value) SERIAL_PROTOCOLPAIR(name, value)
#define SERIAL_ECHOLNPAIR(name, value) SERIAL_PROTOCOLLNPAIR(name, value)
#define SERIAL_ERROR_START (serialprintPGM(errormagic))
#define SERIAL_ERROR(x) SERIAL_PROTOCOL(x)
#define SERIAL_ERRORPGM(x) SERIAL_PROTOCOLPGM(x)
#define SERIAL_ERRORLN(x) SERIAL_PROTOCOLLN(x)
#define SERIAL_ERRORLNPGM(x) SERIAL_PROTOCOLLNPGM(x)
void serial_echopair_P(const char* s_P, const char *v);
void serial_echopair_P(const char* s_P, char v);
void serial_echopair_P(const char* s_P, int v);
void serial_echopair_P(const char* s_P, long v);
void serial_echopair_P(const char* s_P, float v);
void serial_echopair_P(const char* s_P, double v);
void serial_echopair_P(const char* s_P, unsigned long v);
FORCE_INLINE void serial_echopair_P(const char* s_P, uint8_t v) { serial_echopair_P(s_P, (int)v); }
FORCE_INLINE void serial_echopair_P(const char* s_P, uint16_t v) { serial_echopair_P(s_P, (int)v); }
FORCE_INLINE void serial_echopair_P(const char* s_P, bool v) { serial_echopair_P(s_P, (int)v); }
FORCE_INLINE void serial_echopair_P(const char* s_P, void *v) { serial_echopair_P(s_P, (unsigned long)v); }
// Things to write to serial from Program memory. Saves 400 to 2k of RAM.
FORCE_INLINE void serialprintPGM(const char* str) {
while (char ch = pgm_read_byte(str++)) MYSERIAL.write(ch);
}
void idle( void idle(
#if ENABLED(FILAMENT_CHANGE_FEATURE) #if ENABLED(FILAMENT_CHANGE_FEATURE)
bool no_stepper_sleep = false // pass true to keep steppers from disabling on timeout bool no_stepper_sleep = false // pass true to keep steppers from disabling on timeout
@@ -119,36 +60,36 @@ void manage_inactivity(bool ignore_stepper_queue = false);
#endif #endif
#if HAS_X2_ENABLE #if HAS_X2_ENABLE
#define enable_x() do{ X_ENABLE_WRITE( X_ENABLE_ON); X2_ENABLE_WRITE( X_ENABLE_ON); }while(0) #define enable_X() do{ X_ENABLE_WRITE( X_ENABLE_ON); X2_ENABLE_WRITE( X_ENABLE_ON); }while(0)
#define disable_x() do{ X_ENABLE_WRITE(!X_ENABLE_ON); X2_ENABLE_WRITE(!X_ENABLE_ON); axis_known_position[X_AXIS] = false; }while(0) #define disable_X() do{ X_ENABLE_WRITE(!X_ENABLE_ON); X2_ENABLE_WRITE(!X_ENABLE_ON); axis_known_position[X_AXIS] = false; }while(0)
#elif HAS_X_ENABLE #elif HAS_X_ENABLE
#define enable_x() X_ENABLE_WRITE( X_ENABLE_ON) #define enable_X() X_ENABLE_WRITE( X_ENABLE_ON)
#define disable_x() do{ X_ENABLE_WRITE(!X_ENABLE_ON); axis_known_position[X_AXIS] = false; }while(0) #define disable_X() do{ X_ENABLE_WRITE(!X_ENABLE_ON); axis_known_position[X_AXIS] = false; }while(0)
#else #else
#define enable_x() NOOP #define enable_X() NOOP
#define disable_x() NOOP #define disable_X() NOOP
#endif #endif
#if HAS_Y2_ENABLE #if HAS_Y2_ENABLE
#define enable_y() do{ Y_ENABLE_WRITE( Y_ENABLE_ON); Y2_ENABLE_WRITE(Y_ENABLE_ON); }while(0) #define enable_Y() do{ Y_ENABLE_WRITE( Y_ENABLE_ON); Y2_ENABLE_WRITE(Y_ENABLE_ON); }while(0)
#define disable_y() do{ Y_ENABLE_WRITE(!Y_ENABLE_ON); Y2_ENABLE_WRITE(!Y_ENABLE_ON); axis_known_position[Y_AXIS] = false; }while(0) #define disable_Y() do{ Y_ENABLE_WRITE(!Y_ENABLE_ON); Y2_ENABLE_WRITE(!Y_ENABLE_ON); axis_known_position[Y_AXIS] = false; }while(0)
#elif HAS_Y_ENABLE #elif HAS_Y_ENABLE
#define enable_y() Y_ENABLE_WRITE( Y_ENABLE_ON) #define enable_Y() Y_ENABLE_WRITE( Y_ENABLE_ON)
#define disable_y() do{ Y_ENABLE_WRITE(!Y_ENABLE_ON); axis_known_position[Y_AXIS] = false; }while(0) #define disable_Y() do{ Y_ENABLE_WRITE(!Y_ENABLE_ON); axis_known_position[Y_AXIS] = false; }while(0)
#else #else
#define enable_y() NOOP #define enable_Y() NOOP
#define disable_y() NOOP #define disable_Y() NOOP
#endif #endif
#if HAS_Z2_ENABLE #if HAS_Z2_ENABLE
#define enable_z() do{ Z_ENABLE_WRITE( Z_ENABLE_ON); Z2_ENABLE_WRITE(Z_ENABLE_ON); }while(0) #define enable_Z() do{ Z_ENABLE_WRITE( Z_ENABLE_ON); Z2_ENABLE_WRITE(Z_ENABLE_ON); }while(0)
#define disable_z() do{ Z_ENABLE_WRITE(!Z_ENABLE_ON); Z2_ENABLE_WRITE(!Z_ENABLE_ON); axis_known_position[Z_AXIS] = false; }while(0) #define disable_Z() do{ Z_ENABLE_WRITE(!Z_ENABLE_ON); Z2_ENABLE_WRITE(!Z_ENABLE_ON); axis_known_position[Z_AXIS] = false; }while(0)
#elif HAS_Z_ENABLE #elif HAS_Z_ENABLE
#define enable_z() Z_ENABLE_WRITE( Z_ENABLE_ON) #define enable_Z() Z_ENABLE_WRITE( Z_ENABLE_ON)
#define disable_z() do{ Z_ENABLE_WRITE(!Z_ENABLE_ON); axis_known_position[Z_AXIS] = false; }while(0) #define disable_Z() do{ Z_ENABLE_WRITE(!Z_ENABLE_ON); axis_known_position[Z_AXIS] = false; }while(0)
#else #else
#define enable_z() NOOP #define enable_Z() NOOP
#define disable_z() NOOP #define disable_Z() NOOP
#endif #endif
#if ENABLED(MIXING_EXTRUDER) #if ENABLED(MIXING_EXTRUDER)
@@ -157,54 +98,64 @@ void manage_inactivity(bool ignore_stepper_queue = false);
* Mixing steppers synchronize their enable (and direction) together * Mixing steppers synchronize their enable (and direction) together
*/ */
#if MIXING_STEPPERS > 3 #if MIXING_STEPPERS > 3
#define enable_e0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); E2_ENABLE_WRITE( E_ENABLE_ON); E3_ENABLE_WRITE( E_ENABLE_ON); } #define enable_E0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); E2_ENABLE_WRITE( E_ENABLE_ON); E3_ENABLE_WRITE( E_ENABLE_ON); }
#define disable_e0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); E2_ENABLE_WRITE(!E_ENABLE_ON); E3_ENABLE_WRITE(!E_ENABLE_ON); } #define disable_E0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); E2_ENABLE_WRITE(!E_ENABLE_ON); E3_ENABLE_WRITE(!E_ENABLE_ON); }
#elif MIXING_STEPPERS > 2 #elif MIXING_STEPPERS > 2
#define enable_e0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); E2_ENABLE_WRITE( E_ENABLE_ON); } #define enable_E0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); E2_ENABLE_WRITE( E_ENABLE_ON); }
#define disable_e0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); E2_ENABLE_WRITE(!E_ENABLE_ON); } #define disable_E0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); E2_ENABLE_WRITE(!E_ENABLE_ON); }
#else #else
#define enable_e0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); } #define enable_E0() { E0_ENABLE_WRITE( E_ENABLE_ON); E1_ENABLE_WRITE( E_ENABLE_ON); }
#define disable_e0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); } #define disable_E0() { E0_ENABLE_WRITE(!E_ENABLE_ON); E1_ENABLE_WRITE(!E_ENABLE_ON); }
#endif #endif
#define enable_e1() NOOP #define enable_E1() NOOP
#define disable_e1() NOOP #define disable_E1() NOOP
#define enable_e2() NOOP #define enable_E2() NOOP
#define disable_e2() NOOP #define disable_E2() NOOP
#define enable_e3() NOOP #define enable_E3() NOOP
#define disable_e3() NOOP #define disable_E3() NOOP
#define enable_E4() NOOP
#define disable_E4() NOOP
#else // !MIXING_EXTRUDER #else // !MIXING_EXTRUDER
#if HAS_E0_ENABLE #if HAS_E0_ENABLE
#define enable_e0() E0_ENABLE_WRITE( E_ENABLE_ON) #define enable_E0() E0_ENABLE_WRITE( E_ENABLE_ON)
#define disable_e0() E0_ENABLE_WRITE(!E_ENABLE_ON) #define disable_E0() E0_ENABLE_WRITE(!E_ENABLE_ON)
#else #else
#define enable_e0() NOOP #define enable_E0() NOOP
#define disable_e0() NOOP #define disable_E0() NOOP
#endif #endif
#if E_STEPPERS > 1 && HAS_E1_ENABLE #if E_STEPPERS > 1 && HAS_E1_ENABLE
#define enable_e1() E1_ENABLE_WRITE( E_ENABLE_ON) #define enable_E1() E1_ENABLE_WRITE( E_ENABLE_ON)
#define disable_e1() E1_ENABLE_WRITE(!E_ENABLE_ON) #define disable_E1() E1_ENABLE_WRITE(!E_ENABLE_ON)
#else #else
#define enable_e1() NOOP #define enable_E1() NOOP
#define disable_e1() NOOP #define disable_E1() NOOP
#endif #endif
#if E_STEPPERS > 2 && HAS_E2_ENABLE #if E_STEPPERS > 2 && HAS_E2_ENABLE
#define enable_e2() E2_ENABLE_WRITE( E_ENABLE_ON) #define enable_E2() E2_ENABLE_WRITE( E_ENABLE_ON)
#define disable_e2() E2_ENABLE_WRITE(!E_ENABLE_ON) #define disable_E2() E2_ENABLE_WRITE(!E_ENABLE_ON)
#else #else
#define enable_e2() NOOP #define enable_E2() NOOP
#define disable_e2() NOOP #define disable_E2() NOOP
#endif #endif
#if E_STEPPERS > 3 && HAS_E3_ENABLE #if E_STEPPERS > 3 && HAS_E3_ENABLE
#define enable_e3() E3_ENABLE_WRITE( E_ENABLE_ON) #define enable_E3() E3_ENABLE_WRITE( E_ENABLE_ON)
#define disable_e3() E3_ENABLE_WRITE(!E_ENABLE_ON) #define disable_E3() E3_ENABLE_WRITE(!E_ENABLE_ON)
#else #else
#define enable_e3() NOOP #define enable_E3() NOOP
#define disable_e3() NOOP #define disable_E3() NOOP
#endif
#if E_STEPPERS > 4 && HAS_E4_ENABLE
#define enable_E4() E4_ENABLE_WRITE( E_ENABLE_ON)
#define disable_E4() E4_ENABLE_WRITE(!E_ENABLE_ON)
#else
#define enable_E4() NOOP
#define disable_E4() NOOP
#endif #endif
#endif // !MIXING_EXTRUDER #endif // !MIXING_EXTRUDER
@@ -220,6 +171,7 @@ void manage_inactivity(bool ignore_stepper_queue = false);
#define _AXIS(AXIS) AXIS ##_AXIS #define _AXIS(AXIS) AXIS ##_AXIS
void enable_all_steppers(); void enable_all_steppers();
void disable_e_steppers();
void disable_all_steppers(); void disable_all_steppers();
void FlushSerialRequestResend(); void FlushSerialRequestResend();
@@ -240,9 +192,8 @@ extern bool Running;
inline bool IsRunning() { return Running; } inline bool IsRunning() { return Running; }
inline bool IsStopped() { return !Running; } inline bool IsStopped() { return !Running; }
bool enqueue_and_echo_command(const char* cmd, bool say_ok=false); //put a single ASCII command at the end of the current buffer or return false when it is full bool enqueue_and_echo_command(const char* cmd, bool say_ok=false); // Add a single command to the end of the buffer. Return false on failure.
void enqueue_and_echo_command_now(const char* cmd); // enqueue now, only return when the command has been enqueued void enqueue_and_echo_commands_P(const char * const cmd); // Set one or more commands to be prioritized over the next Serial/SD command.
void enqueue_and_echo_commands_P(const char* cmd); //put one or many ASCII commands at the end of the current buffer, read from flash
void clear_command_queue(); void clear_command_queue();
extern millis_t previous_cmd_ms; extern millis_t previous_cmd_ms;
@@ -270,45 +221,87 @@ extern bool axis_known_position[XYZ]; // axis[n].is_known
extern bool axis_homed[XYZ]; // axis[n].is_homed extern bool axis_homed[XYZ]; // axis[n].is_homed
extern volatile bool wait_for_heatup; extern volatile bool wait_for_heatup;
#if ENABLED(EMERGENCY_PARSER) || ENABLED(ULTIPANEL) #if HAS_RESUME_CONTINUE
extern volatile bool wait_for_user; extern volatile bool wait_for_user;
#endif #endif
extern float current_position[NUM_AXIS]; extern float current_position[NUM_AXIS];
extern float position_shift[XYZ];
extern float home_offset[XYZ];
// Workspace offsets
#if HAS_WORKSPACE_OFFSET
#if HAS_HOME_OFFSET
extern float home_offset[XYZ];
#endif
#if HAS_POSITION_SHIFT
extern float position_shift[XYZ];
#endif
#endif
#if HAS_HOME_OFFSET && HAS_POSITION_SHIFT
extern float workspace_offset[XYZ];
#define WORKSPACE_OFFSET(AXIS) workspace_offset[AXIS]
#elif HAS_HOME_OFFSET
#define WORKSPACE_OFFSET(AXIS) home_offset[AXIS]
#elif HAS_POSITION_SHIFT
#define WORKSPACE_OFFSET(AXIS) position_shift[AXIS]
#else
#define WORKSPACE_OFFSET(AXIS) 0
#endif
#define LOGICAL_POSITION(POS, AXIS) ((POS) + WORKSPACE_OFFSET(AXIS))
#define RAW_POSITION(POS, AXIS) ((POS) - WORKSPACE_OFFSET(AXIS))
#if HAS_POSITION_SHIFT || DISABLED(DELTA)
#define LOGICAL_X_POSITION(POS) LOGICAL_POSITION(POS, X_AXIS)
#define LOGICAL_Y_POSITION(POS) LOGICAL_POSITION(POS, Y_AXIS)
#define RAW_X_POSITION(POS) RAW_POSITION(POS, X_AXIS)
#define RAW_Y_POSITION(POS) RAW_POSITION(POS, Y_AXIS)
#else
#define LOGICAL_X_POSITION(POS) (POS)
#define LOGICAL_Y_POSITION(POS) (POS)
#define RAW_X_POSITION(POS) (POS)
#define RAW_Y_POSITION(POS) (POS)
#endif
#define LOGICAL_Z_POSITION(POS) LOGICAL_POSITION(POS, Z_AXIS)
#define RAW_Z_POSITION(POS) RAW_POSITION(POS, Z_AXIS)
#define RAW_CURRENT_POSITION(A) RAW_##A##_POSITION(current_position[A##_AXIS])
// Hotend Offsets
#if HOTENDS > 1 #if HOTENDS > 1
extern float hotend_offset[XYZ][HOTENDS]; extern float hotend_offset[XYZ][HOTENDS];
#endif #endif
// Software Endstops // Software Endstops
void update_software_endstops(AxisEnum axis); extern float soft_endstop_min[XYZ], soft_endstop_max[XYZ];
#if ENABLED(min_software_endstops) || ENABLED(max_software_endstops)
#if HAS_SOFTWARE_ENDSTOPS
extern bool soft_endstops_enabled; extern bool soft_endstops_enabled;
void clamp_to_software_endstops(float target[XYZ]); void clamp_to_software_endstops(float target[XYZ]);
#else #else
#define soft_endstops_enabled false #define soft_endstops_enabled false
#define clamp_to_software_endstops(x) NOOP #define clamp_to_software_endstops(x) NOOP
#endif #endif
extern float soft_endstop_min[XYZ];
extern float soft_endstop_max[XYZ];
#define LOGICAL_POSITION(POS, AXIS) ((POS) + home_offset[AXIS] + position_shift[AXIS]) #if HAS_WORKSPACE_OFFSET || ENABLED(DUAL_X_CARRIAGE)
#define RAW_POSITION(POS, AXIS) ((POS) - home_offset[AXIS] - position_shift[AXIS]) void update_software_endstops(const AxisEnum axis);
#define LOGICAL_X_POSITION(POS) LOGICAL_POSITION(POS, X_AXIS) #endif
#define LOGICAL_Y_POSITION(POS) LOGICAL_POSITION(POS, Y_AXIS)
#define LOGICAL_Z_POSITION(POS) LOGICAL_POSITION(POS, Z_AXIS)
#define RAW_X_POSITION(POS) RAW_POSITION(POS, X_AXIS)
#define RAW_Y_POSITION(POS) RAW_POSITION(POS, Y_AXIS)
#define RAW_Z_POSITION(POS) RAW_POSITION(POS, Z_AXIS)
#define RAW_CURRENT_POSITION(AXIS) RAW_POSITION(current_position[AXIS], AXIS)
// GCode support for external objects // GCode support for external objects
bool code_seen(char); bool code_seen(char);
int code_value_int(); int code_value_int();
float code_value_temp_abs(); int16_t code_value_temp_abs();
float code_value_temp_diff(); int16_t code_value_temp_diff();
#if ENABLED(INCH_MODE_SUPPORT)
float code_value_linear_units();
float code_value_axis_units(const AxisEnum axis);
float code_value_per_axis_unit(const AxisEnum axis);
#else
#define code_value_linear_units() code_value_float()
#define code_value_axis_units(A) code_value_float()
#define code_value_per_axis_unit(A) code_value_float()
#endif
#if IS_KINEMATIC #if IS_KINEMATIC
extern float delta[ABC]; extern float delta[ABC];
@@ -319,18 +312,34 @@ float code_value_temp_diff();
extern float endstop_adj[ABC], extern float endstop_adj[ABC],
delta_radius, delta_radius,
delta_diagonal_rod, delta_diagonal_rod,
delta_calibration_radius,
delta_segments_per_second, delta_segments_per_second,
delta_diagonal_rod_trim_tower_1, delta_tower_angle_trim[2],
delta_diagonal_rod_trim_tower_2, delta_clip_start_height;
delta_diagonal_rod_trim_tower_3;
void recalc_delta_settings(float radius, float diagonal_rod); void recalc_delta_settings(float radius, float diagonal_rod);
#elif IS_SCARA #elif IS_SCARA
void forward_kinematics_SCARA(const float &a, const float &b); void forward_kinematics_SCARA(const float &a, const float &b);
#endif #endif
#if ENABLED(AUTO_BED_LEVELING_BILINEAR) #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
extern int bilinear_grid_spacing[2]; extern int bilinear_grid_spacing[2], bilinear_start[2];
float bilinear_z_offset(float logical[XYZ]); extern float bilinear_grid_factor[2],
z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
float bilinear_z_offset(const float logical[XYZ]);
void set_bed_leveling_enabled(bool enable=true);
#endif
#if ENABLED(AUTO_BED_LEVELING_UBL)
typedef struct { double A, B, D; } linear_fit;
linear_fit* lsf_linear_fit(double x[], double y[], double z[], const int);
#endif
#if HAS_LEVELING
void reset_bed_level();
#endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
void set_z_fade_height(const float zfh);
#endif #endif
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
@@ -339,14 +348,24 @@ float code_value_temp_diff();
#if HAS_BED_PROBE #if HAS_BED_PROBE
extern float zprobe_zoffset; extern float zprobe_zoffset;
void refresh_zprobe_zoffset(const bool no_babystep=false);
#define DEPLOY_PROBE() set_probe_deployed(true)
#define STOW_PROBE() set_probe_deployed(false)
#endif #endif
#if ENABLED(HOST_KEEPALIVE_FEATURE) #if ENABLED(HOST_KEEPALIVE_FEATURE)
extern uint8_t host_keepalive_interval; extern MarlinBusyState busy_state;
#define KEEPALIVE_STATE(n) do{ busy_state = n; }while(0)
#else
#define KEEPALIVE_STATE(n) NOOP
#endif #endif
#if FAN_COUNT > 0 #if FAN_COUNT > 0
extern int fanSpeeds[FAN_COUNT]; extern int16_t fanSpeeds[FAN_COUNT];
#if ENABLED(PROBING_FANS_OFF)
extern bool fans_paused;
extern int16_t paused_fanSpeeds[FAN_COUNT];
#endif
#endif #endif
#if ENABLED(BARICUDA) #if ENABLED(BARICUDA)
@@ -406,4 +425,8 @@ void do_blocking_move_to_x(const float &x, const float &fr_mm_s=0.0);
void do_blocking_move_to_z(const float &z, const float &fr_mm_s=0.0); void do_blocking_move_to_z(const float &z, const float &fr_mm_s=0.0);
void do_blocking_move_to_xy(const float &x, const float &y, const float &fr_mm_s=0.0); void do_blocking_move_to_xy(const float &x, const float &y, const float &fr_mm_s=0.0);
#if ENABLED(Z_PROBE_ALLEN_KEY) || ENABLED(Z_PROBE_SLED) || HAS_PROBING_PROCEDURE || HOTENDS > 1 || ENABLED(NOZZLE_CLEAN_FEATURE) || ENABLED(NOZZLE_PARK_FEATURE)
bool axis_unhomed_error(const bool x, const bool y, const bool z);
#endif
#endif //MARLIN_H #endif //MARLIN_H

View File

@@ -26,14 +26,8 @@
* This firmware is a mashup between Sprinter and grbl. * This firmware is a mashup between Sprinter and grbl.
* - https://github.com/kliment/Sprinter * - https://github.com/kliment/Sprinter
* - https://github.com/simen/grbl/tree * - https://github.com/simen/grbl/tree
*
* It has preliminary support for Matthew Roberts advance algorithm
* - http://reprap.org/pipermail/reprap-dev/2011-May/003323.html
*/ */
/* All the implementation is done in *.cpp files to get better compatibility with avr-gcc without the Arduino IDE */
/* Use this file to help the Arduino IDE find which Arduino libraries are needed and to keep documentation on GCode */
#include "MarlinConfig.h" #include "MarlinConfig.h"
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
@@ -67,9 +61,9 @@
#include <TMC26XStepper.h> #include <TMC26XStepper.h>
#endif #endif
#if ENABLED(HAVE_TMC2130DRIVER) #if ENABLED(HAVE_TMC2130)
#include <SPI.h> #include <SPI.h>
#include <Trinamic_TMC2130.h> #include <TMC2130Stepper.h>
#endif #endif
#if ENABLED(HAVE_L6470DRIVER) #if ENABLED(HAVE_L6470DRIVER)

View File

@@ -28,500 +28,489 @@
* Modified 28 September 2010 by Mark Sproul * Modified 28 September 2010 by Mark Sproul
* Modified 14 February 2016 by Andreas Hardtung (added tx buffer) * Modified 14 February 2016 by Andreas Hardtung (added tx buffer)
*/ */
#include "MarlinSerial.h"
#include "stepper.h" #include "MarlinSerial.h"
#include "Marlin.h" #include "Marlin.h"
#ifndef USBCON // Disable HardwareSerial.cpp to support chips without a UART (Attiny, etc.)
// this next line disables the entire HardwareSerial.cpp,
// this is so I can support Attiny series and any other chip without a UART
#if defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H)
#if UART_PRESENT(SERIAL_PORT) #if !defined(USBCON) && (defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H))
ring_buffer_r rx_buffer = { { 0 }, 0, 0 };
#if TX_BUFFER_SIZE > 0 #if UART_PRESENT(SERIAL_PORT)
ring_buffer_t tx_buffer = { { 0 }, 0, 0 }; ring_buffer_r rx_buffer = { { 0 }, 0, 0 };
static bool _written; #if TX_BUFFER_SIZE > 0
ring_buffer_t tx_buffer = { { 0 }, 0, 0 };
static bool _written;
#endif
#endif #endif
#endif
FORCE_INLINE void store_char(unsigned char c) {
CRITICAL_SECTION_START;
uint8_t h = rx_buffer.head;
uint8_t i = (uint8_t)(h + 1) & (RX_BUFFER_SIZE - 1);
// if we should be storing the received character into the location
// just before the tail (meaning that the head would advance to the
// current location of the tail), we're about to overflow the buffer
// and so we don't write the character or advance the head.
if (i != rx_buffer.tail) {
rx_buffer.buffer[h] = c;
rx_buffer.head = i;
}
CRITICAL_SECTION_END;
#if ENABLED(EMERGENCY_PARSER) #if ENABLED(EMERGENCY_PARSER)
emergency_parser(c);
#endif
}
#if TX_BUFFER_SIZE > 0 #include "stepper.h"
#include "language.h"
FORCE_INLINE void _tx_udr_empty_irq(void) { // Currently looking for: M108, M112, M410
// If interrupts are enabled, there must be more data in the output // If you alter the parser please don't forget to update the capabilities in Conditionals_post.h
// buffer. Send the next byte
uint8_t t = tx_buffer.tail;
uint8_t c = tx_buffer.buffer[t];
tx_buffer.tail = (t + 1) & (TX_BUFFER_SIZE - 1);
M_UDRx = c; FORCE_INLINE void emergency_parser(const unsigned char c) {
// clear the TXC bit -- "can be cleared by writing a one to its bit static e_parser_state state = state_RESET;
// location". This makes sure flush() won't return until the bytes
// actually got written
SBI(M_UCSRxA, M_TXCx);
if (tx_buffer.head == tx_buffer.tail) { switch (state) {
// Buffer empty, so disable interrupts case state_RESET:
CBI(M_UCSRxB, M_UDRIEx); switch (c) {
} case ' ': break;
} case 'N': state = state_N; break;
case 'M': state = state_M; break;
default: state = state_IGNORE;
}
break;
#if defined(M_USARTx_UDRE_vect) case state_N:
ISR(M_USARTx_UDRE_vect) { switch (c) {
_tx_udr_empty_irq(); case '0': case '1': case '2':
} case '3': case '4': case '5':
#endif case '6': case '7': case '8':
case '9': case '-': case ' ': break;
case 'M': state = state_M; break;
default: state = state_IGNORE;
}
break;
#endif // TX_BUFFER_SIZE case state_M:
switch (c) {
case ' ': break;
case '1': state = state_M1; break;
case '4': state = state_M4; break;
default: state = state_IGNORE;
}
break;
#if defined(M_USARTx_RX_vect) case state_M1:
ISR(M_USARTx_RX_vect) { switch (c) {
unsigned char c = M_UDRx; case '0': state = state_M10; break;
store_char(c); case '1': state = state_M11; break;
} default: state = state_IGNORE;
#endif }
break;
// Constructors //////////////////////////////////////////////////////////////// case state_M10:
state = (c == '8') ? state_M108 : state_IGNORE;
break;
MarlinSerial::MarlinSerial() { } case state_M11:
state = (c == '2') ? state_M112 : state_IGNORE;
break;
// Public Methods ////////////////////////////////////////////////////////////// case state_M4:
state = (c == '1') ? state_M41 : state_IGNORE;
break;
void MarlinSerial::begin(long baud) { case state_M41:
uint16_t baud_setting; state = (c == '0') ? state_M410 : state_IGNORE;
bool useU2X = true; break;
#if F_CPU == 16000000UL && SERIAL_PORT == 0 case state_IGNORE:
// hard-coded exception for compatibility with the bootloader shipped if (c == '\n') state = state_RESET;
// with the Duemilanove and previous boards and the firmware on the 8U2 break;
// on the Uno and Mega 2560.
if (baud == 57600) {
useU2X = false;
}
#endif
if (useU2X) { default:
M_UCSRxA = _BV(M_U2Xx); if (c == '\n') {
baud_setting = (F_CPU / 4 / baud - 1) / 2; switch (state) {
} case state_M108:
else { wait_for_user = wait_for_heatup = false;
M_UCSRxA = 0; break;
baud_setting = (F_CPU / 8 / baud - 1) / 2; case state_M112:
} kill(PSTR(MSG_KILLED));
break;
// assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register) case state_M410:
M_UBRRxH = baud_setting >> 8; quickstop_stepper();
M_UBRRxL = baud_setting; break;
default:
SBI(M_UCSRxB, M_RXENx); break;
SBI(M_UCSRxB, M_TXENx); }
SBI(M_UCSRxB, M_RXCIEx); state = state_RESET;
#if TX_BUFFER_SIZE > 0 }
CBI(M_UCSRxB, M_UDRIEx);
_written = false;
#endif
}
void MarlinSerial::end() {
CBI(M_UCSRxB, M_RXENx);
CBI(M_UCSRxB, M_TXENx);
CBI(M_UCSRxB, M_RXCIEx);
CBI(M_UCSRxB, M_UDRIEx);
}
void MarlinSerial::checkRx(void) {
if (TEST(M_UCSRxA, M_RXCx)) {
uint8_t c = M_UDRx;
store_char(c);
}
}
int MarlinSerial::peek(void) {
CRITICAL_SECTION_START;
int v = rx_buffer.head == rx_buffer.tail ? -1 : rx_buffer.buffer[rx_buffer.tail];
CRITICAL_SECTION_END;
return v;
}
int MarlinSerial::read(void) {
int v;
CRITICAL_SECTION_START;
uint8_t t = rx_buffer.tail;
if (rx_buffer.head == t) {
v = -1;
}
else {
v = rx_buffer.buffer[t];
rx_buffer.tail = (uint8_t)(t + 1) & (RX_BUFFER_SIZE - 1);
}
CRITICAL_SECTION_END;
return v;
}
uint8_t MarlinSerial::available(void) {
CRITICAL_SECTION_START;
uint8_t h = rx_buffer.head,
t = rx_buffer.tail;
CRITICAL_SECTION_END;
return (uint8_t)(RX_BUFFER_SIZE + h - t) & (RX_BUFFER_SIZE - 1);
}
void MarlinSerial::flush(void) {
// RX
// don't reverse this or there may be problems if the RX interrupt
// occurs after reading the value of rx_buffer_head but before writing
// the value to rx_buffer_tail; the previous value of rx_buffer_head
// may be written to rx_buffer_tail, making it appear as if the buffer
// were full, not empty.
CRITICAL_SECTION_START;
rx_buffer.head = rx_buffer.tail;
CRITICAL_SECTION_END;
}
#if TX_BUFFER_SIZE > 0
uint8_t MarlinSerial::availableForWrite(void) {
CRITICAL_SECTION_START;
uint8_t h = tx_buffer.head;
uint8_t t = tx_buffer.tail;
CRITICAL_SECTION_END;
return (uint8_t)(TX_BUFFER_SIZE + h - t) & (TX_BUFFER_SIZE - 1);
}
void MarlinSerial::write(uint8_t c) {
_written = true;
CRITICAL_SECTION_START;
bool emty = (tx_buffer.head == tx_buffer.tail);
CRITICAL_SECTION_END;
// If the buffer and the data register is empty, just write the byte
// to the data register and be done. This shortcut helps
// significantly improve the effective datarate at high (>
// 500kbit/s) bitrates, where interrupt overhead becomes a slowdown.
if (emty && TEST(M_UCSRxA, M_UDREx)) {
CRITICAL_SECTION_START;
M_UDRx = c;
SBI(M_UCSRxA, M_TXCx);
CRITICAL_SECTION_END;
return;
}
uint8_t i = (tx_buffer.head + 1) & (TX_BUFFER_SIZE - 1);
// If the output buffer is full, there's nothing for it other than to
// wait for the interrupt handler to empty it a bit
while (i == tx_buffer.tail) {
if (!TEST(SREG, SREG_I)) {
// Interrupts are disabled, so we'll have to poll the data
// register empty flag ourselves. If it is set, pretend an
// interrupt has happened and call the handler to free up
// space for us.
if (TEST(M_UCSRxA, M_UDREx))
_tx_udr_empty_irq();
} else {
// nop, the interrupt handler will free up space for us
} }
} }
tx_buffer.buffer[tx_buffer.head] = c; #endif // EMERGENCY_PARSER
{ CRITICAL_SECTION_START;
tx_buffer.head = i; FORCE_INLINE void store_char(unsigned char c) {
SBI(M_UCSRxB, M_UDRIEx); CRITICAL_SECTION_START;
const uint8_t h = rx_buffer.head,
i = (uint8_t)(h + 1) & (RX_BUFFER_SIZE - 1);
// if we should be storing the received character into the location
// just before the tail (meaning that the head would advance to the
// current location of the tail), we're about to overflow the buffer
// and so we don't write the character or advance the head.
if (i != rx_buffer.tail) {
rx_buffer.buffer[h] = c;
rx_buffer.head = i;
}
CRITICAL_SECTION_END;
#if ENABLED(EMERGENCY_PARSER)
emergency_parser(c);
#endif
}
#if TX_BUFFER_SIZE > 0
FORCE_INLINE void _tx_udr_empty_irq(void) {
// If interrupts are enabled, there must be more data in the output
// buffer. Send the next byte
const uint8_t t = tx_buffer.tail,
c = tx_buffer.buffer[t];
tx_buffer.tail = (t + 1) & (TX_BUFFER_SIZE - 1);
M_UDRx = c;
// clear the TXC bit -- "can be cleared by writing a one to its bit
// location". This makes sure flush() won't return until the bytes
// actually got written
SBI(M_UCSRxA, M_TXCx);
if (tx_buffer.head == tx_buffer.tail) {
// Buffer empty, so disable interrupts
CBI(M_UCSRxB, M_UDRIEx);
}
}
#ifdef M_USARTx_UDRE_vect
ISR(M_USARTx_UDRE_vect) {
_tx_udr_empty_irq();
}
#endif
#endif // TX_BUFFER_SIZE
#ifdef M_USARTx_RX_vect
ISR(M_USARTx_RX_vect) {
const unsigned char c = M_UDRx;
store_char(c);
}
#endif
// Public Methods
void MarlinSerial::begin(const long baud) {
uint16_t baud_setting;
bool useU2X = true;
#if F_CPU == 16000000UL && SERIAL_PORT == 0
// hard-coded exception for compatibility with the bootloader shipped
// with the Duemilanove and previous boards and the firmware on the 8U2
// on the Uno and Mega 2560.
if (baud == 57600) useU2X = false;
#endif
if (useU2X) {
M_UCSRxA = _BV(M_U2Xx);
baud_setting = (F_CPU / 4 / baud - 1) / 2;
}
else {
M_UCSRxA = 0;
baud_setting = (F_CPU / 8 / baud - 1) / 2;
}
// assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
M_UBRRxH = baud_setting >> 8;
M_UBRRxL = baud_setting;
SBI(M_UCSRxB, M_RXENx);
SBI(M_UCSRxB, M_TXENx);
SBI(M_UCSRxB, M_RXCIEx);
#if TX_BUFFER_SIZE > 0
CBI(M_UCSRxB, M_UDRIEx);
_written = false;
#endif
}
void MarlinSerial::end() {
CBI(M_UCSRxB, M_RXENx);
CBI(M_UCSRxB, M_TXENx);
CBI(M_UCSRxB, M_RXCIEx);
CBI(M_UCSRxB, M_UDRIEx);
}
void MarlinSerial::checkRx(void) {
if (TEST(M_UCSRxA, M_RXCx)) {
const uint8_t c = M_UDRx;
store_char(c);
}
}
int MarlinSerial::peek(void) {
CRITICAL_SECTION_START;
const int v = rx_buffer.head == rx_buffer.tail ? -1 : rx_buffer.buffer[rx_buffer.tail];
CRITICAL_SECTION_END;
return v;
}
int MarlinSerial::read(void) {
int v;
CRITICAL_SECTION_START;
const uint8_t t = rx_buffer.tail;
if (rx_buffer.head == t)
v = -1;
else {
v = rx_buffer.buffer[t];
rx_buffer.tail = (uint8_t)(t + 1) & (RX_BUFFER_SIZE - 1);
}
CRITICAL_SECTION_END;
return v;
}
uint8_t MarlinSerial::available(void) {
CRITICAL_SECTION_START;
const uint8_t h = rx_buffer.head,
t = rx_buffer.tail;
CRITICAL_SECTION_END;
return (uint8_t)(RX_BUFFER_SIZE + h - t) & (RX_BUFFER_SIZE - 1);
}
void MarlinSerial::flush(void) {
// RX
// don't reverse this or there may be problems if the RX interrupt
// occurs after reading the value of rx_buffer_head but before writing
// the value to rx_buffer_tail; the previous value of rx_buffer_head
// may be written to rx_buffer_tail, making it appear as if the buffer
// were full, not empty.
CRITICAL_SECTION_START;
rx_buffer.head = rx_buffer.tail;
CRITICAL_SECTION_END;
}
#if TX_BUFFER_SIZE > 0
uint8_t MarlinSerial::availableForWrite(void) {
CRITICAL_SECTION_START;
const uint8_t h = tx_buffer.head,
t = tx_buffer.tail;
CRITICAL_SECTION_END; CRITICAL_SECTION_END;
return (uint8_t)(TX_BUFFER_SIZE + h - t) & (TX_BUFFER_SIZE - 1);
} }
return;
}
void MarlinSerial::flushTX(void) { void MarlinSerial::write(const uint8_t c) {
// TX _written = true;
// If we have never written a byte, no need to flush. This special CRITICAL_SECTION_START;
// case is needed since there is no way to force the TXC (transmit bool emty = (tx_buffer.head == tx_buffer.tail);
// complete) bit to 1 during initialization CRITICAL_SECTION_END;
if (!_written) // If the buffer and the data register is empty, just write the byte
// to the data register and be done. This shortcut helps
// significantly improve the effective datarate at high (>
// 500kbit/s) bitrates, where interrupt overhead becomes a slowdown.
if (emty && TEST(M_UCSRxA, M_UDREx)) {
CRITICAL_SECTION_START;
M_UDRx = c;
SBI(M_UCSRxA, M_TXCx);
CRITICAL_SECTION_END;
return;
}
const uint8_t i = (tx_buffer.head + 1) & (TX_BUFFER_SIZE - 1);
// If the output buffer is full, there's nothing for it other than to
// wait for the interrupt handler to empty it a bit
while (i == tx_buffer.tail) {
if (!TEST(SREG, SREG_I)) {
// Interrupts are disabled, so we'll have to poll the data
// register empty flag ourselves. If it is set, pretend an
// interrupt has happened and call the handler to free up
// space for us.
if (TEST(M_UCSRxA, M_UDREx))
_tx_udr_empty_irq();
} else {
// nop, the interrupt handler will free up space for us
}
}
tx_buffer.buffer[tx_buffer.head] = c;
{ CRITICAL_SECTION_START;
tx_buffer.head = i;
SBI(M_UCSRxB, M_UDRIEx);
CRITICAL_SECTION_END;
}
return; return;
while (TEST(M_UCSRxB, M_UDRIEx) || !TEST(M_UCSRxA, M_TXCx)) {
if (!TEST(SREG, SREG_I) && TEST(M_UCSRxB, M_UDRIEx))
// Interrupts are globally disabled, but the DR empty
// interrupt should be enabled, so poll the DR empty flag to
// prevent deadlock
if (TEST(M_UCSRxA, M_UDREx))
_tx_udr_empty_irq();
} }
// If we get here, nothing is queued anymore (DRIE is disabled) and
// the hardware finished tranmission (TXC is set).
}
#else void MarlinSerial::flushTX(void) {
void MarlinSerial::write(uint8_t c) { // TX
while (!TEST(M_UCSRxA, M_UDREx)) // If we have never written a byte, no need to flush. This special
; // case is needed since there is no way to force the TXC (transmit
M_UDRx = c; // complete) bit to 1 during initialization
if (!_written)
return;
while (TEST(M_UCSRxB, M_UDRIEx) || !TEST(M_UCSRxA, M_TXCx)) {
if (!TEST(SREG, SREG_I) && TEST(M_UCSRxB, M_UDRIEx))
// Interrupts are globally disabled, but the DR empty
// interrupt should be enabled, so poll the DR empty flag to
// prevent deadlock
if (TEST(M_UCSRxA, M_UDREx))
_tx_udr_empty_irq();
}
// If we get here, nothing is queued anymore (DRIE is disabled) and
// the hardware finished tranmission (TXC is set).
} }
#endif
// end NEW #else
void MarlinSerial::write(uint8_t c) {
while (!TEST(M_UCSRxA, M_UDREx))
;
M_UDRx = c;
}
#endif
/// imports from print.h // end NEW
/// imports from print.h
void MarlinSerial::print(char c, int base) { void MarlinSerial::print(char c, int base) {
print((long) c, base); print((long)c, base);
}
void MarlinSerial::print(unsigned char b, int base) {
print((unsigned long) b, base);
}
void MarlinSerial::print(int n, int base) {
print((long) n, base);
}
void MarlinSerial::print(unsigned int n, int base) {
print((unsigned long) n, base);
}
void MarlinSerial::print(long n, int base) {
if (base == 0) {
write(n);
} }
else if (base == 10) {
if (n < 0) { void MarlinSerial::print(unsigned char b, int base) {
print((unsigned long)b, base);
}
void MarlinSerial::print(int n, int base) {
print((long)n, base);
}
void MarlinSerial::print(unsigned int n, int base) {
print((unsigned long)n, base);
}
void MarlinSerial::print(long n, int base) {
if (base == 0)
write(n);
else if (base == 10) {
if (n < 0) {
print('-');
n = -n;
}
printNumber(n, 10);
}
else
printNumber(n, base);
}
void MarlinSerial::print(unsigned long n, int base) {
if (base == 0) write(n);
else printNumber(n, base);
}
void MarlinSerial::print(double n, int digits) {
printFloat(n, digits);
}
void MarlinSerial::println(void) {
print('\r');
print('\n');
}
void MarlinSerial::println(const String& s) {
print(s);
println();
}
void MarlinSerial::println(const char c[]) {
print(c);
println();
}
void MarlinSerial::println(char c, int base) {
print(c, base);
println();
}
void MarlinSerial::println(unsigned char b, int base) {
print(b, base);
println();
}
void MarlinSerial::println(int n, int base) {
print(n, base);
println();
}
void MarlinSerial::println(unsigned int n, int base) {
print(n, base);
println();
}
void MarlinSerial::println(long n, int base) {
print(n, base);
println();
}
void MarlinSerial::println(unsigned long n, int base) {
print(n, base);
println();
}
void MarlinSerial::println(double n, int digits) {
print(n, digits);
println();
}
// Private Methods
void MarlinSerial::printNumber(unsigned long n, uint8_t base) {
if (n) {
unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
int8_t i = 0;
while (n) {
buf[i++] = n % base;
n /= base;
}
while (i--)
print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
}
else
print('0');
}
void MarlinSerial::printFloat(double number, uint8_t digits) {
// Handle negative numbers
if (number < 0.0) {
print('-'); print('-');
n = -n; number = -number;
} }
printNumber(n, 10);
}
else {
printNumber(n, base);
}
}
void MarlinSerial::print(unsigned long n, int base) { // Round correctly so that print(1.999, 2) prints as "2.00"
if (base == 0) write(n); double rounding = 0.5;
else printNumber(n, base); for (uint8_t i = 0; i < digits; ++i)
} rounding *= 0.1;
void MarlinSerial::print(double n, int digits) { number += rounding;
printFloat(n, digits);
}
void MarlinSerial::println(void) { // Extract the integer part of the number and print it
print('\r'); unsigned long int_part = (unsigned long)number;
print('\n'); double remainder = number - (double)int_part;
} print(int_part);
void MarlinSerial::println(const String& s) { // Print the decimal point, but only if there are digits beyond
print(s); if (digits) {
println(); print('.');
} // Extract digits from the remainder one at a time
while (digits--) {
void MarlinSerial::println(const char c[]) { remainder *= 10.0;
print(c); int toPrint = int(remainder);
println(); print(toPrint);
} remainder -= toPrint;
}
void MarlinSerial::println(char c, int base) {
print(c, base);
println();
}
void MarlinSerial::println(unsigned char b, int base) {
print(b, base);
println();
}
void MarlinSerial::println(int n, int base) {
print(n, base);
println();
}
void MarlinSerial::println(unsigned int n, int base) {
print(n, base);
println();
}
void MarlinSerial::println(long n, int base) {
print(n, base);
println();
}
void MarlinSerial::println(unsigned long n, int base) {
print(n, base);
println();
}
void MarlinSerial::println(double n, int digits) {
print(n, digits);
println();
}
// Private Methods /////////////////////////////////////////////////////////////
void MarlinSerial::printNumber(unsigned long n, uint8_t base) {
if (n) {
unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
int8_t i = 0;
while (n) {
buf[i++] = n % base;
n /= base;
}
while (i--)
print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
}
else
print('0');
}
void MarlinSerial::printFloat(double number, uint8_t digits) {
// Handle negative numbers
if (number < 0.0) {
print('-');
number = -number;
}
// Round correctly so that print(1.999, 2) prints as "2.00"
double rounding = 0.5;
for (uint8_t i = 0; i < digits; ++i)
rounding *= 0.1;
number += rounding;
// Extract the integer part of the number and print it
unsigned long int_part = (unsigned long)number;
double remainder = number - (double)int_part;
print(int_part);
// Print the decimal point, but only if there are digits beyond
if (digits) {
print('.');
// Extract digits from the remainder one at a time
while (digits--) {
remainder *= 10.0;
int toPrint = int(remainder);
print(toPrint);
remainder -= toPrint;
} }
} }
}
// Preinstantiate Objects //////////////////////////////////////////////////////
// Preinstantiate
MarlinSerial customizedSerial;
MarlinSerial customizedSerial; #endif // !USBCON && (UBRRH || UBRR0H || UBRR1H || UBRR2H || UBRR3H)
#endif // whole file
#endif // !USBCON
// For AT90USB targets use the UART for BT interfacing // For AT90USB targets use the UART for BT interfacing
#if defined(USBCON) && ENABLED(BLUETOOTH) #if defined(USBCON) && ENABLED(BLUETOOTH)
HardwareSerial bluetoothSerial; HardwareSerial bluetoothSerial;
#endif #endif
#if ENABLED(EMERGENCY_PARSER)
// Currently looking for: M108, M112, M410
// If you alter the parser please don't forget to update the capabilities in Conditionals_post.h
FORCE_INLINE void emergency_parser(unsigned char c) {
static e_parser_state state = state_RESET;
switch (state) {
case state_RESET:
switch (c) {
case ' ': break;
case 'N': state = state_N; break;
case 'M': state = state_M; break;
default: state = state_IGNORE;
}
break;
case state_N:
switch (c) {
case '0': case '1': case '2':
case '3': case '4': case '5':
case '6': case '7': case '8':
case '9': case '-': case ' ': break;
case 'M': state = state_M; break;
default: state = state_IGNORE;
}
break;
case state_M:
switch (c) {
case ' ': break;
case '1': state = state_M1; break;
case '4': state = state_M4; break;
default: state = state_IGNORE;
}
break;
case state_M1:
switch (c) {
case '0': state = state_M10; break;
case '1': state = state_M11; break;
default: state = state_IGNORE;
}
break;
case state_M10:
state = (c == '8') ? state_M108 : state_IGNORE;
break;
case state_M11:
state = (c == '2') ? state_M112 : state_IGNORE;
break;
case state_M4:
state = (c == '1') ? state_M41 : state_IGNORE;
break;
case state_M41:
state = (c == '0') ? state_M410 : state_IGNORE;
break;
case state_IGNORE:
if (c == '\n') state = state_RESET;
break;
default:
if (c == '\n') {
switch (state) {
case state_M108:
wait_for_user = wait_for_heatup = false;
break;
case state_M112:
kill(PSTR(MSG_KILLED));
break;
case state_M410:
quickstop_stepper();
break;
default:
break;
}
state = state_RESET;
}
}
}
#endif

View File

@@ -29,8 +29,8 @@
*/ */
#ifndef MarlinSerial_h #ifndef MARLINSERIAL_H
#define MarlinSerial_h #define MARLINSERIAL_H
#include "MarlinConfig.h" #include "MarlinConfig.h"
@@ -52,125 +52,118 @@
#define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix
#endif #endif
// Registers used by MarlinSerial class (these are expanded // Registers used by MarlinSerial class (expanded depending on selected serial port)
// depending on selected serial port #define M_UCSRxA SERIAL_REGNAME(UCSR,SERIAL_PORT,A) // defines M_UCSRxA to be UCSRnA where n is the serial port number
#define M_UCSRxA SERIAL_REGNAME(UCSR,SERIAL_PORT,A) // defines M_UCSRxA to be UCSRnA where n is the serial port number #define M_UCSRxB SERIAL_REGNAME(UCSR,SERIAL_PORT,B)
#define M_UCSRxB SERIAL_REGNAME(UCSR,SERIAL_PORT,B) #define M_RXENx SERIAL_REGNAME(RXEN,SERIAL_PORT,)
#define M_RXENx SERIAL_REGNAME(RXEN,SERIAL_PORT,) #define M_TXENx SERIAL_REGNAME(TXEN,SERIAL_PORT,)
#define M_TXENx SERIAL_REGNAME(TXEN,SERIAL_PORT,) #define M_TXCx SERIAL_REGNAME(TXC,SERIAL_PORT,)
#define M_TXCx SERIAL_REGNAME(TXC,SERIAL_PORT,) #define M_RXCIEx SERIAL_REGNAME(RXCIE,SERIAL_PORT,)
#define M_RXCIEx SERIAL_REGNAME(RXCIE,SERIAL_PORT,) #define M_UDREx SERIAL_REGNAME(UDRE,SERIAL_PORT,)
#define M_UDREx SERIAL_REGNAME(UDRE,SERIAL_PORT,) #define M_UDRIEx SERIAL_REGNAME(UDRIE,SERIAL_PORT,)
#define M_UDRIEx SERIAL_REGNAME(UDRIE,SERIAL_PORT,) #define M_UDRx SERIAL_REGNAME(UDR,SERIAL_PORT,)
#define M_UDRx SERIAL_REGNAME(UDR,SERIAL_PORT,) #define M_UBRRxH SERIAL_REGNAME(UBRR,SERIAL_PORT,H)
#define M_UBRRxH SERIAL_REGNAME(UBRR,SERIAL_PORT,H) #define M_UBRRxL SERIAL_REGNAME(UBRR,SERIAL_PORT,L)
#define M_UBRRxL SERIAL_REGNAME(UBRR,SERIAL_PORT,L) #define M_RXCx SERIAL_REGNAME(RXC,SERIAL_PORT,)
#define M_RXCx SERIAL_REGNAME(RXC,SERIAL_PORT,) #define M_USARTx_RX_vect SERIAL_REGNAME(USART,SERIAL_PORT,_RX_vect)
#define M_USARTx_RX_vect SERIAL_REGNAME(USART,SERIAL_PORT,_RX_vect) #define M_U2Xx SERIAL_REGNAME(U2X,SERIAL_PORT,)
#define M_U2Xx SERIAL_REGNAME(U2X,SERIAL_PORT,)
#define M_USARTx_UDRE_vect SERIAL_REGNAME(USART,SERIAL_PORT,_UDRE_vect) #define M_USARTx_UDRE_vect SERIAL_REGNAME(USART,SERIAL_PORT,_UDRE_vect)
#define DEC 10 #define DEC 10
#define HEX 16 #define HEX 16
#define OCT 8 #define OCT 8
#define BIN 2 #define BIN 2
#define BYTE 0 #define BYTE 0
#ifndef USBCON #ifndef USBCON
// Define constants and variables for buffering incoming serial data. We're // Define constants and variables for buffering incoming serial data. We're
// using a ring buffer (I think), in which rx_buffer_head is the index of the // using a ring buffer (I think), in which rx_buffer_head is the index of the
// location to which to write the next incoming character and rx_buffer_tail // location to which to write the next incoming character and rx_buffer_tail
// is the index of the location from which to read. // is the index of the location from which to read.
// 256 is the max limit due to uint8_t head and tail. Use only powers of 2. (...,16,32,64,128,256) // 256 is the max limit due to uint8_t head and tail. Use only powers of 2. (...,16,32,64,128,256)
#ifndef RX_BUFFER_SIZE #ifndef RX_BUFFER_SIZE
#define RX_BUFFER_SIZE 128 #define RX_BUFFER_SIZE 128
#endif #endif
#ifndef TX_BUFFER_SIZE #ifndef TX_BUFFER_SIZE
#define TX_BUFFER_SIZE 32 #define TX_BUFFER_SIZE 32
#endif #endif
#if !((RX_BUFFER_SIZE == 256) ||(RX_BUFFER_SIZE == 128) ||(RX_BUFFER_SIZE == 64) ||(RX_BUFFER_SIZE == 32) ||(RX_BUFFER_SIZE == 16) ||(RX_BUFFER_SIZE == 8) ||(RX_BUFFER_SIZE == 4) ||(RX_BUFFER_SIZE == 2)) #if !((RX_BUFFER_SIZE == 256) ||(RX_BUFFER_SIZE == 128) ||(RX_BUFFER_SIZE == 64) ||(RX_BUFFER_SIZE == 32) ||(RX_BUFFER_SIZE == 16) ||(RX_BUFFER_SIZE == 8) ||(RX_BUFFER_SIZE == 4) ||(RX_BUFFER_SIZE == 2))
#error "RX_BUFFER_SIZE has to be a power of 2 and >= 2" #error "RX_BUFFER_SIZE has to be a power of 2 and >= 2"
#endif #endif
#if !((TX_BUFFER_SIZE == 256) ||(TX_BUFFER_SIZE == 128) ||(TX_BUFFER_SIZE == 64) ||(TX_BUFFER_SIZE == 32) ||(TX_BUFFER_SIZE == 16) ||(TX_BUFFER_SIZE == 8) ||(TX_BUFFER_SIZE == 4) ||(TX_BUFFER_SIZE == 2) ||(TX_BUFFER_SIZE == 0)) #if !((TX_BUFFER_SIZE == 256) ||(TX_BUFFER_SIZE == 128) ||(TX_BUFFER_SIZE == 64) ||(TX_BUFFER_SIZE == 32) ||(TX_BUFFER_SIZE == 16) ||(TX_BUFFER_SIZE == 8) ||(TX_BUFFER_SIZE == 4) ||(TX_BUFFER_SIZE == 2) ||(TX_BUFFER_SIZE == 0))
#error TX_BUFFER_SIZE has to be a power of 2 or 0 #error TX_BUFFER_SIZE has to be a power of 2 or 0
#endif #endif
struct ring_buffer_r { struct ring_buffer_r {
unsigned char buffer[RX_BUFFER_SIZE]; unsigned char buffer[RX_BUFFER_SIZE];
volatile uint8_t head;
volatile uint8_t tail;
};
#if TX_BUFFER_SIZE > 0
struct ring_buffer_t {
unsigned char buffer[TX_BUFFER_SIZE];
volatile uint8_t head; volatile uint8_t head;
volatile uint8_t tail; volatile uint8_t tail;
}; };
#endif
#if UART_PRESENT(SERIAL_PORT)
extern ring_buffer_r rx_buffer;
#if TX_BUFFER_SIZE > 0 #if TX_BUFFER_SIZE > 0
extern ring_buffer_t tx_buffer; struct ring_buffer_t {
unsigned char buffer[TX_BUFFER_SIZE];
volatile uint8_t head;
volatile uint8_t tail;
};
#endif #endif
#endif
#if ENABLED(EMERGENCY_PARSER) #if UART_PRESENT(SERIAL_PORT)
#include "language.h" extern ring_buffer_r rx_buffer;
void emergency_parser(unsigned char c);
#endif
class MarlinSerial { //: public Stream
public:
MarlinSerial();
static void begin(long);
static void end();
static int peek(void);
static int read(void);
static void flush(void);
static uint8_t available(void);
static void checkRx(void);
static void write(uint8_t c);
#if TX_BUFFER_SIZE > 0 #if TX_BUFFER_SIZE > 0
static uint8_t availableForWrite(void); extern ring_buffer_t tx_buffer;
static void flushTX(void);
#endif #endif
#endif
private: class MarlinSerial { //: public Stream
static void printNumber(unsigned long, uint8_t);
static void printFloat(double, uint8_t);
public: public:
static FORCE_INLINE void write(const char* str) { while (*str) write(*str++); } MarlinSerial() {};
static FORCE_INLINE void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); } static void begin(const long);
static FORCE_INLINE void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); } static void end();
static FORCE_INLINE void print(const char* str) { write(str); } static int peek(void);
static int read(void);
static void flush(void);
static uint8_t available(void);
static void checkRx(void);
static void write(const uint8_t c);
#if TX_BUFFER_SIZE > 0
static uint8_t availableForWrite(void);
static void flushTX(void);
#endif
static void print(char, int = BYTE); private:
static void print(unsigned char, int = BYTE); static void printNumber(unsigned long, const uint8_t);
static void print(int, int = DEC); static void printFloat(double, uint8_t);
static void print(unsigned int, int = DEC);
static void print(long, int = DEC);
static void print(unsigned long, int = DEC);
static void print(double, int = 2);
static void println(const String& s); public:
static void println(const char[]); static FORCE_INLINE void write(const char* str) { while (*str) write(*str++); }
static void println(char, int = BYTE); static FORCE_INLINE void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
static void println(unsigned char, int = BYTE); static FORCE_INLINE void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
static void println(int, int = DEC); static FORCE_INLINE void print(const char* str) { write(str); }
static void println(unsigned int, int = DEC);
static void println(long, int = DEC); static void print(char, int = BYTE);
static void println(unsigned long, int = DEC); static void print(unsigned char, int = BYTE);
static void println(double, int = 2); static void print(int, int = DEC);
static void println(void); static void print(unsigned int, int = DEC);
}; static void print(long, int = DEC);
static void print(unsigned long, int = DEC);
static void print(double, int = 2);
static void println(const String& s);
static void println(const char[]);
static void println(char, int = BYTE);
static void println(unsigned char, int = BYTE);
static void println(int, int = DEC);
static void println(unsigned int, int = DEC);
static void println(long, int = DEC);
static void println(unsigned long, int = DEC);
static void println(double, int = 2);
static void println(void);
};
extern MarlinSerial customizedSerial;
extern MarlinSerial customizedSerial;
#endif // !USBCON #endif // !USBCON
// Use the UART for Bluetooth in AT90USB configurations // Use the UART for Bluetooth in AT90USB configurations
@@ -178,4 +171,4 @@ extern MarlinSerial customizedSerial;
extern HardwareSerial bluetoothSerial; extern HardwareSerial bluetoothSerial;
#endif #endif
#endif #endif // MARLINSERIAL_H

5340
Marlin/Marlin_main.cpp Executable file → Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -27,18 +27,17 @@
*/ */
/** /**
* Due to the high number of issues related with old versions of Arduino IDE * Require gcc 4.7 or newer (first included with Arduino 1.6.8) for C++11 features.
* we now prevent Marlin from compiling with older toolkits.
*/ */
#if !defined(ARDUINO) || ARDUINO < 10608 #if __cplusplus < 201103L
#error "Versions of Arduino IDE prior to 1.6.8 are no longer supported, please update your toolkit." #error "Marlin requires C++11 support (gcc >= 4.7, Arduino IDE >= 1.6.8). Please upgrade your toolchain."
#endif #endif
/** /**
* We try our best to include sanity checks for all the changes configuration * We try our best to include sanity checks for all changed configuration
* directives because people have a tendency to use outdated config files with * directives because users have a tendency to use outdated config files with
* the bleding edge source code, but sometimes this is not enough. This check * the bleeding-edge source code, but sometimes this is not enough. This check
* will force a minimum config file revision, otherwise Marlin will not build. * forces a minimum config file revision. Otherwise Marlin will not build.
*/ */
#if ! defined(CONFIGURATION_H_VERSION) || CONFIGURATION_H_VERSION < REQUIRED_CONFIGURATION_H_VERSION #if ! defined(CONFIGURATION_H_VERSION) || CONFIGURATION_H_VERSION < REQUIRED_CONFIGURATION_H_VERSION
#error "You are using an old Configuration.h file, update it before building Marlin." #error "You are using an old Configuration.h file, update it before building Marlin."
@@ -78,7 +77,7 @@
#elif defined(DISABLE_MAX_ENDSTOPS) || defined(DISABLE_MIN_ENDSTOPS) #elif defined(DISABLE_MAX_ENDSTOPS) || defined(DISABLE_MIN_ENDSTOPS)
#error "DISABLE_MAX_ENDSTOPS and DISABLE_MIN_ENDSTOPS deprecated. Use individual USE_*_PLUG options instead." #error "DISABLE_MAX_ENDSTOPS and DISABLE_MIN_ENDSTOPS deprecated. Use individual USE_*_PLUG options instead."
#elif ENABLED(Z_DUAL_ENDSTOPS) && !defined(Z2_USE_ENDSTOP) #elif ENABLED(Z_DUAL_ENDSTOPS) && !defined(Z2_USE_ENDSTOP)
#error "Z_DUAL_ENDSTOPS settings are simplified. Just set Z2_USE_ENDSTOP to the endstop you want to repurpose for Z2" #error "Z_DUAL_ENDSTOPS settings are simplified. Just set Z2_USE_ENDSTOP to the endstop you want to repurpose for Z2."
#elif defined(LANGUAGE_INCLUDE) #elif defined(LANGUAGE_INCLUDE)
#error "LANGUAGE_INCLUDE has been replaced by LCD_LANGUAGE. Please update your configuration." #error "LANGUAGE_INCLUDE has been replaced by LCD_LANGUAGE. Please update your configuration."
#elif defined(EXTRUDER_OFFSET_X) || defined(EXTRUDER_OFFSET_Y) #elif defined(EXTRUDER_OFFSET_X) || defined(EXTRUDER_OFFSET_Y)
@@ -131,6 +130,12 @@
#error "Z_RAISE_PROBE_DEPLOY_STOW and Z_RAISE_BETWEEN_PROBINGS are now Z_CLEARANCE_DEPLOY_PROBE and Z_CLEARANCE_BETWEEN_PROBES. Please update your configuration." #error "Z_RAISE_PROBE_DEPLOY_STOW and Z_RAISE_BETWEEN_PROBINGS are now Z_CLEARANCE_DEPLOY_PROBE and Z_CLEARANCE_BETWEEN_PROBES. Please update your configuration."
#elif defined(Z_PROBE_DEPLOY_HEIGHT) || defined(Z_PROBE_TRAVEL_HEIGHT) #elif defined(Z_PROBE_DEPLOY_HEIGHT) || defined(Z_PROBE_TRAVEL_HEIGHT)
#error "Z_PROBE_DEPLOY_HEIGHT and Z_PROBE_TRAVEL_HEIGHT are now Z_CLEARANCE_DEPLOY_PROBE and Z_CLEARANCE_BETWEEN_PROBES. Please update your configuration." #error "Z_PROBE_DEPLOY_HEIGHT and Z_PROBE_TRAVEL_HEIGHT are now Z_CLEARANCE_DEPLOY_PROBE and Z_CLEARANCE_BETWEEN_PROBES. Please update your configuration."
#elif defined(MANUAL_BED_LEVELING)
#error "MANUAL_BED_LEVELING is now LCD_BED_LEVELING. Please update your configuration."
#elif defined(MESH_HOME_SEARCH_Z)
#error "MESH_HOME_SEARCH_Z is now LCD_PROBE_Z_RANGE. Please update your configuration."
#elif defined(MANUAL_PROBE_Z_RANGE)
#error "MANUAL_PROBE_Z_RANGE is now LCD_PROBE_Z_RANGE. Please update your configuration."
#elif !defined(MIN_STEPS_PER_SEGMENT) #elif !defined(MIN_STEPS_PER_SEGMENT)
#error Please replace "const int dropsegments" with "#define MIN_STEPS_PER_SEGMENT" (and increase by 1) in Configuration_adv.h. #error Please replace "const int dropsegments" with "#define MIN_STEPS_PER_SEGMENT" (and increase by 1) in Configuration_adv.h.
#elif defined(PREVENT_DANGEROUS_EXTRUDE) #elif defined(PREVENT_DANGEROUS_EXTRUDE)
@@ -142,7 +147,17 @@
#elif defined(AUTO_BED_LEVELING_FEATURE) #elif defined(AUTO_BED_LEVELING_FEATURE)
#error "AUTO_BED_LEVELING_FEATURE is deprecated. Specify AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_BILINEAR, or AUTO_BED_LEVELING_3POINT." #error "AUTO_BED_LEVELING_FEATURE is deprecated. Specify AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_BILINEAR, or AUTO_BED_LEVELING_3POINT."
#elif defined(ABL_GRID_POINTS) #elif defined(ABL_GRID_POINTS)
#error "ABL_GRID_POINTS is now ABL_GRID_POINTS_X and ABL_GRID_POINTS_Y. Please update your configuration." #error "ABL_GRID_POINTS is now GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y. Please update your configuration."
#elif defined(ABL_GRID_POINTS_X) || defined(ABL_GRID_POINTS_Y)
#error "ABL_GRID_POINTS_[XY] is now GRID_MAX_POINTS_[XY]. Please update your configuration."
#elif defined(ABL_GRID_MAX_POINTS_X) || defined(ABL_GRID_MAX_POINTS_Y)
#error "ABL_GRID_MAX_POINTS_[XY] is now GRID_MAX_POINTS_[XY]. Please update your configuration."
#elif defined(MESH_NUM_X_POINTS) || defined(MESH_NUM_Y_POINTS)
#error "MESH_NUM_[XY]_POINTS is now GRID_MAX_POINTS_[XY]. Please update your configuration."
#elif defined(UBL_MESH_NUM_X_POINTS) || defined(UBL_MESH_NUM_Y_POINTS)
#error "UBL_MESH_NUM_[XY]_POINTS is now GRID_MAX_POINTS_[XY]. Please update your configuration."
#elif defined(UBL_MESH_EDIT_ENABLED)
#error "UBL_MESH_EDIT_ENABLED is now UBL_G26_MESH_EDITING. Please update your configuration."
#elif defined(BEEPER) #elif defined(BEEPER)
#error "BEEPER is now BEEPER_PIN. Please update your pins definitions." #error "BEEPER is now BEEPER_PIN. Please update your pins definitions."
#elif defined(SDCARDDETECT) #elif defined(SDCARDDETECT)
@@ -155,6 +170,12 @@
#error "LCD_PIN_RESET is now LCD_RESET_PIN. Please update your pins definitions." #error "LCD_PIN_RESET is now LCD_RESET_PIN. Please update your pins definitions."
#elif defined(EXTRUDER_0_AUTO_FAN_PIN) || defined(EXTRUDER_1_AUTO_FAN_PIN) || defined(EXTRUDER_2_AUTO_FAN_PIN) || defined(EXTRUDER_3_AUTO_FAN_PIN) #elif defined(EXTRUDER_0_AUTO_FAN_PIN) || defined(EXTRUDER_1_AUTO_FAN_PIN) || defined(EXTRUDER_2_AUTO_FAN_PIN) || defined(EXTRUDER_3_AUTO_FAN_PIN)
#error "EXTRUDER_[0123]_AUTO_FAN_PIN is now E[0123]_AUTO_FAN_PIN. Please update your Configuration_adv.h." #error "EXTRUDER_[0123]_AUTO_FAN_PIN is now E[0123]_AUTO_FAN_PIN. Please update your Configuration_adv.h."
#elif defined(min_software_endstops) || defined(max_software_endstops)
#error "(min|max)_software_endstops are now (MIN|MAX)_SOFTWARE_ENDSTOPS. Please update your configuration."
#elif ENABLED(Z_PROBE_SLED) && defined(SLED_PIN)
#error "Replace SLED_PIN with SOL1_PIN (applies to both Z_PROBE_SLED and SOLENOID_PROBE)."
#elif defined(CONTROLLERFAN_PIN)
#error "CONTROLLERFAN_PIN is now CONTROLLER_FAN_PIN, enabled with USE_CONTROLLER_FAN. Please update your Configuration_adv.h."
#endif #endif
/** /**
@@ -204,18 +225,37 @@
#endif #endif
#endif #endif
/**
* SD File Sorting
*/
#if ENABLED(SDCARD_SORT_ALPHA)
#if SDSORT_LIMIT > 256
#error "SDSORT_LIMIT must be 256 or smaller."
#elif SDSORT_LIMIT < 10
#error "SDSORT_LIMIT should be greater than 9 to be useful."
#elif DISABLED(SDSORT_USES_RAM)
#if ENABLED(SDSORT_DYNAMIC_RAM)
#error "SDSORT_DYNAMIC_RAM requires SDSORT_USES_RAM (which reads the directory into RAM)."
#elif ENABLED(SDSORT_CACHE_NAMES)
#error "SDSORT_CACHE_NAMES requires SDSORT_USES_RAM (which reads the directory into RAM)."
#endif
#endif
#endif
/** /**
* Delta requirements * Delta requirements
*/ */
#if ENABLED(DELTA) #if ENABLED(DELTA)
#if DISABLED(USE_XMAX_PLUG) && DISABLED(USE_YMAX_PLUG) && DISABLED(USE_ZMAX_PLUG) #if DISABLED(USE_XMAX_PLUG) && DISABLED(USE_YMAX_PLUG) && DISABLED(USE_ZMAX_PLUG)
#error "You probably want to use Max Endstops for DELTA!" #error "You probably want to use Max Endstops for DELTA!"
#elif ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
#error "DELTA is incompatible with ENABLE_LEVELING_FADE_HEIGHT. Please disable it."
#endif #endif
#if ABL_GRID #if ABL_GRID
#if (ABL_GRID_POINTS_X & 1) == 0 || (ABL_GRID_POINTS_Y & 1) == 0 #if (GRID_MAX_POINTS_X & 1) == 0 || (GRID_MAX_POINTS_Y & 1) == 0
#error "DELTA requires ABL_GRID_POINTS_X and ABL_GRID_POINTS_Y to be odd numbers." #error "DELTA requires GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y to be odd numbers."
#elif ABL_GRID_POINTS_X < 3 #elif GRID_MAX_POINTS_X < 3
#error "DELTA requires ABL_GRID_POINTS_X and ABL_GRID_POINTS_Y to be 3 or higher." #error "DELTA requires GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y to be 3 or higher."
#endif #endif
#endif #endif
#endif #endif
@@ -226,12 +266,12 @@
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#if DISABLED(ULTRA_LCD) #if DISABLED(ULTRA_LCD)
#error "BABYSTEPPING requires an LCD controller." #error "BABYSTEPPING requires an LCD controller."
#endif #elif ENABLED(SCARA)
#if ENABLED(SCARA)
#error "BABYSTEPPING is not implemented for SCARA yet." #error "BABYSTEPPING is not implemented for SCARA yet."
#endif #elif ENABLED(DELTA) && ENABLED(BABYSTEP_XY)
#if ENABLED(DELTA) && ENABLED(BABYSTEP_XY)
#error "BABYSTEPPING only implemented for Z axis on deltabots." #error "BABYSTEPPING only implemented for Z axis on deltabots."
#elif ENABLED(BABYSTEP_ZPROBE_OFFSET) && !HAS_BED_PROBE
#error "BABYSTEP_ZPROBE_OFFSET requires a probe."
#endif #endif
#endif #endif
@@ -243,14 +283,22 @@
#error "FILAMENT_RUNOUT_SENSOR requires FIL_RUNOUT_PIN." #error "FILAMENT_RUNOUT_SENSOR requires FIL_RUNOUT_PIN."
#elif DISABLED(SDSUPPORT) && DISABLED(PRINTJOB_TIMER_AUTOSTART) #elif DISABLED(SDSUPPORT) && DISABLED(PRINTJOB_TIMER_AUTOSTART)
#error "FILAMENT_RUNOUT_SENSOR requires SDSUPPORT or PRINTJOB_TIMER_AUTOSTART." #error "FILAMENT_RUNOUT_SENSOR requires SDSUPPORT or PRINTJOB_TIMER_AUTOSTART."
#elif DISABLED(FILAMENT_CHANGE_FEATURE)
static_assert(NULL == strstr(FILAMENT_RUNOUT_SCRIPT, "M600"), "FILAMENT_CHANGE_FEATURE is required to use M600 with FILAMENT_RUNOUT_SENSOR.");
#endif #endif
#endif #endif
/** /**
* Filament Change with Extruder Runout Prevention * Filament Change with Extruder Runout Prevention
*/ */
#if ENABLED(FILAMENT_CHANGE_FEATURE) && ENABLED(EXTRUDER_RUNOUT_PREVENT) #if ENABLED(FILAMENT_CHANGE_FEATURE)
#error "EXTRUDER_RUNOUT_PREVENT is incompatible with FILAMENT_CHANGE_FEATURE." #if DISABLED(ULTIPANEL)
#error "FILAMENT_CHANGE_FEATURE currently requires an LCD controller."
#elif ENABLED(EXTRUDER_RUNOUT_PREVENT)
#error "EXTRUDER_RUNOUT_PREVENT is incompatible with FILAMENT_CHANGE_FEATURE."
#elif ENABLED(PARK_HEAD_ON_PAUSE) && DISABLED(SDSUPPORT) && DISABLED(ULTIPANEL) && DISABLED(EMERGENCY_PARSER)
#error "PARK_HEAD_ON_PAUSE requires SDSUPPORT, EMERGENCY_PARSER, or an LCD controller."
#endif
#endif #endif
/** /**
@@ -265,8 +313,8 @@
*/ */
#if EXTRUDERS > 1 #if EXTRUDERS > 1
#if EXTRUDERS > 4 #if EXTRUDERS > 5
#error "The maximum number of EXTRUDERS in Marlin is 4." #error "Marlin supports a maximum of 5 EXTRUDERS."
#endif #endif
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT) #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
@@ -348,32 +396,24 @@
/** /**
* Allow only one bed leveling option to be defined * Allow only one bed leveling option to be defined
*/ */
#if HAS_ABL static_assert(1 >= 0
#define COUNT_LEV_1 0
#if ENABLED(AUTO_BED_LEVELING_LINEAR) #if ENABLED(AUTO_BED_LEVELING_LINEAR)
#define COUNT_LEV_2 INCREMENT(COUNT_LEV_1) + 1
#else
#define COUNT_LEV_2 COUNT_LEV_1
#endif #endif
#if ENABLED(AUTO_BED_LEVELING_3POINT) #if ENABLED(AUTO_BED_LEVELING_3POINT)
#define COUNT_LEV_3 INCREMENT(COUNT_LEV_2) + 1
#else
#define COUNT_LEV_3 COUNT_LEV_2
#endif #endif
#if ENABLED(AUTO_BED_LEVELING_BILINEAR) #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
#define COUNT_LEV_4 INCREMENT(COUNT_LEV_3) + 1
#else #endif
#define COUNT_LEV_4 COUNT_LEV_3 #if ENABLED(AUTO_BED_LEVELING_UBL)
+ 1
#endif #endif
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
#define COUNT_LEV_5 INCREMENT(COUNT_LEV_4) + 1
#else
#define COUNT_LEV_5 COUNT_LEV_4
#endif #endif
#if COUNT_LEV_5 > 1 , "Select only one of: MESH_BED_LEVELING, AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT, AUTO_BED_LEVELING_BILINEAR or AUTO_BED_LEVELING_UBL."
#error "Select only one of: MESH_BED_LEVELING, AUTO_BED_LEVELING_LINEAR, AUTO_BED_LEVELING_3POINT, or AUTO_BED_LEVELING_BILINEAR." );
#endif
#endif
/** /**
* Mesh Bed Leveling * Mesh Bed Leveling
@@ -381,50 +421,56 @@
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
#if ENABLED(DELTA) #if ENABLED(DELTA)
#error "MESH_BED_LEVELING does not yet support DELTA printers." #error "MESH_BED_LEVELING does not yet support DELTA printers."
#elif MESH_NUM_X_POINTS > 9 || MESH_NUM_Y_POINTS > 9 #elif GRID_MAX_POINTS_X > 9 || GRID_MAX_POINTS_Y > 9
#error "MESH_NUM_X_POINTS and MESH_NUM_Y_POINTS must be less than 10." #error "GRID_MAX_POINTS_X and GRID_MAX_POINTS_Y must be less than 10 for MBL."
#endif
#endif
/**
* Unified Bed Leveling
*/
#if ENABLED(AUTO_BED_LEVELING_UBL)
#if ENABLED(DELTA)
#error "AUTO_BED_LEVELING_UBL does not yet support DELTA printers."
#elif DISABLED(NEWPANEL)
#error "AUTO_BED_LEVELING_UBL requires an LCD controller."
#endif #endif
#elif ENABLED(MANUAL_BED_LEVELING)
#error "MANUAL_BED_LEVELING only applies to MESH_BED_LEVELING."
#endif #endif
/** /**
* Probes * Probes
*/ */
#if PROBE_SELECTED
/** /**
* Allow only one probe option to be defined * Allow only one probe option to be defined
*/ */
#define COUNT_PROBE_1 0 static_assert(1 >= 0
#if ENABLED(PROBE_MANUALLY)
+ 1
#endif
#if ENABLED(FIX_MOUNTED_PROBE) #if ENABLED(FIX_MOUNTED_PROBE)
#define COUNT_PROBE_2 INCREMENT(COUNT_PROBE_1) + 1
#else
#define COUNT_PROBE_2 COUNT_PROBE_1
#endif #endif
#if HAS_Z_SERVO_ENDSTOP && DISABLED(BLTOUCH) #if HAS_Z_SERVO_ENDSTOP && DISABLED(BLTOUCH)
#define COUNT_PROBE_3 INCREMENT(COUNT_PROBE_2) + 1
#else
#define COUNT_PROBE_3 COUNT_PROBE_2
#endif #endif
#if ENABLED(BLTOUCH) #if ENABLED(BLTOUCH)
#define COUNT_PROBE_4 INCREMENT(COUNT_PROBE_3) + 1
#else
#define COUNT_PROBE_4 COUNT_PROBE_3
#endif #endif
#if ENABLED(Z_PROBE_ALLEN_KEY) #if ENABLED(Z_PROBE_ALLEN_KEY)
#define COUNT_PROBE_5 INCREMENT(COUNT_PROBE_4) + 1
#else
#define COUNT_PROBE_5 COUNT_PROBE_4
#endif #endif
#if ENABLED(Z_PROBE_SLED) #if ENABLED(Z_PROBE_SLED)
#define COUNT_PROBE_6 INCREMENT(COUNT_PROBE_5) + 1
#else
#define COUNT_PROBE_6 COUNT_PROBE_5
#endif #endif
#if COUNT_PROBE_6 > 1 #if ENABLED(SOLENOID_PROBE)
#error "Please enable only one probe: FIX_MOUNTED_PROBE, Z Servo, BLTOUCH, Z_PROBE_ALLEN_KEY, or Z_PROBE_SLED." + 1
#endif #endif
, "Please enable only one probe: PROBE_MANUALLY, FIX_MOUNTED_PROBE, Z Servo, BLTOUCH, Z_PROBE_ALLEN_KEY, or Z_PROBE_SLED."
);
#if PROBE_SELECTED
/** /**
* Z_PROBE_SLED is incompatible with DELTA * Z_PROBE_SLED is incompatible with DELTA
@@ -433,6 +479,17 @@
#error "You cannot use Z_PROBE_SLED with DELTA." #error "You cannot use Z_PROBE_SLED with DELTA."
#endif #endif
/**
* SOLENOID_PROBE requirements
*/
#if ENABLED(SOLENOID_PROBE)
#if ENABLED(EXT_SOLENOID)
#error "SOLENOID_PROBE is incompatible with EXT_SOLENOID."
#elif !HAS_SOLENOID_1
#error "SOLENOID_PROBE requires SOL1_PIN. It can be added to your Configuration.h."
#endif
#endif
/** /**
* NUM_SERVOS is required for a Z servo probe * NUM_SERVOS is required for a Z servo probe
*/ */
@@ -454,12 +511,14 @@
#error "Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN requires USE_ZMIN_PLUG to be enabled." #error "Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN requires USE_ZMIN_PLUG to be enabled."
#elif !HAS_Z_MIN #elif !HAS_Z_MIN
#error "Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN requires the Z_MIN_PIN to be defined." #error "Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN requires the Z_MIN_PIN to be defined."
#elif ENABLED(Z_MIN_PROBE_ENDSTOP_INVERTING) != ENABLED(Z_MIN_ENDSTOP_INVERTING)
#error "Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN requires Z_MIN_ENDSTOP_INVERTING to match Z_MIN_PROBE_ENDSTOP_INVERTING."
#endif #endif
#elif ENABLED(Z_MIN_PROBE_ENDSTOP) #elif ENABLED(Z_MIN_PROBE_ENDSTOP)
#if !HAS_Z_MIN_PROBE_PIN #if !HAS_Z_MIN_PROBE_PIN
#error "Z_MIN_PROBE_ENDSTOP requires the Z_MIN_PROBE_PIN to be defined." #error "Z_MIN_PROBE_ENDSTOP requires the Z_MIN_PROBE_PIN to be defined."
#endif #endif
#else #elif DISABLED(PROBE_MANUALLY)
#error "You must enable either Z_MIN_PROBE_ENDSTOP or Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN to use a probe." #error "You must enable either Z_MIN_PROBE_ENDSTOP or Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN to use a probe."
#endif #endif
@@ -489,6 +548,13 @@
#endif #endif
/**
* LCD_BED_LEVELING requirements
*/
#if ENABLED(LCD_BED_LEVELING) && DISABLED(MESH_BED_LEVELING) && !(HAS_ABL && ENABLED(PROBE_MANUALLY))
#error "LCD_BED_LEVELING requires MESH_BED_LEVELING or PROBE_MANUALLY."
#endif
/** /**
* Homing Bump * Homing Bump
*/ */
@@ -500,13 +566,13 @@
* Make sure Z_SAFE_HOMING point is reachable * Make sure Z_SAFE_HOMING point is reachable
*/ */
#if ENABLED(Z_SAFE_HOMING) #if ENABLED(Z_SAFE_HOMING)
#if Z_SAFE_HOMING_X_POINT < MIN_PROBE_X || Z_SAFE_HOMING_X_POINT > MAX_PROBE_X #if !WITHIN(Z_SAFE_HOMING_X_POINT, MIN_PROBE_X, MAX_PROBE_X)
#if HAS_BED_PROBE #if HAS_BED_PROBE
#error "Z_SAFE_HOMING_X_POINT can't be reached by the Z probe." #error "Z_SAFE_HOMING_X_POINT can't be reached by the Z probe."
#else #else
#error "Z_SAFE_HOMING_X_POINT can't be reached by the nozzle." #error "Z_SAFE_HOMING_X_POINT can't be reached by the nozzle."
#endif #endif
#elif Z_SAFE_HOMING_Y_POINT < MIN_PROBE_Y || Z_SAFE_HOMING_Y_POINT > MAX_PROBE_Y #elif !WITHIN(Z_SAFE_HOMING_Y_POINT, MIN_PROBE_Y, MAX_PROBE_Y)
#if HAS_BED_PROBE #if HAS_BED_PROBE
#error "Z_SAFE_HOMING_Y_POINT can't be reached by the Z probe." #error "Z_SAFE_HOMING_Y_POINT can't be reached by the Z probe."
#else #else
@@ -536,17 +602,15 @@
#endif #endif
/** /**
* Check if Probe_Offset * Grid Points is greater than Probing Range * Check auto bed leveling sub-options, especially probe points
*/ */
#if ABL_GRID #if ABL_GRID
#ifndef DELTA_PROBEABLE_RADIUS #ifndef DELTA_PROBEABLE_RADIUS
// Be sure points are in the right order
#if LEFT_PROBE_BED_POSITION > RIGHT_PROBE_BED_POSITION #if LEFT_PROBE_BED_POSITION > RIGHT_PROBE_BED_POSITION
#error "LEFT_PROBE_BED_POSITION must be less than RIGHT_PROBE_BED_POSITION." #error "LEFT_PROBE_BED_POSITION must be less than RIGHT_PROBE_BED_POSITION."
#elif FRONT_PROBE_BED_POSITION > BACK_PROBE_BED_POSITION #elif FRONT_PROBE_BED_POSITION > BACK_PROBE_BED_POSITION
#error "FRONT_PROBE_BED_POSITION must be less than BACK_PROBE_BED_POSITION." #error "FRONT_PROBE_BED_POSITION must be less than BACK_PROBE_BED_POSITION."
#endif #endif
// Make sure probing points are reachable
#if LEFT_PROBE_BED_POSITION < MIN_PROBE_X #if LEFT_PROBE_BED_POSITION < MIN_PROBE_X
#error "The given LEFT_PROBE_BED_POSITION can't be reached by the Z probe." #error "The given LEFT_PROBE_BED_POSITION can't be reached by the Z probe."
#elif RIGHT_PROBE_BED_POSITION > MAX_PROBE_X #elif RIGHT_PROBE_BED_POSITION > MAX_PROBE_X
@@ -557,24 +621,39 @@
#error "The given BACK_PROBE_BED_POSITION can't be reached by the Z probe." #error "The given BACK_PROBE_BED_POSITION can't be reached by the Z probe."
#endif #endif
#endif #endif
#else // !ABL_GRID #elif ENABLED(AUTO_BED_LEVELING_UBL)
#if DISABLED(EEPROM_SETTINGS)
// Check the triangulation points #error "AUTO_BED_LEVELING_UBL requires EEPROM_SETTINGS. Please update your configuration."
#if ABL_PROBE_PT_1_X < MIN_PROBE_X || ABL_PROBE_PT_1_X > MAX_PROBE_X #elif !WITHIN(GRID_MAX_POINTS_X, 3, 15) || !WITHIN(GRID_MAX_POINTS_Y, 3, 15)
#error "GRID_MAX_POINTS_[XY] must be a whole number between 3 and 15."
#elif !WITHIN(UBL_PROBE_PT_1_X, MIN_PROBE_X, MAX_PROBE_X)
#error "The given UBL_PROBE_PT_1_X can't be reached by the Z probe."
#elif !WITHIN(UBL_PROBE_PT_2_X, MIN_PROBE_X, MAX_PROBE_X)
#error "The given UBL_PROBE_PT_2_X can't be reached by the Z probe."
#elif !WITHIN(UBL_PROBE_PT_3_X, MIN_PROBE_X, MAX_PROBE_X)
#error "The given UBL_PROBE_PT_3_X can't be reached by the Z probe."
#elif !WITHIN(UBL_PROBE_PT_1_Y, MIN_PROBE_Y, MAX_PROBE_Y)
#error "The given UBL_PROBE_PT_1_Y can't be reached by the Z probe."
#elif !WITHIN(UBL_PROBE_PT_2_Y, MIN_PROBE_Y, MAX_PROBE_Y)
#error "The given UBL_PROBE_PT_2_Y can't be reached by the Z probe."
#elif !WITHIN(UBL_PROBE_PT_3_Y, MIN_PROBE_Y, MAX_PROBE_Y)
#error "The given UBL_PROBE_PT_3_Y can't be reached by the Z probe."
#endif
#else // AUTO_BED_LEVELING_3POINT
#if !WITHIN(ABL_PROBE_PT_1_X, MIN_PROBE_X, MAX_PROBE_X)
#error "The given ABL_PROBE_PT_1_X can't be reached by the Z probe." #error "The given ABL_PROBE_PT_1_X can't be reached by the Z probe."
#elif ABL_PROBE_PT_2_X < MIN_PROBE_X || ABL_PROBE_PT_2_X > MAX_PROBE_X #elif !WITHIN(ABL_PROBE_PT_2_X, MIN_PROBE_X, MAX_PROBE_X)
#error "The given ABL_PROBE_PT_2_X can't be reached by the Z probe." #error "The given ABL_PROBE_PT_2_X can't be reached by the Z probe."
#elif ABL_PROBE_PT_3_X < MIN_PROBE_X || ABL_PROBE_PT_3_X > MAX_PROBE_X #elif !WITHIN(ABL_PROBE_PT_3_X, MIN_PROBE_X, MAX_PROBE_X)
#error "The given ABL_PROBE_PT_3_X can't be reached by the Z probe." #error "The given ABL_PROBE_PT_3_X can't be reached by the Z probe."
#elif ABL_PROBE_PT_1_Y < MIN_PROBE_Y || ABL_PROBE_PT_1_Y > MAX_PROBE_Y #elif !WITHIN(ABL_PROBE_PT_1_Y, MIN_PROBE_Y, MAX_PROBE_Y)
#error "The given ABL_PROBE_PT_1_Y can't be reached by the Z probe." #error "The given ABL_PROBE_PT_1_Y can't be reached by the Z probe."
#elif ABL_PROBE_PT_2_Y < MIN_PROBE_Y || ABL_PROBE_PT_2_Y > MAX_PROBE_Y #elif !WITHIN(ABL_PROBE_PT_2_Y, MIN_PROBE_Y, MAX_PROBE_Y)
#error "The given ABL_PROBE_PT_2_Y can't be reached by the Z probe." #error "The given ABL_PROBE_PT_2_Y can't be reached by the Z probe."
#elif ABL_PROBE_PT_3_Y < MIN_PROBE_Y || ABL_PROBE_PT_3_Y > MAX_PROBE_Y #elif !WITHIN(ABL_PROBE_PT_3_Y, MIN_PROBE_Y, MAX_PROBE_Y)
#error "The given ABL_PROBE_PT_3_Y can't be reached by the Z probe." #error "The given ABL_PROBE_PT_3_Y can't be reached by the Z probe."
#endif #endif
#endif // AUTO_BED_LEVELING_3POINT
#endif // !ABL_GRID
#endif // HAS_ABL #endif // HAS_ABL
@@ -613,55 +692,36 @@
/** /**
* Don't set more than one kinematic type * Don't set more than one kinematic type
*/ */
#define COUNT_KIN_1 0 static_assert(1 >= 0
#if ENABLED(DELTA) #if ENABLED(DELTA)
#define COUNT_KIN_2 INCREMENT(COUNT_KIN_1) + 1
#else #endif
#define COUNT_KIN_2 COUNT_KIN_1 #if ENABLED(MORGAN_SCARA)
#endif + 1
#if ENABLED(MORGAN_SCARA) #endif
#define COUNT_KIN_3 INCREMENT(COUNT_KIN_2) #if ENABLED(MAKERARM_SCARA)
#else + 1
#define COUNT_KIN_3 COUNT_KIN_2 #endif
#endif #if ENABLED(COREXY)
#if ENABLED(MAKERARM_SCARA) + 1
#define COUNT_KIN_4 INCREMENT(COUNT_KIN_3) #endif
#else #if ENABLED(COREXZ)
#define COUNT_KIN_4 COUNT_KIN_3 + 1
#endif #endif
#if ENABLED(COREXY) #if ENABLED(COREYZ)
#define COUNT_KIN_5 INCREMENT(COUNT_KIN_4) + 1
#else #endif
#define COUNT_KIN_5 COUNT_KIN_4 #if ENABLED(COREYX)
#endif + 1
#if ENABLED(COREXZ) #endif
#define COUNT_KIN_6 INCREMENT(COUNT_KIN_5) #if ENABLED(COREZX)
#else + 1
#define COUNT_KIN_6 COUNT_KIN_5 #endif
#endif #if ENABLED(COREZY)
#if ENABLED(COREYZ) + 1
#define COUNT_KIN_7 INCREMENT(COUNT_KIN_6) #endif
#else , "Please enable only one of DELTA, MORGAN_SCARA, MAKERARM_SCARA, COREXY, COREYX, COREXZ, COREZX, COREYZ, or COREZY."
#define COUNT_KIN_7 COUNT_KIN_6 );
#endif
#if ENABLED(COREYX)
#define COUNT_KIN_8 INCREMENT(COUNT_KIN_7)
#else
#define COUNT_KIN_8 COUNT_KIN_7
#endif
#if ENABLED(COREZX)
#define COUNT_KIN_9 INCREMENT(COUNT_KIN_8)
#else
#define COUNT_KIN_9 COUNT_KIN_8
#endif
#if ENABLED(COREZY)
#define COUNT_KIN_10 INCREMENT(COUNT_KIN_9)
#else
#define COUNT_KIN_10 COUNT_KIN_9
#endif
#if COUNT_KIN_10 > 1
#error "Please enable only one of DELTA, MORGAN_SCARA, MAKERARM_SCARA, COREXY, COREYX, COREXZ, COREZX, COREYZ, or COREZY."
#endif
/** /**
* Allen Key * Allen Key
@@ -707,19 +767,21 @@
#endif #endif
#endif #endif
#if HAS_FAN0 && CONTROLLERFAN_PIN == FAN_PIN #if HAS_FAN0 && CONTROLLER_FAN_PIN == FAN_PIN
#error "You cannot set CONTROLLERFAN_PIN equal to FAN_PIN." #error "You cannot set CONTROLLER_FAN_PIN equal to FAN_PIN."
#endif #endif
#if HAS_CONTROLLERFAN #if ENABLED(USE_CONTROLLER_FAN)
#if E0_AUTO_FAN_PIN == CONTROLLERFAN_PIN #if !HAS_CONTROLLER_FAN
#error "You cannot set E0_AUTO_FAN_PIN equal to CONTROLLERFAN_PIN." #error "USE_CONTROLLER_FAN requires a CONTROLLER_FAN_PIN. Define in Configuration_adv.h."
#elif E1_AUTO_FAN_PIN == CONTROLLERFAN_PIN #elif E0_AUTO_FAN_PIN == CONTROLLER_FAN_PIN
#error "You cannot set E1_AUTO_FAN_PIN equal to CONTROLLERFAN_PIN." #error "You cannot set E0_AUTO_FAN_PIN equal to CONTROLLER_FAN_PIN."
#elif E2_AUTO_FAN_PIN == CONTROLLERFAN_PIN #elif E1_AUTO_FAN_PIN == CONTROLLER_FAN_PIN
#error "You cannot set E2_AUTO_FAN_PIN equal to CONTROLLERFAN_PIN." #error "You cannot set E1_AUTO_FAN_PIN equal to CONTROLLER_FAN_PIN."
#elif E3_AUTO_FAN_PIN == CONTROLLERFAN_PIN #elif E2_AUTO_FAN_PIN == CONTROLLER_FAN_PIN
#error "You cannot set E3_AUTO_FAN_PIN equal to CONTROLLERFAN_PIN." #error "You cannot set E2_AUTO_FAN_PIN equal to CONTROLLER_FAN_PIN."
#elif E3_AUTO_FAN_PIN == CONTROLLER_FAN_PIN
#error "You cannot set E3_AUTO_FAN_PIN equal to CONTROLLER_FAN_PIN."
#endif #endif
#endif #endif
@@ -728,7 +790,7 @@
*/ */
#if !HAS_HEATER_0 #if !HAS_HEATER_0
#error "HEATER_0_PIN not defined for this board." #error "HEATER_0_PIN not defined for this board."
#elif !PIN_EXISTS(TEMP_0) #elif !PIN_EXISTS(TEMP_0) && !(defined(MAX6675_SS) && MAX6675_SS >= 0)
#error "TEMP_0_PIN not defined for this board." #error "TEMP_0_PIN not defined for this board."
#elif !PIN_EXISTS(E0_STEP) || !PIN_EXISTS(E0_DIR) || !PIN_EXISTS(E0_ENABLE) #elif !PIN_EXISTS(E0_STEP) || !PIN_EXISTS(E0_DIR) || !PIN_EXISTS(E0_ENABLE)
#error "E0_STEP_PIN, E0_DIR_PIN, or E0_ENABLE_PIN not defined for this board." #error "E0_STEP_PIN, E0_DIR_PIN, or E0_ENABLE_PIN not defined for this board."
@@ -758,19 +820,34 @@
#endif #endif
#if HOTENDS > 3 #if HOTENDS > 3
#if TEMP_SENSOR_3 == 0 #if TEMP_SENSOR_3 == 0
#error "TEMP_SENSOR_3 is required with 4 HOTENDS." #error "TEMP_SENSOR_3 is required with 4 or more HOTENDS."
#elif !HAS_HEATER_3 #elif !HAS_HEATER_3
#error "HEATER_3_PIN not defined for this board." #error "HEATER_3_PIN not defined for this board."
#elif !PIN_EXISTS(TEMP_3) #elif !PIN_EXISTS(TEMP_3)
#error "TEMP_3_PIN not defined for this board." #error "TEMP_3_PIN not defined for this board."
#endif #endif
#if HOTENDS > 4
#if TEMP_SENSOR_4 == 0
#error "TEMP_SENSOR_4 is required with 5 HOTENDS."
#elif !HAS_HEATER_4
#error "HEATER_4_PIN not defined for this board."
#elif !PIN_EXISTS(TEMP_4)
#error "TEMP_4_PIN not defined for this board."
#endif
#elif TEMP_SENSOR_4 != 0
#error "TEMP_SENSOR_4 shouldn't be set with only 4 extruders."
#endif
#elif TEMP_SENSOR_3 != 0 #elif TEMP_SENSOR_3 != 0
#error "TEMP_SENSOR_3 shouldn't be set with only 3 extruders." #error "TEMP_SENSOR_3 shouldn't be set with only 3 extruders."
#elif TEMP_SENSOR_4 != 0
#error "TEMP_SENSOR_4 shouldn't be set with only 3 extruders."
#endif #endif
#elif TEMP_SENSOR_2 != 0 #elif TEMP_SENSOR_2 != 0
#error "TEMP_SENSOR_2 shouldn't be set with only 2 extruders." #error "TEMP_SENSOR_2 shouldn't be set with only 2 extruders."
#elif TEMP_SENSOR_3 != 0 #elif TEMP_SENSOR_3 != 0
#error "TEMP_SENSOR_3 shouldn't be set with only 2 extruders." #error "TEMP_SENSOR_3 shouldn't be set with only 2 extruders."
#elif TEMP_SENSOR_4 != 0
#error "TEMP_SENSOR_4 shouldn't be set with only 2 extruders."
#endif #endif
#elif TEMP_SENSOR_1 != 0 && DISABLED(TEMP_SENSOR_1_AS_REDUNDANT) #elif TEMP_SENSOR_1 != 0 && DISABLED(TEMP_SENSOR_1_AS_REDUNDANT)
#error "TEMP_SENSOR_1 shouldn't be set with only 1 extruder." #error "TEMP_SENSOR_1 shouldn't be set with only 1 extruder."
@@ -778,6 +855,8 @@
#error "TEMP_SENSOR_2 shouldn't be set with only 1 extruder." #error "TEMP_SENSOR_2 shouldn't be set with only 1 extruder."
#elif TEMP_SENSOR_3 != 0 #elif TEMP_SENSOR_3 != 0
#error "TEMP_SENSOR_3 shouldn't be set with only 1 extruder." #error "TEMP_SENSOR_3 shouldn't be set with only 1 extruder."
#elif TEMP_SENSOR_4 != 0
#error "TEMP_SENSOR_4 shouldn't be set with only 1 extruder."
#endif #endif
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT) && TEMP_SENSOR_1 == 0 #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT) && TEMP_SENSOR_1 == 0
@@ -811,7 +890,11 @@
/** /**
* Test Extruder Pins * Test Extruder Pins
*/ */
#if EXTRUDERS > 3 #if EXTRUDERS > 4
#if !PIN_EXISTS(E4_STEP) || !PIN_EXISTS(E4_DIR) || !PIN_EXISTS(E4_ENABLE)
#error "E4_STEP_PIN, E4_DIR_PIN, or E4_ENABLE_PIN not defined for this board."
#endif
#elif EXTRUDERS > 3
#if !PIN_EXISTS(E3_STEP) || !PIN_EXISTS(E3_DIR) || !PIN_EXISTS(E3_ENABLE) #if !PIN_EXISTS(E3_STEP) || !PIN_EXISTS(E3_DIR) || !PIN_EXISTS(E3_ENABLE)
#error "E3_STEP_PIN, E3_DIR_PIN, or E3_ENABLE_PIN not defined for this board." #error "E3_STEP_PIN, E3_DIR_PIN, or E3_ENABLE_PIN not defined for this board."
#endif #endif
@@ -828,15 +911,17 @@
/** /**
* Endstops * Endstops
*/ */
#if DISABLED(USE_XMIN_PLUG) && DISABLED(USE_XMAX_PLUG) && !(ENABLED(Z_DUAL_ENDSTOPS) && Z2_USE_ENDSTOP >= _XMAX_ && Z2_USE_ENDSTOP <= _XMIN_) #if DISABLED(USE_XMIN_PLUG) && DISABLED(USE_XMAX_PLUG) && !(ENABLED(Z_DUAL_ENDSTOPS) && WITHIN(Z2_USE_ENDSTOP, _XMAX_, _XMIN_))
#error "You must enable USE_XMIN_PLUG or USE_XMAX_PLUG." #error "You must enable USE_XMIN_PLUG or USE_XMAX_PLUG."
#elif DISABLED(USE_YMIN_PLUG) && DISABLED(USE_YMAX_PLUG) && !(ENABLED(Z_DUAL_ENDSTOPS) && Z2_USE_ENDSTOP >= _YMAX_ && Z2_USE_ENDSTOP <= _YMIN_) #elif DISABLED(USE_YMIN_PLUG) && DISABLED(USE_YMAX_PLUG) && !(ENABLED(Z_DUAL_ENDSTOPS) && WITHIN(Z2_USE_ENDSTOP, _YMAX_, _YMIN_))
#error "You must enable USE_YMIN_PLUG or USE_YMAX_PLUG." #error "You must enable USE_YMIN_PLUG or USE_YMAX_PLUG."
#elif DISABLED(USE_ZMIN_PLUG) && DISABLED(USE_ZMAX_PLUG) && !(ENABLED(Z_DUAL_ENDSTOPS) && Z2_USE_ENDSTOP >= _ZMAX_ && Z2_USE_ENDSTOP <= _ZMIN_) #elif DISABLED(USE_ZMIN_PLUG) && DISABLED(USE_ZMAX_PLUG) && !(ENABLED(Z_DUAL_ENDSTOPS) && WITHIN(Z2_USE_ENDSTOP, _ZMAX_, _ZMIN_))
#error "You must enable USE_ZMIN_PLUG or USE_ZMAX_PLUG." #error "You must enable USE_ZMIN_PLUG or USE_ZMAX_PLUG."
#elif ENABLED(Z_DUAL_ENDSTOPS) #elif ENABLED(Z_DUAL_ENDSTOPS)
#if !Z2_USE_ENDSTOP #if !Z2_USE_ENDSTOP
#error "You must set Z2_USE_ENDSTOP with Z_DUAL_ENDSTOPS." #error "You must set Z2_USE_ENDSTOP with Z_DUAL_ENDSTOPS."
#elif Z2_MAX_PIN == 0 && Z2_MIN_PIN == 0
#error "Z2_USE_ENDSTOP has been assigned to a nonexistent endstop!"
#elif ENABLED(DELTA) #elif ENABLED(DELTA)
#error "Z_DUAL_ENDSTOPS is not compatible with DELTA." #error "Z_DUAL_ENDSTOPS is not compatible with DELTA."
#endif #endif
@@ -888,12 +973,23 @@
/** /**
* RGB_LED Requirements * RGB_LED Requirements
*/ */
#define _RGB_TEST (PIN_EXISTS(RGB_LED_R) && PIN_EXISTS(RGB_LED_G) && PIN_EXISTS(RGB_LED_B))
#if ENABLED(RGB_LED) #if ENABLED(RGB_LED)
#if !(PIN_EXISTS(RGB_LED_R) && PIN_EXISTS(RGB_LED_G) && PIN_EXISTS(RGB_LED_B)) #if !_RGB_TEST
#error "RGB_LED requires RGB_LED_R_PIN, RGB_LED_G_PIN, and RGB_LED_B_PIN." #error "RGB_LED requires RGB_LED_R_PIN, RGB_LED_G_PIN, and RGB_LED_B_PIN."
#elif ENABLED(RGBW_LED)
#error "Please enable only one of RGB_LED and RGBW_LED."
#elif ENABLED(BLINKM) #elif ENABLED(BLINKM)
#error "RGB_LED and BLINKM are currently incompatible (both use M150)." #error "RGB_LED and BLINKM are currently incompatible (both use M150)."
#endif #endif
#elif ENABLED(RGBW_LED)
#if !(_RGB_TEST && PIN_EXISTS(RGB_LED_W))
#error "RGBW_LED requires RGB_LED_R_PIN, RGB_LED_G_PIN, RGB_LED_B_PIN, and RGB_LED_W_PIN."
#elif ENABLED(BLINKM)
#error "RGBW_LED and BLINKM are currently incompatible (both use M150)."
#endif
#elif DISABLED(BLINKM) && ENABLED(PRINTER_EVENT_LEDS)
#error "PRINTER_EVENT_LEDS requires BLINKM, RGB_LED, or RGBW_LED."
#endif #endif
/** /**
@@ -912,7 +1008,6 @@
#endif #endif
#endif #endif
/** /**
* Make sure only one display is enabled * Make sure only one display is enabled
* *
@@ -924,124 +1019,111 @@
* ELB_FULL_GRAPHIC_CONTROLLER => ULTIMAKERCONTROLLER * ELB_FULL_GRAPHIC_CONTROLLER => ULTIMAKERCONTROLLER
* PANEL_ONE => ULTIMAKERCONTROLLER * PANEL_ONE => ULTIMAKERCONTROLLER
*/ */
#define COUNT_LCD_1 0 static_assert(1 >= 0
#if ENABLED(ULTIMAKERCONTROLLER) \ #if ENABLED(ULTIMAKERCONTROLLER) \
&& DISABLED(SAV_3DGLCD) && DISABLED(miniVIKI) && DISABLED(VIKI2) \ && DISABLED(SAV_3DGLCD) && DISABLED(miniVIKI) && DISABLED(VIKI2) \
&& DISABLED(ELB_FULL_GRAPHIC_CONTROLLER) && DISABLED(PANEL_ONE) && DISABLED(ELB_FULL_GRAPHIC_CONTROLLER) && DISABLED(PANEL_ONE)
#define COUNT_LCD_2 INCREMENT(COUNT_LCD_1) + 1
#else #endif
#define COUNT_LCD_2 COUNT_LCD_1 #if ENABLED(REPRAP_DISCOUNT_SMART_CONTROLLER) && DISABLED(REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER)
+ 1
#endif
#if ENABLED(REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER) && DISABLED(BQ_LCD_SMART_CONTROLLER)
+ 1
#endif
#if ENABLED(CARTESIO_UI)
+ 1
#endif
#if ENABLED(PANEL_ONE)
+ 1
#endif
#if ENABLED(MAKRPANEL)
+ 1
#endif
#if ENABLED(REPRAPWORLD_GRAPHICAL_LCD)
+ 1
#endif
#if ENABLED(VIKI2)
+ 1
#endif
#if ENABLED(miniVIKI)
+ 1
#endif
#if ENABLED(ELB_FULL_GRAPHIC_CONTROLLER)
+ 1
#endif
#if ENABLED(G3D_PANEL)
+ 1
#endif
#if ENABLED(MINIPANEL)
+ 1
#endif
#if ENABLED(REPRAPWORLD_KEYPAD) && DISABLED(CARTESIO_UI)
+ 1
#endif
#if ENABLED(RIGIDBOT_PANEL)
+ 1
#endif
#if ENABLED(RA_CONTROL_PANEL)
+ 1
#endif
#if ENABLED(LCD_I2C_SAINSMART_YWROBOT)
+ 1
#endif
#if ENABLED(LCM1602)
+ 1
#endif
#if ENABLED(LCD_I2C_PANELOLU2)
+ 1
#endif
#if ENABLED(LCD_I2C_VIKI)
+ 1
#endif
#if ENABLED(U8GLIB_SSD1306) && DISABLED(OLED_PANEL_TINYBOY2)
+ 1
#endif
#if ENABLED(SAV_3DLCD)
+ 1
#endif
#if ENABLED(BQ_LCD_SMART_CONTROLLER)
+ 1
#endif
#if ENABLED(SAV_3DGLCD)
+ 1
#endif
#if ENABLED(OLED_PANEL_TINYBOY2)
+ 1
#endif
, "Please select no more than one LCD controller option."
);
#if ENABLED(HAVE_TMC2130) && !( \
ENABLED( X_IS_TMC2130 ) \
|| ENABLED( X2_IS_TMC2130 ) \
|| ENABLED( Y_IS_TMC2130 ) \
|| ENABLED( Y2_IS_TMC2130 ) \
|| ENABLED( Z_IS_TMC2130 ) \
|| ENABLED( Z2_IS_TMC2130 ) \
|| ENABLED( E0_IS_TMC2130 ) \
|| ENABLED( E1_IS_TMC2130 ) \
|| ENABLED( E2_IS_TMC2130 ) \
|| ENABLED( E3_IS_TMC2130 ) )
#error "Choose at least one TMC2130 stepper."
#endif #endif
#if ENABLED(REPRAP_DISCOUNT_SMART_CONTROLLER) && DISABLED(REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER)
#define COUNT_LCD_3 INCREMENT(COUNT_LCD_2) #if ENABLED(HYBRID_THRESHOLD) && DISABLED(STEALTHCHOP)
#else #error "Enable STEALTHCHOP to use HYBRID_THRESHOLD."
#define COUNT_LCD_3 COUNT_LCD_2
#endif
#if ENABLED(REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER) && DISABLED(BQ_LCD_SMART_CONTROLLER)
#define COUNT_LCD_4 INCREMENT(COUNT_LCD_3)
#else
#define COUNT_LCD_4 COUNT_LCD_3
#endif
#if ENABLED(CARTESIO_UI)
#define COUNT_LCD_5 INCREMENT(COUNT_LCD_4)
#else
#define COUNT_LCD_5 COUNT_LCD_4
#endif
#if ENABLED(PANEL_ONE)
#define COUNT_LCD_6 INCREMENT(COUNT_LCD_5)
#else
#define COUNT_LCD_6 COUNT_LCD_5
#endif
#if ENABLED(MAKRPANEL)
#define COUNT_LCD_7 INCREMENT(COUNT_LCD_6)
#else
#define COUNT_LCD_7 COUNT_LCD_6
#endif
#if ENABLED(REPRAPWORLD_GRAPHICAL_LCD)
#define COUNT_LCD_8 INCREMENT(COUNT_LCD_7)
#else
#define COUNT_LCD_8 COUNT_LCD_7
#endif
#if ENABLED(VIKI2)
#define COUNT_LCD_9 INCREMENT(COUNT_LCD_8)
#else
#define COUNT_LCD_9 COUNT_LCD_8
#endif
#if ENABLED(miniVIKI)
#define COUNT_LCD_10 INCREMENT(COUNT_LCD_9)
#else
#define COUNT_LCD_10 COUNT_LCD_9
#endif
#if ENABLED(ELB_FULL_GRAPHIC_CONTROLLER)
#define COUNT_LCD_11 INCREMENT(COUNT_LCD_10)
#else
#define COUNT_LCD_11 COUNT_LCD_10
#endif
#if ENABLED(G3D_PANEL)
#define COUNT_LCD_12 INCREMENT(COUNT_LCD_11)
#else
#define COUNT_LCD_12 COUNT_LCD_11
#endif
#if ENABLED(MINIPANEL)
#define COUNT_LCD_13 INCREMENT(COUNT_LCD_12)
#else
#define COUNT_LCD_13 COUNT_LCD_12
#endif
#if ENABLED(REPRAPWORLD_KEYPAD) && DISABLED(CARTESIO_UI)
#define COUNT_LCD_14 INCREMENT(COUNT_LCD_13)
#else
#define COUNT_LCD_14 COUNT_LCD_13
#endif
#if ENABLED(RIGIDBOT_PANEL)
#define COUNT_LCD_15 INCREMENT(COUNT_LCD_14)
#else
#define COUNT_LCD_15 COUNT_LCD_14
#endif
#if ENABLED(RA_CONTROL_PANEL)
#define COUNT_LCD_16 INCREMENT(COUNT_LCD_15)
#else
#define COUNT_LCD_16 COUNT_LCD_15
#endif
#if ENABLED(LCD_I2C_SAINSMART_YWROBOT)
#define COUNT_LCD_17 INCREMENT(COUNT_LCD_16)
#else
#define COUNT_LCD_17 COUNT_LCD_16
#endif
#if ENABLED(LCM1602)
#define COUNT_LCD_18 INCREMENT(COUNT_LCD_17)
#else
#define COUNT_LCD_18 COUNT_LCD_17
#endif
#if ENABLED(LCD_I2C_PANELOLU2)
#define COUNT_LCD_19 INCREMENT(COUNT_LCD_18)
#else
#define COUNT_LCD_19 COUNT_LCD_18
#endif
#if ENABLED(LCD_I2C_VIKI)
#define COUNT_LCD_20 INCREMENT(COUNT_LCD_19)
#else
#define COUNT_LCD_20 COUNT_LCD_19
#endif
#if ENABLED(U8GLIB_SSD1306)
#define COUNT_LCD_21 INCREMENT(COUNT_LCD_20)
#else
#define COUNT_LCD_21 COUNT_LCD_20
#endif
#if ENABLED(SAV_3DLCD)
#define COUNT_LCD_22 INCREMENT(COUNT_LCD_21)
#else
#define COUNT_LCD_22 COUNT_LCD_21
#endif
#if ENABLED(BQ_LCD_SMART_CONTROLLER)
#define COUNT_LCD_23 INCREMENT(COUNT_LCD_22)
#else
#define COUNT_LCD_23 COUNT_LCD_22
#endif
#if ENABLED(SAV_3DGLCD)
#define COUNT_LCD_24 INCREMENT(COUNT_LCD_23)
#else
#define COUNT_LCD_24 COUNT_LCD_23
#endif
#if COUNT_LCD_24 > 1
#error "Please select no more than one LCD controller option."
#endif #endif
/**
* Require 4 or more elements in per-axis initializers
*/
constexpr float sanity_arr_1[] = DEFAULT_AXIS_STEPS_PER_UNIT,
sanity_arr_2[] = DEFAULT_MAX_FEEDRATE,
sanity_arr_3[] = DEFAULT_MAX_ACCELERATION;
static_assert(COUNT(sanity_arr_1) >= XYZE, "DEFAULT_AXIS_STEPS_PER_UNIT requires 4 (or more) elements.");
static_assert(COUNT(sanity_arr_2) >= XYZE, "DEFAULT_MAX_FEEDRATE requires 4 (or more) elements.");
static_assert(COUNT(sanity_arr_3) >= XYZE, "DEFAULT_MAX_ACCELERATION requires 4 (or more) elements.");
static_assert(COUNT(sanity_arr_1) <= XYZE_N, "DEFAULT_AXIS_STEPS_PER_UNIT has too many elements.");
static_assert(COUNT(sanity_arr_2) <= XYZE_N, "DEFAULT_MAX_FEEDRATE has too many elements.");
static_assert(COUNT(sanity_arr_3) <= XYZE_N, "DEFAULT_MAX_ACCELERATION has too many elements.");

View File

@@ -31,6 +31,10 @@
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
#include "Sd2Card.h" #include "Sd2Card.h"
#if ENABLED(USE_WATCHDOG)
#include "watchdog.h"
#endif
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
#if DISABLED(SOFTWARE_SPI) #if DISABLED(SOFTWARE_SPI)
// functions for hardware SPI // functions for hardware SPI
@@ -299,6 +303,12 @@ bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
uint16_t t0 = (uint16_t)millis(); uint16_t t0 = (uint16_t)millis();
uint32_t arg; uint32_t arg;
// If init takes more than 4s it could trigger
// watchdog leading to a reboot loop.
#if ENABLED(USE_WATCHDOG)
watchdog_reset();
#endif
// set pin modes // set pin modes
pinMode(chipSelectPin_, OUTPUT); pinMode(chipSelectPin_, OUTPUT);
chipSelectHigh(); chipSelectHigh();
@@ -396,7 +406,7 @@ bool Sd2Card::readBlock(uint32_t blockNumber, uint8_t* dst) {
else else
error(SD_CARD_ERROR_CMD17); error(SD_CARD_ERROR_CMD17);
if (--retryCnt) break; if (!--retryCnt) break;
chipSelectHigh(); chipSelectHigh();
cardCommand(CMD12, 0); // Try sending a stop command, ignore the result. cardCommand(CMD12, 0); // Try sending a stop command, ignore the result.
@@ -654,8 +664,8 @@ fail:
bool Sd2Card::writeData(uint8_t token, const uint8_t* src) { bool Sd2Card::writeData(uint8_t token, const uint8_t* src) {
spiSendBlock(token, src); spiSendBlock(token, src);
spiSend(0xff); // dummy crc spiSend(0xFF); // dummy crc
spiSend(0xff); // dummy crc spiSend(0xFF); // dummy crc
status_ = spiRec(); status_ = spiRec();
if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) { if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {

View File

@@ -35,7 +35,7 @@
/** /**
* Marlin release version identifier * Marlin release version identifier
*/ */
#define SHORT_BUILD_VERSION "1.1.0-RCBugFix" #define SHORT_BUILD_VERSION "1.1.1"
/** /**
* Verbose version identifier which should contain a reference to the location * Verbose version identifier which should contain a reference to the location
@@ -48,7 +48,7 @@
* here we define this default string as the date where the latest release * here we define this default string as the date where the latest release
* version was tagged. * version was tagged.
*/ */
#define STRING_DISTRIBUTION_DATE "2016-12-06 12:00" #define STRING_DISTRIBUTION_DATE "2017-05-12 12:00"
/** /**
* Required minimum Configuration.h and Configuration_adv.h file versions. * Required minimum Configuration.h and Configuration_adv.h file versions.
@@ -61,7 +61,9 @@
#define REQUIRED_CONFIGURATION_ADV_H_VERSION 010100 #define REQUIRED_CONFIGURATION_ADV_H_VERSION 010100
/** /**
* @todo: Missing documentation block * The protocol for communication to the host. Protocol indicates communication
* standards such as the use of ASCII, "echo:" and "error:" line prefixes, etc.
* (Other behaviors are given by the firmware version and capabilities report.)
*/ */
#define PROTOCOL_VERSION "1.0" #define PROTOCOL_VERSION "1.0"

View File

@@ -32,6 +32,7 @@
#define BOARD_CNCONTROLS_11 111 // Cartesio CN Controls V11 #define BOARD_CNCONTROLS_11 111 // Cartesio CN Controls V11
#define BOARD_CNCONTROLS_12 112 // Cartesio CN Controls V12 #define BOARD_CNCONTROLS_12 112 // Cartesio CN Controls V12
#define BOARD_CHEAPTRONIC 2 // Cheaptronic v1.0 #define BOARD_CHEAPTRONIC 2 // Cheaptronic v1.0
#define BOARD_CHEAPTRONIC_V2 21 // Cheaptronic v2.0
#define BOARD_SETHI 20 // Sethi 3D_1 #define BOARD_SETHI 20 // Sethi 3D_1
#define BOARD_MIGHTYBOARD_REVE 200 // Makerbot Mightyboard Revision E #define BOARD_MIGHTYBOARD_REVE 200 // Makerbot Mightyboard Revision E
#define BOARD_RAMPS_OLD 3 // MEGA/RAMPS up to 1.2 #define BOARD_RAMPS_OLD 3 // MEGA/RAMPS up to 1.2
@@ -83,7 +84,7 @@
#define BOARD_OMCA 91 // Final OMCA board #define BOARD_OMCA 91 // Final OMCA board
#define BOARD_RAMBO 301 // Rambo #define BOARD_RAMBO 301 // Rambo
#define BOARD_MINIRAMBO 302 // Mini-Rambo #define BOARD_MINIRAMBO 302 // Mini-Rambo
#define BOARD_AJ4P 303 // AJ4P #define BOARD_SCOOVO_X9H 303 // abee Scoovo X9H
#define BOARD_MEGACONTROLLER 310 // Mega controller #define BOARD_MEGACONTROLLER 310 // Mega controller
#define BOARD_ELEFU_3 21 // Elefu Ra Board (v3) #define BOARD_ELEFU_3 21 // Elefu Ra Board (v3)
#define BOARD_5DPRINT 88 // 5DPrint D8 Driver Board #define BOARD_5DPRINT 88 // 5DPrint D8 Driver Board

View File

@@ -30,7 +30,17 @@
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
#define LONGEST_FILENAME (longFilename[0] ? longFilename : filename)
CardReader::CardReader() { CardReader::CardReader() {
#if ENABLED(SDCARD_SORT_ALPHA)
sort_count = 0;
#if ENABLED(SDSORT_GCODE)
sort_alpha = true;
sort_folders = FOLDER_SORTING;
//sort_reverse = false;
#endif
#endif
sdprinting = cardOK = saving = logging = false; sdprinting = cardOK = saving = logging = false;
filesize = 0; filesize = 0;
sdpos = 0; sdpos = 0;
@@ -64,7 +74,7 @@ char *createFilename(char *buffer, const dir_t &p) { //buffer > 12characters
* Dive into a folder and recurse depth-first to perform a pre-set operation lsAction: * Dive into a folder and recurse depth-first to perform a pre-set operation lsAction:
* LS_Count - Add +1 to nrFiles for every file within the parent * LS_Count - Add +1 to nrFiles for every file within the parent
* LS_GetFilename - Get the filename of the file indexed by nrFiles * LS_GetFilename - Get the filename of the file indexed by nrFiles
* LS_SerialPrint - Print the full path of each file to serial output * LS_SerialPrint - Print the full path and size of each file to serial output
*/ */
void CardReader::lsDive(const char *prepend, SdFile parent, const char * const match/*=NULL*/) { void CardReader::lsDive(const char *prepend, SdFile parent, const char * const match/*=NULL*/) {
dir_t p; dir_t p;
@@ -81,7 +91,7 @@ void CardReader::lsDive(const char *prepend, SdFile parent, const char * const m
createFilename(lfilename, p); createFilename(lfilename, p);
// Allocate enough stack space for the full path to a folder, trailing slash, and nul // Allocate enough stack space for the full path to a folder, trailing slash, and nul
boolean prepend_is_empty = (prepend[0] == '\0'); bool prepend_is_empty = (prepend[0] == '\0');
int len = (prepend_is_empty ? 1 : strlen(prepend)) + strlen(lfilename) + 1 + 1; int len = (prepend_is_empty ? 1 : strlen(prepend)) + strlen(lfilename) + 1 + 1;
char path[len]; char path[len];
@@ -123,11 +133,15 @@ void CardReader::lsDive(const char *prepend, SdFile parent, const char * const m
case LS_Count: case LS_Count:
nrFiles++; nrFiles++;
break; break;
case LS_SerialPrint: case LS_SerialPrint:
createFilename(filename, p); createFilename(filename, p);
SERIAL_PROTOCOL(prepend); SERIAL_PROTOCOL(prepend);
SERIAL_PROTOCOLLN(filename); SERIAL_PROTOCOL(filename);
SERIAL_PROTOCOLCHAR(' ');
SERIAL_PROTOCOLLN(p.fileSize);
break; break;
case LS_GetFilename: case LS_GetFilename:
createFilename(filename, p); createFilename(filename, p);
if (match != NULL) { if (match != NULL) {
@@ -142,7 +156,7 @@ void CardReader::lsDive(const char *prepend, SdFile parent, const char * const m
} // while readDir } // while readDir
} }
void CardReader::ls() { void CardReader::ls() {
lsAction = LS_SerialPrint; lsAction = LS_SerialPrint;
root.rewind(); root.rewind();
lsDive("", root); lsDive("", root);
@@ -219,7 +233,7 @@ void CardReader::initsd() {
#define SPI_SPEED SPI_FULL_SPEED #define SPI_SPEED SPI_FULL_SPEED
#endif #endif
if (!card.init(SPI_SPEED,SDSS) if (!card.init(SPI_SPEED, SDSS)
#if defined(LCD_SDSS) && (LCD_SDSS != SDSS) #if defined(LCD_SDSS) && (LCD_SDSS != SDSS)
&& !card.init(SPI_SPEED, LCD_SDSS) && !card.init(SPI_SPEED, LCD_SDSS)
#endif #endif
@@ -243,6 +257,9 @@ void CardReader::initsd() {
} }
workDir = root; workDir = root;
curDir = &root; curDir = &root;
#if ENABLED(SDCARD_SORT_ALPHA)
presort();
#endif
/** /**
if (!workDir.openRoot(&volume)) { if (!workDir.openRoot(&volume)) {
SERIAL_ECHOLNPGM(MSG_SD_WORKDIR_FAIL); SERIAL_ECHOLNPGM(MSG_SD_WORKDIR_FAIL);
@@ -256,6 +273,9 @@ void CardReader::setroot() {
}*/ }*/
workDir = root; workDir = root;
curDir = &workDir; curDir = &workDir;
#if ENABLED(SDCARD_SORT_ALPHA)
presort();
#endif
} }
void CardReader::release() { void CardReader::release() {
@@ -272,7 +292,12 @@ void CardReader::openAndPrintFile(const char *name) {
} }
void CardReader::startFileprint() { void CardReader::startFileprint() {
if (cardOK) sdprinting = true; if (cardOK) {
sdprinting = true;
#if ENABLED(SDCARD_SORT_ALPHA)
flush_presort();
#endif
}
} }
void CardReader::stopSDPrint() { void CardReader::stopSDPrint() {
@@ -463,6 +488,9 @@ void CardReader::removeFile(char* name) {
SERIAL_PROTOCOLPGM("File deleted:"); SERIAL_PROTOCOLPGM("File deleted:");
SERIAL_PROTOCOLLN(fname); SERIAL_PROTOCOLLN(fname);
sdpos = 0; sdpos = 0;
#if ENABLED(SDCARD_SORT_ALPHA)
presort();
#endif
} }
else { else {
SERIAL_PROTOCOLPGM("Deletion failed, File: "); SERIAL_PROTOCOLPGM("Deletion failed, File: ");
@@ -524,7 +552,7 @@ void CardReader::checkautostart(bool force) {
bool found = false; bool found = false;
while (root.readDir(p, NULL) > 0) { while (root.readDir(p, NULL) > 0) {
for (int8_t i = 0; i < (int8_t)strlen((char*)p.name); i++) p.name[i] = tolower(p.name[i]); for (int8_t i = (int8_t)strlen((char*)p.name); i--;) p.name[i] = tolower(p.name[i]);
if (p.name[9] != '~' && strncmp((char*)p.name, autoname, 5) == 0) { if (p.name[9] != '~' && strncmp((char*)p.name, autoname, 5) == 0) {
openAndPrintFile(autoname); openAndPrintFile(autoname);
found = true; found = true;
@@ -551,6 +579,20 @@ void CardReader::closefile(bool store_location) {
* Get the name of a file in the current directory by index * Get the name of a file in the current directory by index
*/ */
void CardReader::getfilename(uint16_t nr, const char * const match/*=NULL*/) { void CardReader::getfilename(uint16_t nr, const char * const match/*=NULL*/) {
#if ENABLED(SDSORT_CACHE_NAMES)
if (match != NULL) {
while (nr < sort_count) {
if (strcasecmp(match, sortshort[nr]) == 0) break;
nr++;
}
}
if (nr < sort_count) {
strcpy(filename, sortshort[nr]);
strcpy(longFilename, sortnames[nr]);
filenameIsDir = TEST(isDir[nr>>3], nr & 0x07);
return;
}
#endif // SDSORT_CACHE_NAMES
curDir = &workDir; curDir = &workDir;
lsAction = LS_GetFilename; lsAction = LS_GetFilename;
nrFiles = nr; nrFiles = nr;
@@ -583,14 +625,241 @@ void CardReader::chdir(const char * relpath) {
if (workDirDepth < MAX_DIR_DEPTH) if (workDirDepth < MAX_DIR_DEPTH)
workDirParents[workDirDepth++] = *parent; workDirParents[workDirDepth++] = *parent;
workDir = newfile; workDir = newfile;
#if ENABLED(SDCARD_SORT_ALPHA)
presort();
#endif
} }
} }
void CardReader::updir() { void CardReader::updir() {
if (workDirDepth > 0) if (workDirDepth > 0) {
workDir = workDirParents[--workDirDepth]; workDir = workDirParents[--workDirDepth];
#if ENABLED(SDCARD_SORT_ALPHA)
presort();
#endif
}
} }
#if ENABLED(SDCARD_SORT_ALPHA)
/**
* Get the name of a file in the current directory by sort-index
*/
void CardReader::getfilename_sorted(const uint16_t nr) {
getfilename(
#if ENABLED(SDSORT_GCODE)
sort_alpha &&
#endif
(nr < sort_count) ? sort_order[nr] : nr
);
}
/**
* Read all the files and produce a sort key
*
* We can do this in 3 ways...
* - Minimal RAM: Read two filenames at a time sorting along...
* - Some RAM: Buffer the directory just for this sort
* - Most RAM: Buffer the directory and return filenames from RAM
*/
void CardReader::presort() {
// Sorting may be turned off
#if ENABLED(SDSORT_GCODE)
if (!sort_alpha) return;
#endif
// Throw away old sort index
flush_presort();
// If there are files, sort up to the limit
uint16_t fileCnt = getnrfilenames();
if (fileCnt > 0) {
// Never sort more than the max allowed
// If you use folders to organize, 20 may be enough
if (fileCnt > SDSORT_LIMIT) fileCnt = SDSORT_LIMIT;
// Sort order is always needed. May be static or dynamic.
#if ENABLED(SDSORT_DYNAMIC_RAM)
sort_order = new uint8_t[fileCnt];
#endif
// Use RAM to store the entire directory during pre-sort.
// SDSORT_LIMIT should be set to prevent over-allocation.
#if ENABLED(SDSORT_USES_RAM)
// If using dynamic ram for names, allocate on the heap.
#if ENABLED(SDSORT_CACHE_NAMES)
#if ENABLED(SDSORT_DYNAMIC_RAM)
sortshort = new char*[fileCnt];
sortnames = new char*[fileCnt];
#endif
#elif ENABLED(SDSORT_USES_STACK)
char sortnames[fileCnt][LONG_FILENAME_LENGTH];
#endif
// Folder sorting needs 1 bit per entry for flags.
#if HAS_FOLDER_SORTING
#if ENABLED(SDSORT_DYNAMIC_RAM)
isDir = new uint8_t[(fileCnt + 7) >> 3];
#elif ENABLED(SDSORT_USES_STACK)
uint8_t isDir[(fileCnt + 7) >> 3];
#endif
#endif
#else // !SDSORT_USES_RAM
// By default re-read the names from SD for every compare
// retaining only two filenames at a time. This is very
// slow but is safest and uses minimal RAM.
char name1[LONG_FILENAME_LENGTH + 1];
#endif
if (fileCnt > 1) {
// Init sort order.
for (uint16_t i = 0; i < fileCnt; i++) {
sort_order[i] = i;
// If using RAM then read all filenames now.
#if ENABLED(SDSORT_USES_RAM)
getfilename(i);
#if ENABLED(SDSORT_DYNAMIC_RAM)
// Use dynamic method to copy long filename
sortnames[i] = strdup(LONGEST_FILENAME);
#if ENABLED(SDSORT_CACHE_NAMES)
// When caching also store the short name, since
// we're replacing the getfilename() behavior.
sortshort[i] = strdup(filename);
#endif
#else
// Copy filenames into the static array
strcpy(sortnames[i], LONGEST_FILENAME);
#if ENABLED(SDSORT_CACHE_NAMES)
strcpy(sortshort[i], filename);
#endif
#endif
// char out[30];
// sprintf_P(out, PSTR("---- %i %s %s"), i, filenameIsDir ? "D" : " ", sortnames[i]);
// SERIAL_ECHOLN(out);
#if HAS_FOLDER_SORTING
const uint16_t bit = i & 0x07, ind = i >> 3;
if (bit == 0) isDir[ind] = 0x00;
if (filenameIsDir) isDir[ind] |= _BV(bit);
#endif
#endif
}
// Bubble Sort
for (uint16_t i = fileCnt; --i;) {
bool didSwap = false;
for (uint16_t j = 0; j < i; ++j) {
const uint16_t o1 = sort_order[j], o2 = sort_order[j + 1];
// Compare names from the array or just the two buffered names
#if ENABLED(SDSORT_USES_RAM)
#define _SORT_CMP_NODIR() (strcasecmp(sortnames[o1], sortnames[o2]) > 0)
#else
#define _SORT_CMP_NODIR() (strcasecmp(name1, name2) > 0)
#endif
#if HAS_FOLDER_SORTING
#if ENABLED(SDSORT_USES_RAM)
// Folder sorting needs an index and bit to test for folder-ness.
const uint8_t ind1 = o1 >> 3, bit1 = o1 & 0x07,
ind2 = o2 >> 3, bit2 = o2 & 0x07;
#define _SORT_CMP_DIR(fs) \
(((isDir[ind1] & _BV(bit1)) != 0) == ((isDir[ind2] & _BV(bit2)) != 0) \
? _SORT_CMP_NODIR() \
: (isDir[fs > 0 ? ind1 : ind2] & (fs > 0 ? _BV(bit1) : _BV(bit2))) != 0)
#else
#define _SORT_CMP_DIR(fs) ((dir1 == filenameIsDir) ? _SORT_CMP_NODIR() : (fs > 0 ? dir1 : !dir1))
#endif
#endif
// The most economical method reads names as-needed
// throughout the loop. Slow if there are many.
#if DISABLED(SDSORT_USES_RAM)
getfilename(o1);
strcpy(name1, LONGEST_FILENAME); // save (or getfilename below will trounce it)
#if HAS_FOLDER_SORTING
bool dir1 = filenameIsDir;
#endif
getfilename(o2);
char *name2 = LONGEST_FILENAME; // use the string in-place
#endif // !SDSORT_USES_RAM
// Sort the current pair according to settings.
if (
#if HAS_FOLDER_SORTING
#if ENABLED(SDSORT_GCODE)
sort_folders ? _SORT_CMP_DIR(sort_folders) : _SORT_CMP_NODIR()
#else
_SORT_CMP_DIR(FOLDER_SORTING)
#endif
#else
_SORT_CMP_NODIR()
#endif
) {
sort_order[j] = o2;
sort_order[j + 1] = o1;
didSwap = true;
}
}
if (!didSwap) break;
}
// Using RAM but not keeping names around
#if ENABLED(SDSORT_USES_RAM) && DISABLED(SDSORT_CACHE_NAMES)
#if ENABLED(SDSORT_DYNAMIC_RAM)
for (uint16_t i = 0; i < fileCnt; ++i) free(sortnames[i]);
#if HAS_FOLDER_SORTING
free(isDir);
#endif
#endif
#endif
}
else {
sort_order[0] = 0;
#if ENABLED(SDSORT_USES_RAM) && ENABLED(SDSORT_CACHE_NAMES)
getfilename(0);
#if ENABLED(SDSORT_DYNAMIC_RAM)
sortnames = new char*[1];
sortnames[0] = strdup(LONGEST_FILENAME); // malloc
sortshort = new char*[1];
sortshort[0] = strdup(filename); // malloc
isDir = new uint8_t[1];
#else
strcpy(sortnames[0], LONGEST_FILENAME);
strcpy(sortshort[0], filename);
#endif
isDir[0] = filenameIsDir ? 0x01 : 0x00;
#endif
}
sort_count = fileCnt;
}
}
void CardReader::flush_presort() {
if (sort_count > 0) {
#if ENABLED(SDSORT_DYNAMIC_RAM)
delete sort_order;
#if ENABLED(SDSORT_CACHE_NAMES)
for (uint8_t i = 0; i < sort_count; ++i) {
free(sortshort[i]); // strdup
free(sortnames[i]); // strdup
}
delete sortshort;
delete sortnames;
#endif
#endif
sort_count = 0;
}
}
#endif // SDCARD_SORT_ALPHA
void CardReader::printingHasFinished() { void CardReader::printingHasFinished() {
stepper.synchronize(); stepper.synchronize();
file.close(); file.close();
@@ -607,6 +876,9 @@ void CardReader::printingHasFinished() {
print_job_timer.stop(); print_job_timer.stop();
if (print_job_timer.duration() > 60) if (print_job_timer.duration() > 60)
enqueue_and_echo_commands_P(PSTR("M31")); enqueue_and_echo_commands_P(PSTR("M31"));
#if ENABLED(SDCARD_SORT_ALPHA)
presort();
#endif
} }
} }

View File

@@ -69,6 +69,16 @@ public:
void updir(); void updir();
void setroot(); void setroot();
#if ENABLED(SDCARD_SORT_ALPHA)
void presort();
void getfilename_sorted(const uint16_t nr);
#if ENABLED(SDSORT_GCODE)
FORCE_INLINE void setSortOn(bool b) { sort_alpha = b; presort(); }
FORCE_INLINE void setSortFolders(int i) { sort_folders = i; presort(); }
//FORCE_INLINE void setSortReverse(bool b) { sort_reverse = b; }
#endif
#endif
FORCE_INLINE void pauseSDPrint() { sdprinting = false; } FORCE_INLINE void pauseSDPrint() { sdprinting = false; }
FORCE_INLINE bool isFileOpen() { return file.isOpen(); } FORCE_INLINE bool isFileOpen() { return file.isOpen(); }
FORCE_INLINE bool eof() { return sdpos >= filesize; } FORCE_INLINE bool eof() { return sdpos >= filesize; }
@@ -84,6 +94,51 @@ public:
private: private:
SdFile root, *curDir, workDir, workDirParents[MAX_DIR_DEPTH]; SdFile root, *curDir, workDir, workDirParents[MAX_DIR_DEPTH];
uint8_t workDirDepth; uint8_t workDirDepth;
// Sort files and folders alphabetically.
#if ENABLED(SDCARD_SORT_ALPHA)
uint16_t sort_count; // Count of sorted items in the current directory
#if ENABLED(SDSORT_GCODE)
bool sort_alpha; // Flag to enable / disable the feature
int sort_folders; // Flag to enable / disable folder sorting
//bool sort_reverse; // Flag to enable / disable reverse sorting
#endif
// By default the sort index is static
#if ENABLED(SDSORT_DYNAMIC_RAM)
uint8_t *sort_order;
#else
uint8_t sort_order[SDSORT_LIMIT];
#endif
// Cache filenames to speed up SD menus.
#if ENABLED(SDSORT_USES_RAM)
// If using dynamic ram for names, allocate on the heap.
#if ENABLED(SDSORT_CACHE_NAMES)
#if ENABLED(SDSORT_DYNAMIC_RAM)
char **sortshort, **sortnames;
#else
char sortshort[SDSORT_LIMIT][FILENAME_LENGTH];
char sortnames[SDSORT_LIMIT][FILENAME_LENGTH];
#endif
#elif DISABLED(SDSORT_USES_STACK)
char sortnames[SDSORT_LIMIT][FILENAME_LENGTH];
#endif
// Folder sorting uses an isDir array when caching items.
#if HAS_FOLDER_SORTING
#if ENABLED(SDSORT_DYNAMIC_RAM)
uint8_t *isDir;
#elif ENABLED(SDSORT_CACHE_NAMES) || DISABLED(SDSORT_USES_STACK)
uint8_t isDir[(SDSORT_LIMIT+7)>>3];
#endif
#endif
#endif // SDSORT_USES_RAM
#endif // SDCARD_SORT_ALPHA
Sd2Card card; Sd2Card card;
SdVolume volume; SdVolume volume;
SdFile file; SdFile file;
@@ -103,6 +158,10 @@ private:
uint16_t nrFiles; //counter for the files in the current directory and recycled as position counter for getting the nrFiles'th name in the directory. uint16_t nrFiles; //counter for the files in the current directory and recycled as position counter for getting the nrFiles'th name in the directory.
char* diveDirName; char* diveDirName;
void lsDive(const char *prepend, SdFile parent, const char * const match=NULL); void lsDive(const char *prepend, SdFile parent, const char * const match=NULL);
#if ENABLED(SDCARD_SORT_ALPHA)
void flush_presort();
#endif
}; };
extern CardReader card; extern CardReader card;

File diff suppressed because it is too large Load Diff

View File

@@ -25,19 +25,38 @@
#include "MarlinConfig.h" #include "MarlinConfig.h"
void Config_ResetDefault(); class MarlinSettings {
void Config_StoreSettings(); public:
MarlinSettings() { }
#if DISABLED(DISABLE_M503) static void reset();
void Config_PrintSettings(bool forReplay=false); static bool save();
#else
FORCE_INLINE void Config_PrintSettings(bool forReplay=false) {}
#endif
#if ENABLED(EEPROM_SETTINGS) #if ENABLED(EEPROM_SETTINGS)
void Config_RetrieveSettings(); static bool load();
#else #else
FORCE_INLINE void Config_RetrieveSettings() { Config_ResetDefault(); Config_PrintSettings(); } FORCE_INLINE
#endif static bool load() { reset(); report(); return true; }
#endif
#endif //CONFIGURATION_STORE_H #if DISABLED(DISABLE_M503)
static void report(bool forReplay=false);
#else
FORCE_INLINE
static void report(bool forReplay=false) { }
#endif
private:
static void postprocess();
#if ENABLED(EEPROM_SETTINGS)
static uint16_t eeprom_checksum;
static bool eeprom_read_error, eeprom_write_error;
static void write_data(int &pos, const uint8_t* value, uint16_t size);
static void read_data(int &pos, uint8_t* value, uint16_t size);
#endif
};
extern MarlinSettings settings;
#endif // CONFIGURATION_STORE_H

View File

@@ -0,0 +1,91 @@
/**
* 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/>.
*
*/
#include "MarlinConfig.h"
#if ENABLED(DIGIPOT_I2C) && ENABLED(DIGIPOT_MCP4018)
#include "Stream.h"
#include "utility/twi.h"
#include <SlowSoftI2CMaster.h> //https://github.com/stawel/SlowSoftI2CMaster
// Settings for the I2C based DIGIPOT (MCP4018) based on WT150
#define DIGIPOT_I2C_ADDRESS 0x2F
#define DIGIPOT_A4988_Rsx 0.250
#define DIGIPOT_A4988_Vrefmax 5.0
#define DIGIPOT_A4988_MAX_VALUE 127
#define DIGIPOT_A4988_Itripmax(Vref) ((Vref)/(8.0*DIGIPOT_A4988_Rsx))
#define DIGIPOT_A4988_FACTOR (DIGIPOT_A4988_MAX_VALUE/DIGIPOT_A4988_Itripmax(DIGIPOT_A4988_Vrefmax))
//TODO: MAX_CURRENT -0.5A ?? (currently set to 2A, max possible current 2.5A)
#define DIGIPOT_A4988_MAX_CURRENT (DIGIPOT_A4988_Itripmax(DIGIPOT_A4988_Vrefmax) - 0.5)
static byte current_to_wiper(float current) {
return byte(ceil(float((DIGIPOT_A4988_FACTOR * current))));
}
static uint8_t sda_pins[DIGIPOT_I2C_NUM_CHANNELS] = {
DIGIPOTS_I2C_SDA_X,
DIGIPOTS_I2C_SDA_Y,
DIGIPOTS_I2C_SDA_Z,
DIGIPOTS_I2C_SDA_E0,
DIGIPOTS_I2C_SDA_E1,
};
static SlowSoftI2CMaster pots[DIGIPOT_I2C_NUM_CHANNELS] = {
SlowSoftI2CMaster { sda_pins[0], DIGIPOTS_I2C_SCL },
SlowSoftI2CMaster { sda_pins[1], DIGIPOTS_I2C_SCL },
SlowSoftI2CMaster { sda_pins[2], DIGIPOTS_I2C_SCL },
SlowSoftI2CMaster { sda_pins[3], DIGIPOTS_I2C_SCL },
SlowSoftI2CMaster { sda_pins[4], DIGIPOTS_I2C_SCL }
};
static void i2c_send(int channel, byte v) {
if (WITHIN(channel, 0, DIGIPOT_I2C_NUM_CHANNELS - 1)) {
pots[channel].i2c_start(((DIGIPOT_I2C_ADDRESS) << 1) | I2C_WRITE);
pots[channel].i2c_write(v);
pots[channel].i2c_stop();
}
}
// This is for the MCP4018 I2C based digipot
void digipot_i2c_set_current(int channel, float current) {
current = min(max(current, 0.0f), float(DIGIPOT_A4988_MAX_CURRENT));
i2c_send(channel, current_to_wiper(current));
}
void digipot_i2c_init() {
const float digipot_motor_current[] = DIGIPOT_I2C_MOTOR_CURRENTS;
for (uint8_t i = 0; i < DIGIPOT_I2C_NUM_CHANNELS; i++)
pots[i].i2c_init();
// setup initial currents as defined in Configuration_adv.h
for (uint8_t i = 0; i < COUNT(digipot_motor_current); i++)
digipot_i2c_set_current(i, digipot_motor_current[i]);
}
#endif // DIGIPOT_I2C && DIGIPOT_MCP4018

View File

@@ -22,7 +22,7 @@
#include "MarlinConfig.h" #include "MarlinConfig.h"
#if ENABLED(DIGIPOT_I2C) #if ENABLED(DIGIPOT_I2C) && DISABLED(DIGIPOT_MCP4018)
#include "Stream.h" #include "Stream.h"
#include "utility/twi.h" #include "utility/twi.h"
@@ -60,8 +60,8 @@ void digipot_i2c_set_current(int channel, float current) {
} }
// Initial setup // Initial setup
i2c_send(addr, 0x40, 0xff); i2c_send(addr, 0x40, 0xFF);
i2c_send(addr, 0xA0, 0xff); i2c_send(addr, 0xA0, 0xFF);
// Set actual wiper value // Set actual wiper value
byte addresses[4] = { 0x00, 0x10, 0x60, 0x70 }; byte addresses[4] = { 0x00, 0x10, 0x60, 0x70 };

View File

@@ -0,0 +1,184 @@
/*
Fontname: ISO10646-1-PL
Copyright: A.Hardtung, public domain
Capital A Height: 7, '1' Height: 7
Calculated Max Values w= 5 h= 9 x= 2 y= 7 dx= 6 dy= 0 ascent= 8 len= 9
Font Bounding box w= 6 h= 9 x= 0 y=-2
Calculated Min Values x= 0 y=-2 dx= 0 dy= 0
Pure Font ascent = 7 descent=-1
X Font ascent = 7 descent=-1
Max Font ascent = 8 descent=-2
*/
#include <U8glib.h>
const u8g_fntpgm_uint8_t ISO10646_1_PL_5x7[2732] U8G_FONT_SECTION(".progmem.ISO10646_1_PL_5x7") = {
0,6,9,0,254,7,1,146,3,33,32,255,255,8,254,7,
255,0,0,0,6,0,0,1,7,7,6,2,0,128,128,128,
128,128,0,128,3,2,2,6,1,5,160,160,5,7,7,6,
0,0,80,80,248,80,248,80,80,5,7,7,6,0,0,32,
120,160,112,40,240,32,5,7,7,6,0,0,192,200,16,32,
64,152,24,5,7,7,6,0,0,96,144,160,64,168,144,104,
2,3,3,6,1,4,192,64,128,3,7,7,6,1,0,32,
64,128,128,128,64,32,3,7,7,6,1,0,128,64,32,32,
32,64,128,5,5,5,6,0,1,32,168,112,168,32,5,5,
5,6,0,1,32,32,248,32,32,2,3,3,6,2,255,192,
64,128,5,1,1,6,0,3,248,2,2,2,6,2,0,192,
192,5,5,5,6,0,1,8,16,32,64,128,5,7,7,6,
0,0,112,136,136,136,136,136,112,3,7,7,6,1,0,64,
192,64,64,64,64,224,5,7,7,6,0,0,112,136,8,112,
128,128,248,5,7,7,6,0,0,248,16,32,16,8,8,240,
5,7,7,6,0,0,16,48,80,144,248,16,16,5,7,7,
6,0,0,248,128,240,8,8,136,112,5,7,7,6,0,0,
112,128,128,240,136,136,112,5,7,7,6,0,0,248,8,16,
32,32,32,32,5,7,7,6,0,0,112,136,136,112,136,136,
112,5,7,7,6,0,0,112,136,136,120,8,8,112,2,5,
5,6,2,0,192,192,0,192,192,2,6,6,6,2,255,192,
192,0,192,64,128,4,7,7,6,0,0,16,32,64,128,64,
32,16,5,3,3,6,0,2,248,0,248,4,7,7,6,1,
0,128,64,32,16,32,64,128,5,7,7,6,0,0,112,136,
8,16,32,0,32,5,7,7,6,0,0,112,136,8,104,168,
168,112,5,7,7,6,0,0,112,136,136,248,136,136,136,5,
7,7,6,0,0,240,136,136,240,136,136,240,5,7,7,6,
0,0,112,136,128,128,128,136,112,5,7,7,6,0,0,240,
136,136,136,136,136,240,5,7,7,6,0,0,248,128,128,240,
128,128,248,5,7,7,6,0,0,248,128,128,240,128,128,128,
5,7,7,6,0,0,112,136,128,184,136,136,112,5,7,7,
6,0,0,136,136,136,248,136,136,136,1,7,7,6,2,0,
128,128,128,128,128,128,128,5,7,7,6,0,0,56,16,16,
16,16,144,96,5,7,7,6,0,0,136,144,160,192,160,144,
136,5,7,7,6,0,0,128,128,128,128,128,128,248,5,7,
7,6,0,0,136,216,168,136,136,136,136,5,7,7,6,0,
0,136,136,200,168,152,136,136,5,7,7,6,0,0,112,136,
136,136,136,136,112,5,7,7,6,0,0,240,136,136,240,128,
128,128,5,7,7,6,0,0,112,136,136,136,168,144,104,5,
7,7,6,0,0,240,136,136,240,160,144,136,5,7,7,6,
0,0,120,128,128,112,8,8,240,5,7,7,6,0,0,248,
32,32,32,32,32,32,5,7,7,6,0,0,136,136,136,136,
136,136,112,5,7,7,6,0,0,136,136,136,136,136,80,32,
5,7,7,6,0,0,136,136,136,136,136,168,80,5,7,7,
6,0,0,136,136,80,32,80,136,136,5,7,7,6,0,0,
136,136,136,80,32,32,32,5,7,7,6,0,0,248,8,16,
32,64,128,248,3,7,7,6,1,0,224,128,128,128,128,128,
224,5,5,5,6,0,1,128,64,32,16,8,3,7,7,6,
1,0,224,32,32,32,32,32,224,5,3,3,6,0,4,32,
80,136,5,1,1,6,0,0,248,2,2,2,6,2,5,128,
64,5,5,5,6,0,0,112,8,120,136,120,5,7,7,6,
0,0,128,128,176,200,136,136,240,5,5,5,6,0,0,112,
128,128,136,112,5,7,7,6,0,0,8,8,104,152,136,136,
120,5,5,5,6,0,0,112,136,248,128,112,5,7,7,6,
0,0,48,72,224,64,64,64,64,5,6,6,6,0,255,112,
136,136,120,8,112,5,7,7,6,0,0,128,128,176,200,136,
136,136,1,7,7,6,2,0,128,0,128,128,128,128,128,3,
8,8,6,1,255,32,0,32,32,32,32,160,64,4,7,7,
6,0,0,128,128,144,160,192,160,144,3,7,7,6,1,0,
192,64,64,64,64,64,224,5,5,5,6,0,0,208,168,168,
168,168,5,5,5,6,0,0,176,200,136,136,136,5,5,5,
6,0,0,112,136,136,136,112,5,6,6,6,0,255,240,136,
136,240,128,128,5,6,6,6,0,255,120,136,136,120,8,8,
5,5,5,6,0,0,176,200,128,128,128,5,5,5,6,0,
0,112,128,112,8,240,4,7,7,6,0,0,64,64,224,64,
64,64,48,5,5,5,6,0,0,136,136,136,152,104,5,5,
5,6,0,0,136,136,136,80,32,5,5,5,6,0,0,136,
136,168,168,80,5,5,5,6,0,0,136,80,32,80,136,5,
6,6,6,0,255,136,136,136,120,8,112,5,5,5,6,0,
0,248,16,32,64,248,3,7,7,6,1,0,32,64,64,128,
64,64,32,1,7,7,6,2,0,128,128,128,128,128,128,128,
3,7,7,6,1,0,128,64,64,32,64,64,128,5,2,2,
6,0,2,104,144,0,0,0,6,0,0,5,9,9,6,0,
254,112,136,136,248,136,136,136,16,32,5,7,7,6,0,254,
112,8,120,136,120,16,32,5,8,8,6,0,0,16,32,112,
136,128,128,136,112,5,7,7,6,0,0,16,32,112,128,128,
136,112,5,9,9,6,0,254,248,128,128,240,128,128,248,8,
16,5,7,7,6,0,254,112,136,248,128,112,16,32,5,7,
7,6,0,0,128,144,160,192,128,128,248,5,7,7,6,0,
0,96,40,48,96,160,32,112,5,8,8,6,0,0,16,168,
136,200,168,152,136,136,5,8,8,6,0,0,8,16,0,176,
200,136,136,136,5,8,8,6,0,0,16,32,112,136,136,136,
136,112,5,8,8,6,0,0,16,32,0,112,136,136,136,112,
5,8,8,6,0,0,16,120,128,128,112,8,8,240,5,8,
8,6,0,0,16,32,0,112,128,112,8,240,5,8,8,6,
0,0,32,248,8,16,32,64,128,248,5,8,8,6,0,0,
16,32,0,248,16,32,64,248,5,7,7,6,0,0,248,8,
16,248,64,128,248,5,8,8,6,0,0,48,48,0,248,16,
32,64,248,0,0,0,6,0,0,0,0,0,6,0,0,0,
0,0,6,0,0,0,0,0,6,0,0,0,0,0,6,0,
0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,0,
6,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,
0,0,6,0,0,0,0,0,6,0,0,0,0,0,6,0,
0,0,0,0,6,0,0,0,0,0,6,0,0,1,7,7,
6,2,0,128,0,128,128,128,128,128,5,7,7,6,0,0,
32,112,168,160,168,112,32,5,7,7,6,0,0,48,64,64,
224,64,80,168,5,5,5,6,0,0,136,112,80,112,136,5,
7,7,6,0,0,136,80,32,248,32,248,32,1,7,7,6,
2,0,128,128,128,0,128,128,128,5,8,8,6,0,0,48,
72,32,80,80,32,144,96,3,1,1,6,1,7,160,5,7,
7,6,0,0,248,136,184,184,184,136,248,5,7,7,6,0,
1,112,8,120,136,120,0,248,5,5,5,6,0,1,40,80,
160,80,40,5,3,3,6,0,1,248,8,8,2,2,2,6,
2,6,64,128,5,7,7,6,0,0,248,136,168,136,152,168,
248,5,1,1,6,0,6,248,4,4,4,6,0,3,96,144,
144,96,5,7,7,6,0,0,32,32,248,32,32,0,248,4,
5,5,6,0,3,96,144,32,64,240,3,5,5,6,0,3,
224,32,224,32,224,2,2,2,6,2,6,64,128,5,8,8,
6,0,255,136,136,136,136,152,232,128,128,5,7,7,6,0,
0,120,152,152,120,24,24,24,2,2,2,6,2,2,192,192,
2,2,2,6,2,255,64,128,3,5,5,6,0,3,64,192,
64,64,224,5,7,7,6,0,1,112,136,136,136,112,0,248,
5,5,5,6,0,1,160,80,40,80,160,5,7,7,6,0,
0,136,144,168,88,184,8,8,5,7,7,6,0,0,136,144,
184,72,152,32,56,5,8,8,6,0,0,192,64,192,72,216,
56,8,8,5,7,7,6,0,0,32,0,32,64,128,136,112,
5,8,8,6,0,0,64,32,0,112,136,248,136,136,5,8,
8,6,0,0,16,32,0,112,136,248,136,136,5,8,8,6,
0,0,32,80,0,112,136,248,136,136,5,8,8,6,0,0,
104,144,0,112,136,248,136,136,5,8,8,6,0,0,80,0,
112,136,136,248,136,136,5,8,8,6,0,0,32,80,32,112,
136,248,136,136,5,7,7,6,0,0,56,96,160,184,224,160,
184,5,8,8,6,0,255,112,136,128,128,136,112,32,96,5,
8,8,6,0,0,64,32,0,248,128,240,128,248,5,8,8,
6,0,0,8,16,0,248,128,240,128,248,5,8,8,6,0,
0,32,80,0,248,128,240,128,248,5,7,7,6,0,0,80,
0,248,128,240,128,248,3,8,8,6,1,0,128,64,0,224,
64,64,64,224,3,8,8,6,1,0,32,64,0,224,64,64,
64,224,3,8,8,6,1,0,64,160,0,224,64,64,64,224,
3,7,7,6,1,0,160,0,224,64,64,64,224,5,7,7,
6,0,0,112,72,72,232,72,72,112,5,8,8,6,0,0,
104,144,0,136,200,168,152,136,5,8,8,6,0,0,64,32,
112,136,136,136,136,112,5,8,8,6,0,0,16,32,112,136,
136,136,136,112,5,8,8,6,0,0,32,80,0,112,136,136,
136,112,5,8,8,6,0,0,104,144,0,112,136,136,136,112,
5,8,8,6,0,0,80,0,112,136,136,136,136,112,5,5,
5,6,0,1,136,80,32,80,136,5,8,8,6,0,255,16,
112,168,168,168,168,112,64,5,8,8,6,0,0,64,32,136,
136,136,136,136,112,5,8,8,6,0,0,16,32,136,136,136,
136,136,112,5,8,8,6,0,0,32,80,0,136,136,136,136,
112,5,8,8,6,0,0,80,0,136,136,136,136,136,112,5,
8,8,6,0,0,16,32,136,80,32,32,32,32,5,9,9,
6,0,255,192,64,112,72,72,112,64,64,224,4,8,8,6,
1,255,96,144,144,160,144,144,224,128,5,8,8,6,0,0,
64,32,0,112,8,120,136,120,5,8,8,6,0,0,16,32,
0,112,8,120,136,120,5,8,8,6,0,0,32,80,0,112,
8,120,136,120,5,8,8,6,0,0,104,144,0,112,8,120,
136,120,5,7,7,6,0,0,80,0,112,8,120,136,120,5,
8,8,6,0,0,32,80,32,112,8,120,136,120,5,6,6,
6,0,0,208,40,120,160,168,80,5,6,6,6,0,255,112,
128,136,112,32,96,5,8,8,6,0,0,64,32,0,112,136,
248,128,112,5,8,8,6,0,0,16,32,0,112,136,248,128,
112,5,8,8,6,0,0,32,80,0,112,136,248,128,112,5,
7,7,6,0,0,80,0,112,136,248,128,112,3,8,8,6,
1,0,128,64,0,64,192,64,64,224,3,8,8,6,1,0,
32,64,0,64,192,64,64,224,3,8,8,6,1,0,64,160,
0,64,192,64,64,224,3,7,7,6,1,0,160,0,64,192,
64,64,224,5,7,7,6,0,0,160,64,160,16,120,136,112,
5,8,8,6,0,0,104,144,0,176,200,136,136,136,5,8,
8,6,0,0,64,32,0,112,136,136,136,112,5,8,8,6,
0,0,16,32,0,112,136,136,136,112,5,8,8,6,0,0,
32,80,0,112,136,136,136,112,5,8,8,6,0,0,104,144,
0,112,136,136,136,112,5,7,7,6,0,0,80,0,112,136,
136,136,112,5,5,5,6,0,1,32,0,248,0,32,5,7,
7,6,0,255,16,112,168,168,168,112,64,5,8,8,6,0,
0,64,32,0,136,136,136,152,104,5,8,8,6,0,0,16,
32,0,136,136,136,152,104,5,8,8,6,0,0,32,80,0,
136,136,136,152,104,5,7,7,6,0,0,80,0,136,136,136,
152,104,5,9,9,6,0,255,16,32,0,136,136,136,248,8,
112,4,7,7,6,1,255,192,64,96,80,96,64,224,5,8,
8,6,0,255,80,0,136,136,136,120,8,112};

View File

@@ -31,7 +31,7 @@
X Font ascent = 7 descent=-1 X Font ascent = 7 descent=-1
Max Font ascent = 8 descent=-1 Max Font ascent = 8 descent=-1
*/ */
#include "U8glib.h" #include <U8glib.h>
const u8g_fntpgm_uint8_t ISO10646_TR[2591] U8G_SECTION(".progmem.ISO10646_TR") = { const u8g_fntpgm_uint8_t ISO10646_TR[2591] U8G_SECTION(".progmem.ISO10646_TR") = {
0,6,9,0,254,7,1,146,3,33,32,255,255,8,255,7, 0,6,9,0,254,7,1,146,3,33,32,255,255,8,255,7,
255,0,0,0,6,0,0,1,7,7,6,2,0,128,128,128, 255,0,0,0,6,0,0,1,7,7,6,2,0,128,128,128,

View File

@@ -150,7 +150,7 @@ struct duration_t {
m = uint16_t(this->minute() % 60UL); m = uint16_t(this->minute() % 60UL);
if (with_days) { if (with_days) {
uint16_t d = this->day(); uint16_t d = this->day();
sprintf_P(buffer, PSTR("%ud %02u:%02u"), d, h, m); sprintf_P(buffer, PSTR("%ud %02u:%02u"), d, h % 24, m);
return d >= 10 ? 8 : 7; return d >= 10 ? 8 : 7;
} }
else if (h < 100) { else if (h < 100) {

View File

@@ -35,8 +35,10 @@
* (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino) * (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino)
*/ */
#ifndef _ENDSTOP_INTERRUPTS_H_ #ifndef _ENDSTOP_INTERRUPTS_H_
#define _ENDSTOP_INTERRUPTS_H_ #define _ENDSTOP_INTERRUPTS_H_
#include "macros.h"
/** /**
* Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h) * Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h)
@@ -47,39 +49,37 @@
*/ */
#if defined(ARDUINO_AVR_MEGA2560) || defined(ARDUINO_AVR_MEGA) #if defined(ARDUINO_AVR_MEGA2560) || defined(ARDUINO_AVR_MEGA)
#undef digitalPinToPCICR #undef digitalPinToPCICR
#define digitalPinToPCICR(p) ( (((p) >= 10) && ((p) <= 15)) || \ #define digitalPinToPCICR(p) ( WITHIN(p, 10, 15) || \
(((p) >= 50) && ((p) <= 53)) || \ WITHIN(p, 50, 53) || \
(((p) >= 62) && ((p) <= 69)) ? (&PCICR) : ((uint8_t *)0) ) WITHIN(p, 62, 69) ? &PCICR : (uint8_t*)0 )
#undef digitalPinToPCICRbit #undef digitalPinToPCICRbit
#define digitalPinToPCICRbit(p) ( (((p) >= 10) && ((p) <= 13)) || (((p) >= 50) && ((p) <= 53)) ? 0 : \ #define digitalPinToPCICRbit(p) ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? 0 : \
( (((p) >= 14) && ((p) <= 15)) ? 1 : \ WITHIN(p, 14, 15) ? 1 : \
( (((p) >= 62) && ((p) <= 69)) ? 2 : \ WITHIN(p, 62, 69) ? 2 : \
0 ) ) ) 0 )
#undef digitalPinToPCMSK #undef digitalPinToPCMSK
#define digitalPinToPCMSK(p) ( (((p) >= 10) && ((p) <= 13)) || (((p) >= 50) && ((p) <= 53)) ? (&PCMSK0) : \ #define digitalPinToPCMSK(p) ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? &PCMSK0 : \
( (((p) >= 14) && ((p) <= 15)) ? (&PCMSK1) : \ WITHIN(p, 14, 15) ? &PCMSK1 : \
( (((p) >= 62) && ((p) <= 69)) ? (&PCMSK2) : \ WITHIN(p, 62, 69) ? &PCMSK2 : \
((uint8_t *)0) ) ) ) (uint8_t *)0 )
#undef digitalPinToPCMSKbit #undef digitalPinToPCMSKbit
#define digitalPinToPCMSKbit(p) ( (((p) >= 10) && ((p) <= 13)) ? ((p) - 6) : \ #define digitalPinToPCMSKbit(p) ( WITHIN(p, 10, 13) ? ((p) - 6) : \
( ((p) == 14) ? 2 : \ (p) == 14 || (p) == 51 ? 2 : \
( ((p) == 15) ? 1 : \ (p) == 15 || (p) == 52 ? 1 : \
( ((p) == 50) ? 3 : \ (p) == 50 ? 3 : \
( ((p) == 51) ? 2 : \ (p) == 53 ? 0 : \
( ((p) == 52) ? 1 : \ WITHIN(p, 62, 69) ? ((p) - 62) : \
( ((p) == 53) ? 0 : \ 0 )
( (((p) >= 62) && ((p) <= 69)) ? ((p) - 62) : \
0 ) ) ) ) ) ) ) )
#endif #endif
volatile uint8_t e_hit = 0; // Different from 0 when the endstops shall be tested in detail. volatile uint8_t e_hit = 0; // Different from 0 when the endstops should be tested in detail.
// Must be reset to 0 by the test function when the tests are finished. // Must be reset to 0 by the test function when finished.
// Install Pin change interrupt for a pin. Can be called multiple times. // Install Pin change interrupt for a pin. Can be called multiple times.
void pciSetup(byte pin) { void pciSetup(byte pin) {
*digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin)); // enable pin SBI(*digitalPinToPCMSK(pin), digitalPinToPCMSKbit(pin)); // enable pin
PCIFR |= bit (digitalPinToPCICRbit(pin)); // clear any outstanding interrupt SBI(PCIFR, digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
PCICR |= bit (digitalPinToPCICRbit(pin)); // enable interrupt for the group SBI(PCICR, digitalPinToPCICRbit(pin)); // enable interrupt for the group
} }
// This is what is really done inside the interrupts. // This is what is really done inside the interrupts.

View File

@@ -67,65 +67,74 @@ volatile char Endstops::endstop_hit_bits; // use X_MIN, Y_MIN, Z_MIN and Z_MIN_P
void Endstops::init() { void Endstops::init() {
#if HAS_X_MIN #if HAS_X_MIN
SET_INPUT(X_MIN_PIN);
#if ENABLED(ENDSTOPPULLUP_XMIN) #if ENABLED(ENDSTOPPULLUP_XMIN)
WRITE(X_MIN_PIN,HIGH); SET_INPUT_PULLUP(X_MIN_PIN);
#else
SET_INPUT(X_MIN_PIN);
#endif #endif
#endif #endif
#if HAS_Y_MIN #if HAS_Y_MIN
SET_INPUT(Y_MIN_PIN);
#if ENABLED(ENDSTOPPULLUP_YMIN) #if ENABLED(ENDSTOPPULLUP_YMIN)
WRITE(Y_MIN_PIN,HIGH); SET_INPUT_PULLUP(Y_MIN_PIN);
#else
SET_INPUT(Y_MIN_PIN);
#endif #endif
#endif #endif
#if HAS_Z_MIN #if HAS_Z_MIN
SET_INPUT(Z_MIN_PIN);
#if ENABLED(ENDSTOPPULLUP_ZMIN) #if ENABLED(ENDSTOPPULLUP_ZMIN)
WRITE(Z_MIN_PIN,HIGH); SET_INPUT_PULLUP(Z_MIN_PIN);
#else
SET_INPUT(Z_MIN_PIN);
#endif #endif
#endif #endif
#if HAS_Z2_MIN #if HAS_Z2_MIN
SET_INPUT(Z2_MIN_PIN);
#if ENABLED(ENDSTOPPULLUP_ZMIN) #if ENABLED(ENDSTOPPULLUP_ZMIN)
WRITE(Z2_MIN_PIN,HIGH); SET_INPUT_PULLUP(Z2_MIN_PIN);
#else
SET_INPUT(Z2_MIN_PIN);
#endif #endif
#endif #endif
#if HAS_X_MAX #if HAS_X_MAX
SET_INPUT(X_MAX_PIN);
#if ENABLED(ENDSTOPPULLUP_XMAX) #if ENABLED(ENDSTOPPULLUP_XMAX)
WRITE(X_MAX_PIN,HIGH); SET_INPUT_PULLUP(X_MAX_PIN);
#else
SET_INPUT(X_MAX_PIN);
#endif #endif
#endif #endif
#if HAS_Y_MAX #if HAS_Y_MAX
SET_INPUT(Y_MAX_PIN);
#if ENABLED(ENDSTOPPULLUP_YMAX) #if ENABLED(ENDSTOPPULLUP_YMAX)
WRITE(Y_MAX_PIN,HIGH); SET_INPUT_PULLUP(Y_MAX_PIN);
#else
SET_INPUT(Y_MAX_PIN);
#endif #endif
#endif #endif
#if HAS_Z_MAX #if HAS_Z_MAX
SET_INPUT(Z_MAX_PIN);
#if ENABLED(ENDSTOPPULLUP_ZMAX) #if ENABLED(ENDSTOPPULLUP_ZMAX)
WRITE(Z_MAX_PIN,HIGH); SET_INPUT_PULLUP(Z_MAX_PIN);
#else
SET_INPUT(Z_MAX_PIN);
#endif #endif
#endif #endif
#if HAS_Z2_MAX #if HAS_Z2_MAX
SET_INPUT(Z2_MAX_PIN);
#if ENABLED(ENDSTOPPULLUP_ZMAX) #if ENABLED(ENDSTOPPULLUP_ZMAX)
WRITE(Z2_MAX_PIN,HIGH); SET_INPUT_PULLUP(Z2_MAX_PIN);
#else
SET_INPUT(Z2_MAX_PIN);
#endif #endif
#endif #endif
#if ENABLED(Z_MIN_PROBE_ENDSTOP) #if ENABLED(Z_MIN_PROBE_ENDSTOP)
SET_INPUT(Z_MIN_PROBE_PIN);
#if ENABLED(ENDSTOPPULLUP_ZMIN_PROBE) #if ENABLED(ENDSTOPPULLUP_ZMIN_PROBE)
WRITE(Z_MIN_PROBE_PIN,HIGH); SET_INPUT_PULLUP(Z_MIN_PROBE_PIN);
#else
SET_INPUT(Z_MIN_PROBE_PIN);
#endif #endif
#endif #endif
@@ -148,11 +157,15 @@ void Endstops::report_state() {
if (TEST(endstop_hit_bits, A ##_MIN) || TEST(endstop_hit_bits, A ##_MAX)) \ if (TEST(endstop_hit_bits, A ##_MIN) || TEST(endstop_hit_bits, A ##_MAX)) \
_ENDSTOP_HIT_ECHO(A,C) _ENDSTOP_HIT_ECHO(A,C)
#define ENDSTOP_HIT_TEST_X() _ENDSTOP_HIT_TEST(X,'X')
#define ENDSTOP_HIT_TEST_Y() _ENDSTOP_HIT_TEST(Y,'Y')
#define ENDSTOP_HIT_TEST_Z() _ENDSTOP_HIT_TEST(Z,'Z')
SERIAL_ECHO_START; SERIAL_ECHO_START;
SERIAL_ECHOPGM(MSG_ENDSTOPS_HIT); SERIAL_ECHOPGM(MSG_ENDSTOPS_HIT);
_ENDSTOP_HIT_TEST(X, 'X'); ENDSTOP_HIT_TEST_X();
_ENDSTOP_HIT_TEST(Y, 'Y'); ENDSTOP_HIT_TEST_Y();
_ENDSTOP_HIT_TEST(Z, 'Z'); ENDSTOP_HIT_TEST_Z();
#if ENABLED(Z_MIN_PROBE_ENDSTOP) #if ENABLED(Z_MIN_PROBE_ENDSTOP)
#define P_AXIS Z_AXIS #define P_AXIS Z_AXIS
@@ -161,9 +174,7 @@ void Endstops::report_state() {
SERIAL_EOL; SERIAL_EOL;
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
char msg[3 * strlen(MSG_LCD_ENDSTOPS) + 8 + 1]; // Room for a UTF 8 string lcd_status_printf_P(0, PSTR(MSG_LCD_ENDSTOPS " %c %c %c %c"), chrX, chrY, chrZ, chrP);
sprintf_P(msg, PSTR(MSG_LCD_ENDSTOPS " %c %c %c %c"), chrX, chrY, chrZ, chrP);
lcd_setstatus(msg);
#endif #endif
hit_on_purpose(); hit_on_purpose();
@@ -217,6 +228,10 @@ void Endstops::M119() {
SERIAL_PROTOCOLPGM(MSG_Z_PROBE); SERIAL_PROTOCOLPGM(MSG_Z_PROBE);
SERIAL_PROTOCOLLN(((READ(Z_MIN_PROBE_PIN)^Z_MIN_PROBE_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN)); SERIAL_PROTOCOLLN(((READ(Z_MIN_PROBE_PIN)^Z_MIN_PROBE_ENDSTOP_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN));
#endif #endif
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
SERIAL_PROTOCOLPGM(MSG_FILAMENT_RUNOUT_SENSOR);
SERIAL_PROTOCOLLN(((READ(FIL_RUNOUT_PIN)^FIL_RUNOUT_INVERTING) ? MSG_ENDSTOP_HIT : MSG_ENDSTOP_OPEN));
#endif
} // Endstops::M119 } // Endstops::M119
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
@@ -246,153 +261,197 @@ void Endstops::update() {
// COPY_BIT: copy the value of SRC_BIT to DST_BIT in DST // COPY_BIT: copy the value of SRC_BIT to DST_BIT in DST
#define COPY_BIT(DST, SRC_BIT, DST_BIT) SET_BIT(DST, DST_BIT, TEST(DST, SRC_BIT)) #define COPY_BIT(DST, SRC_BIT, DST_BIT) SET_BIT(DST, DST_BIT, TEST(DST, SRC_BIT))
#define _UPDATE_ENDSTOP(AXIS,MINMAX,CODE) do { \ #define UPDATE_ENDSTOP(AXIS,MINMAX) do { \
UPDATE_ENDSTOP_BIT(AXIS, MINMAX); \ UPDATE_ENDSTOP_BIT(AXIS, MINMAX); \
if (TEST_ENDSTOP(_ENDSTOP(AXIS, MINMAX)) && stepper.current_block->steps[_AXIS(AXIS)] > 0) { \ if (TEST_ENDSTOP(_ENDSTOP(AXIS, MINMAX)) && stepper.current_block->steps[_AXIS(AXIS)] > 0) { \
_ENDSTOP_HIT(AXIS); \ _ENDSTOP_HIT(AXIS); \
stepper.endstop_triggered(_AXIS(AXIS)); \ stepper.endstop_triggered(_AXIS(AXIS)); \
CODE; \
} \ } \
} while(0) } while(0)
#if ENABLED(G38_PROBE_TARGET) && PIN_EXISTS(Z_MIN) // If G38 command then check Z_MIN for every axis and every direction #if ENABLED(G38_PROBE_TARGET) && PIN_EXISTS(Z_MIN_PROBE) && !(CORE_IS_XY || CORE_IS_XZ)
// If G38 command is active check Z_MIN_PROBE for ALL movement
if (G38_move) {
UPDATE_ENDSTOP_BIT(Z, MIN_PROBE);
if (TEST_ENDSTOP(_ENDSTOP(Z, MIN_PROBE))) {
if (stepper.current_block->steps[_AXIS(X)] > 0) { _ENDSTOP_HIT(X); stepper.endstop_triggered(_AXIS(X)); }
else if (stepper.current_block->steps[_AXIS(Y)] > 0) { _ENDSTOP_HIT(Y); stepper.endstop_triggered(_AXIS(Y)); }
else if (stepper.current_block->steps[_AXIS(Z)] > 0) { _ENDSTOP_HIT(Z); stepper.endstop_triggered(_AXIS(Z)); }
G38_endstop_hit = true;
}
}
#endif
#define UPDATE_ENDSTOP(AXIS,MINMAX) do { \ /**
_UPDATE_ENDSTOP(AXIS,MINMAX,NOOP); \ * Define conditions for checking endstops
if (G38_move) _UPDATE_ENDSTOP(Z, MIN, G38_endstop_hit = true); \ */
} while(0)
#else
#define UPDATE_ENDSTOP(AXIS,MINMAX) _UPDATE_ENDSTOP(AXIS,MINMAX,NOOP)
#if IS_CORE
#define S_(N) stepper.current_block->steps[CORE_AXIS_##N]
#define D_(N) stepper.motor_direction(CORE_AXIS_##N)
#endif #endif
#if CORE_IS_XY || CORE_IS_XZ #if CORE_IS_XY || CORE_IS_XZ
// Head direction in -X axis for CoreXY and CoreXZ bots. /**
// If DeltaA == -DeltaB, the movement is only in Y or Z axis * Head direction in -X axis for CoreXY and CoreXZ bots.
if ((stepper.current_block->steps[CORE_AXIS_1] != stepper.current_block->steps[CORE_AXIS_2]) || (stepper.motor_direction(CORE_AXIS_1) == stepper.motor_direction(CORE_AXIS_2))) { *
if (stepper.motor_direction(X_HEAD)) * If steps differ, both axes are moving.
* If DeltaA == -DeltaB, the movement is only in the 2nd axis (Y or Z, handled below)
* If DeltaA == DeltaB, the movement is only in the 1st axis (X)
*/
#if ENABLED(COREXY) || ENABLED(COREXZ)
#define X_CMP ==
#else
#define X_CMP !=
#endif
#define X_MOVE_TEST ( S_(1) != S_(2) || (S_(1) > 0 && D_(1) X_CMP D_(2)) )
#define X_AXIS_HEAD X_HEAD
#else #else
if (stepper.motor_direction(X_AXIS)) // stepping along -X axis (regular Cartesian bot) #define X_MOVE_TEST stepper.current_block->steps[X_AXIS] > 0
#endif #define X_AXIS_HEAD X_AXIS
{ // -direction
#if ENABLED(DUAL_X_CARRIAGE)
// with 2 x-carriages, endstops are only checked in the homing direction for the active extruder
if ((stepper.current_block->active_extruder == 0 && X_HOME_DIR == -1) || (stepper.current_block->active_extruder != 0 && X2_HOME_DIR == -1))
#endif
{
#if HAS_X_MIN
UPDATE_ENDSTOP(X, MIN);
#endif
}
}
else { // +direction
#if ENABLED(DUAL_X_CARRIAGE)
// with 2 x-carriages, endstops are only checked in the homing direction for the active extruder
if ((stepper.current_block->active_extruder == 0 && X_HOME_DIR == 1) || (stepper.current_block->active_extruder != 0 && X2_HOME_DIR == 1))
#endif
{
#if HAS_X_MAX
UPDATE_ENDSTOP(X, MAX);
#endif
}
}
#if CORE_IS_XY || CORE_IS_XZ
}
#endif #endif
#if CORE_IS_XY || CORE_IS_YZ #if CORE_IS_XY || CORE_IS_YZ
// Head direction in -Y axis for CoreXY / CoreYZ bots. /**
// If DeltaA == DeltaB, the movement is only in X or Y axis * Head direction in -Y axis for CoreXY / CoreYZ bots.
if ((stepper.current_block->steps[CORE_AXIS_1] != stepper.current_block->steps[CORE_AXIS_2]) || (stepper.motor_direction(CORE_AXIS_1) != stepper.motor_direction(CORE_AXIS_2))) { *
if (stepper.motor_direction(Y_HEAD)) * If steps differ, both axes are moving
* If DeltaA == DeltaB, the movement is only in the 1st axis (X or Y)
* If DeltaA == -DeltaB, the movement is only in the 2nd axis (Y or Z)
*/
#if ENABLED(COREYX) || ENABLED(COREYZ)
#define Y_CMP ==
#else
#define Y_CMP !=
#endif
#define Y_MOVE_TEST ( S_(1) != S_(2) || (S_(1) > 0 && D_(1) Y_CMP D_(2)) )
#define Y_AXIS_HEAD Y_HEAD
#else #else
if (stepper.motor_direction(Y_AXIS)) // -direction #define Y_MOVE_TEST stepper.current_block->steps[Y_AXIS] > 0
#endif #define Y_AXIS_HEAD Y_AXIS
{ // -direction
#if HAS_Y_MIN
UPDATE_ENDSTOP(Y, MIN);
#endif
}
else { // +direction
#if HAS_Y_MAX
UPDATE_ENDSTOP(Y, MAX);
#endif
}
#if CORE_IS_XY || CORE_IS_YZ
}
#endif #endif
#if CORE_IS_XZ || CORE_IS_YZ #if CORE_IS_XZ || CORE_IS_YZ
// Head direction in -Z axis for CoreXZ or CoreYZ bots. /**
// If DeltaA == DeltaB, the movement is only in X or Y axis * Head direction in -Z axis for CoreXZ or CoreYZ bots.
if ((stepper.current_block->steps[CORE_AXIS_1] != stepper.current_block->steps[CORE_AXIS_2]) || (stepper.motor_direction(CORE_AXIS_1) != stepper.motor_direction(CORE_AXIS_2))) { *
if (stepper.motor_direction(Z_HEAD)) * If steps differ, both axes are moving
* If DeltaA == DeltaB, the movement is only in the 1st axis (X or Y, already handled above)
* If DeltaA == -DeltaB, the movement is only in the 2nd axis (Z)
*/
#if ENABLED(COREZX) || ENABLED(COREZY)
#define Z_CMP ==
#else
#define Z_CMP !=
#endif
#define Z_MOVE_TEST ( S_(1) != S_(2) || (S_(1) > 0 && D_(1) Z_CMP D_(2)) )
#define Z_AXIS_HEAD Z_HEAD
#else #else
if (stepper.motor_direction(Z_AXIS)) #define Z_MOVE_TEST stepper.current_block->steps[Z_AXIS] > 0
#define Z_AXIS_HEAD Z_AXIS
#endif #endif
{ // Z -direction. Gantry down, bed up.
#if HAS_Z_MIN
#if ENABLED(Z_DUAL_ENDSTOPS) // With Dual X, endstops are only checked in the homing direction for the active extruder
#if ENABLED(DUAL_X_CARRIAGE)
#define E0_ACTIVE stepper.current_block->active_extruder == 0
#define X_MIN_TEST ((X_HOME_DIR < 0 && E0_ACTIVE) || (X2_HOME_DIR < 0 && !E0_ACTIVE))
#define X_MAX_TEST ((X_HOME_DIR > 0 && E0_ACTIVE) || (X2_HOME_DIR > 0 && !E0_ACTIVE))
#else
#define X_MIN_TEST true
#define X_MAX_TEST true
#endif
UPDATE_ENDSTOP_BIT(Z, MIN); /**
#if HAS_Z2_MIN * Check and update endstops according to conditions
UPDATE_ENDSTOP_BIT(Z2, MIN); */
#else
COPY_BIT(current_endstop_bits, Z_MIN, Z2_MIN);
#endif
test_dual_z_endstops(Z_MIN, Z2_MIN); if (X_MOVE_TEST) {
if (stepper.motor_direction(X_AXIS_HEAD)) {
#else // !Z_DUAL_ENDSTOPS if (X_MIN_TEST) { // -direction
#if HAS_X_MIN
#if ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN) UPDATE_ENDSTOP(X, MIN);
if (z_probe_enabled) UPDATE_ENDSTOP(Z, MIN);
#else
UPDATE_ENDSTOP(Z, MIN);
#endif
#endif // !Z_DUAL_ENDSTOPS
#endif // HAS_Z_MIN
// When closing the gap check the enabled probe
#if ENABLED(Z_MIN_PROBE_ENDSTOP)
if (z_probe_enabled) {
UPDATE_ENDSTOP(Z, MIN_PROBE);
if (TEST_ENDSTOP(Z_MIN_PROBE)) SBI(endstop_hit_bits, Z_MIN_PROBE);
}
#endif #endif
} }
else { // Z +direction. Gantry up, bed down.
#if HAS_Z_MAX
// Check both Z dual endstops
#if ENABLED(Z_DUAL_ENDSTOPS)
UPDATE_ENDSTOP_BIT(Z, MAX);
#if HAS_Z2_MAX
UPDATE_ENDSTOP_BIT(Z2, MAX);
#else
COPY_BIT(current_endstop_bits, Z_MAX, Z2_MAX);
#endif
test_dual_z_endstops(Z_MAX, Z2_MAX);
// If this pin is not hijacked for the bed probe
// then it belongs to the Z endstop
#elif DISABLED(Z_MIN_PROBE_ENDSTOP) || Z_MAX_PIN != Z_MIN_PROBE_PIN
UPDATE_ENDSTOP(Z, MAX);
#endif // !Z_MIN_PROBE_PIN...
#endif // Z_MAX_PIN
}
#if CORE_IS_XZ || CORE_IS_YZ
} }
#endif else if (X_MAX_TEST) { // +direction
#if HAS_X_MAX
UPDATE_ENDSTOP(X, MAX);
#endif
}
}
if (Y_MOVE_TEST) {
if (stepper.motor_direction(Y_AXIS_HEAD)) { // -direction
#if HAS_Y_MIN
UPDATE_ENDSTOP(Y, MIN);
#endif
}
else { // +direction
#if HAS_Y_MAX
UPDATE_ENDSTOP(Y, MAX);
#endif
}
}
if (Z_MOVE_TEST) {
if (stepper.motor_direction(Z_AXIS_HEAD)) { // Z -direction. Gantry down, bed up.
#if HAS_Z_MIN
#if ENABLED(Z_DUAL_ENDSTOPS)
UPDATE_ENDSTOP_BIT(Z, MIN);
#if HAS_Z2_MIN
UPDATE_ENDSTOP_BIT(Z2, MIN);
#else
COPY_BIT(current_endstop_bits, Z_MIN, Z2_MIN);
#endif
test_dual_z_endstops(Z_MIN, Z2_MIN);
#else // !Z_DUAL_ENDSTOPS
#if ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN)
if (z_probe_enabled) UPDATE_ENDSTOP(Z, MIN);
#else
UPDATE_ENDSTOP(Z, MIN);
#endif
#endif // !Z_DUAL_ENDSTOPS
#endif // HAS_Z_MIN
// When closing the gap check the enabled probe
#if ENABLED(Z_MIN_PROBE_ENDSTOP)
if (z_probe_enabled) {
UPDATE_ENDSTOP(Z, MIN_PROBE);
if (TEST_ENDSTOP(Z_MIN_PROBE)) SBI(endstop_hit_bits, Z_MIN_PROBE);
}
#endif
}
else { // Z +direction. Gantry up, bed down.
#if HAS_Z_MAX
// Check both Z dual endstops
#if ENABLED(Z_DUAL_ENDSTOPS)
UPDATE_ENDSTOP_BIT(Z, MAX);
#if HAS_Z2_MAX
UPDATE_ENDSTOP_BIT(Z2, MAX);
#else
COPY_BIT(current_endstop_bits, Z_MAX, Z2_MAX);
#endif
test_dual_z_endstops(Z_MAX, Z2_MAX);
// If this pin is not hijacked for the bed probe
// then it belongs to the Z endstop
#elif DISABLED(Z_MIN_PROBE_ENDSTOP) || Z_MAX_PIN != Z_MIN_PROBE_PIN
UPDATE_ENDSTOP(Z, MAX);
#endif // !Z_MIN_PROBE_PIN...
#endif // Z_MAX_PIN
}
}
old_endstop_bits = current_endstop_bits; old_endstop_bits = current_endstop_bits;

View File

@@ -92,4 +92,11 @@ class Endstops {
extern Endstops endstops; extern Endstops endstops;
#if HAS_BED_PROBE
#define ENDSTOPS_ENABLED (endstops.enabled || endstops.z_probe_enabled)
#else
#define ENDSTOPS_ENABLED endstops.enabled
#endif
#endif // ENDSTOPS_H #endif // ENDSTOPS_H

View File

@@ -75,6 +75,7 @@ enum DebugFlags {
DEBUG_DRYRUN = _BV(3), ///< Ignore temperature setting and E movement commands DEBUG_DRYRUN = _BV(3), ///< Ignore temperature setting and E movement commands
DEBUG_COMMUNICATION = _BV(4), ///< Not implemented DEBUG_COMMUNICATION = _BV(4), ///< Not implemented
DEBUG_LEVELING = _BV(5), ///< Print detailed output for homing and leveling DEBUG_LEVELING = _BV(5), ///< Print detailed output for homing and leveling
DEBUG_MESH_ADJUST = _BV(6), ///< UBL bed leveling
DEBUG_ALL = 0xFF DEBUG_ALL = 0xFF
}; };
@@ -90,26 +91,6 @@ enum EndstopEnum {
Z2_MAX Z2_MAX
}; };
/**
* Temperature
* Stages in the ISR loop
*/
enum TempState {
PrepareTemp_0,
MeasureTemp_0,
PrepareTemp_BED,
MeasureTemp_BED,
PrepareTemp_1,
MeasureTemp_1,
PrepareTemp_2,
MeasureTemp_2,
PrepareTemp_3,
MeasureTemp_3,
Prepare_FILWIDTH,
Measure_FILWIDTH,
StartupDelay // Startup, delay initial temp reading a tiny bit so the hardware can settle
};
#if ENABLED(EMERGENCY_PARSER) #if ENABLED(EMERGENCY_PARSER)
enum e_parser_state { enum e_parser_state {
state_RESET, state_RESET,
@@ -143,7 +124,9 @@ enum TempState {
FILAMENT_CHANGE_MESSAGE_EXTRUDE, FILAMENT_CHANGE_MESSAGE_EXTRUDE,
FILAMENT_CHANGE_MESSAGE_OPTION, FILAMENT_CHANGE_MESSAGE_OPTION,
FILAMENT_CHANGE_MESSAGE_RESUME, FILAMENT_CHANGE_MESSAGE_RESUME,
FILAMENT_CHANGE_MESSAGE_STATUS FILAMENT_CHANGE_MESSAGE_STATUS,
FILAMENT_CHANGE_MESSAGE_CLICK_TO_HEAT_NOZZLE,
FILAMENT_CHANGE_MESSAGE_WAIT_FOR_NOZZLES_TO_HEAT
}; };
#endif #endif
#endif #endif
@@ -162,23 +145,6 @@ enum TempState {
}; };
#endif #endif
#if ENABLED(MESH_BED_LEVELING)
enum MeshLevelingState {
MeshReport,
MeshStart,
MeshNext,
MeshSet,
MeshSetZOffset,
MeshReset
};
enum MBLStatus {
MBL_STATUS_NONE = 0,
MBL_STATUS_HAS_MESH_BIT = 0,
MBL_STATUS_ACTIVE_BIT = 1
};
#endif
/** /**
* SD Card * SD Card
*/ */
@@ -195,7 +161,7 @@ enum LCDViewAction {
LCDVIEW_CALL_NO_REDRAW LCDVIEW_CALL_NO_REDRAW
}; };
#if ENABLED(DUAL_X_CARRIAGE) #if ENABLED(DUAL_X_CARRIAGE) || ENABLED(DUAL_NOZZLE_DUPLICATION_MODE)
enum DualXMode { enum DualXMode {
DXC_FULL_CONTROL_MODE, DXC_FULL_CONTROL_MODE,
DXC_AUTO_PARK_MODE, DXC_AUTO_PARK_MODE,

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 3.0 #define TEMP_SENSOR_AD595_OFFSET 3.0
#define TEMP_SENSOR_AD595_GAIN 2.0 #define TEMP_SENSOR_AD595_GAIN 2.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
//#define E1_AUTO_FAN_PIN -1 //#define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 35 #define EXTRUDER_AUTO_FAN_TEMPERATURE 35
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 30 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 10 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 1 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 30 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 10 // Y position of hotend
//#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 1 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used //#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

View File

@@ -37,67 +37,67 @@
const unsigned char custom_start_bmp[512] PROGMEM = { const unsigned char custom_start_bmp[512] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x3f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFC, 0x00, 0x00, 0x00,
0x00, 0x00, 0x03, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xC0, 0x00, 0x00,
0x00, 0x00, 0x1f, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xF0, 0x00, 0x00,
0x00, 0x00, 0x7f, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFC, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00,
0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x00,
0x00, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00,
0x00, 0x0f, 0x07, 0x87, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x0F, 0x07, 0x87, 0xFF, 0xFF, 0xE0, 0x00,
0x00, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xf1, 0x00, 0x00, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xF1, 0x00,
0x01, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xf1, 0x80, 0x01, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xF1, 0x80,
0x03, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xf1, 0x80, 0x03, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xF1, 0x80,
0x07, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xe1, 0xc0, 0x07, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xE1, 0xC0,
0x07, 0x1f, 0x8f, 0xc7, 0xc0, 0x00, 0x01, 0xe0, 0x07, 0x1F, 0x8F, 0xC7, 0xC0, 0x00, 0x01, 0xE0,
0x0f, 0x1f, 0x8f, 0xc7, 0xc0, 0x00, 0x01, 0xe0, 0x0F, 0x1F, 0x8F, 0xC7, 0xC0, 0x00, 0x01, 0xE0,
0x0f, 0x1f, 0x8f, 0xc7, 0xc0, 0x00, 0x01, 0xf0, 0x0F, 0x1F, 0x8F, 0xC7, 0xC0, 0x00, 0x01, 0xF0,
0x1f, 0x1f, 0x8f, 0xc7, 0xc0, 0x00, 0x01, 0xf0, 0x1F, 0x1F, 0x8F, 0xC7, 0xC0, 0x00, 0x01, 0xF0,
0x1f, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xe1, 0xf0, 0x1F, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xE1, 0xF0,
0x3f, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xf1, 0xf8, 0x3F, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xF1, 0xF8,
0x3f, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xf1, 0xf8, 0x3F, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xF1, 0xF8,
0x3f, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xf1, 0xf8, 0x3F, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xF1, 0xF8,
0x3f, 0x1f, 0x8f, 0xc7, 0xff, 0xff, 0xe1, 0xf8, 0x3F, 0x1F, 0x8F, 0xC7, 0xFF, 0xFF, 0xE1, 0xF8,
0x7f, 0x1f, 0x8f, 0xc7, 0xc0, 0x00, 0x01, 0xfc, 0x7F, 0x1F, 0x8F, 0xC7, 0xC0, 0x00, 0x01, 0xFC,
0x7f, 0x1f, 0x8f, 0xc7, 0xc0, 0x00, 0x01, 0xfc, 0x7F, 0x1F, 0x8F, 0xC7, 0xC0, 0x00, 0x01, 0xFC,
0x7f, 0x1f, 0x8f, 0xc7, 0xc0, 0x00, 0x01, 0xfc, 0x7F, 0x1F, 0x8F, 0xC7, 0xC0, 0x00, 0x01, 0xFC,
0x7f, 0x1f, 0x8f, 0xc7, 0xc0, 0x00, 0x01, 0xfc, 0x7F, 0x1F, 0x8F, 0xC7, 0xC0, 0x00, 0x01, 0xFC,
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC,
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC,
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC,
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC,
0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC,
0x7f, 0x00, 0x00, 0x07, 0xc7, 0xe3, 0xf1, 0xfc, 0x7F, 0x00, 0x00, 0x07, 0xC7, 0xE3, 0xF1, 0xFC,
0x7f, 0x00, 0x00, 0x07, 0xc7, 0xe3, 0xf1, 0xfc, 0x7F, 0x00, 0x00, 0x07, 0xC7, 0xE3, 0xF1, 0xFC,
0x7f, 0x00, 0x00, 0x07, 0xc7, 0xe3, 0xf1, 0xfc, 0x7F, 0x00, 0x00, 0x07, 0xC7, 0xE3, 0xF1, 0xFC,
0x3f, 0x0f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0xf8, 0x3F, 0x0F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0xF8,
0x3f, 0x1f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0xf8, 0x3F, 0x1F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0xF8,
0x3f, 0x1f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0xf8, 0x3F, 0x1F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0xF8,
0x3f, 0x1f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0xf8, 0x3F, 0x1F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0xF8,
0x1f, 0x1f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0xf0, 0x1F, 0x1F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0xF0,
0x1f, 0x0f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0xf0, 0x1F, 0x0F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0xF0,
0x1f, 0x00, 0x00, 0x07, 0xc7, 0xe3, 0xf1, 0xe0, 0x1F, 0x00, 0x00, 0x07, 0xC7, 0xE3, 0xF1, 0xE0,
0x0f, 0x00, 0x00, 0x07, 0xc7, 0xe3, 0xf1, 0xe0, 0x0F, 0x00, 0x00, 0x07, 0xC7, 0xE3, 0xF1, 0xE0,
0x0f, 0x00, 0x00, 0x07, 0xc7, 0xe3, 0xf1, 0xc0, 0x0F, 0x00, 0x00, 0x07, 0xC7, 0xE3, 0xF1, 0xC0,
0x07, 0x0f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0xc0, 0x07, 0x0F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0xC0,
0x03, 0x1f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0x80, 0x03, 0x1F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0x80,
0x03, 0x1f, 0xff, 0xff, 0xc7, 0xe3, 0xf1, 0x00, 0x03, 0x1F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF1, 0x00,
0x01, 0x1f, 0xff, 0xff, 0xc7, 0xe3, 0xf0, 0x00, 0x01, 0x1F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF0, 0x00,
0x00, 0x1f, 0xff, 0xff, 0xc7, 0xe3, 0xf0, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xC7, 0xE3, 0xF0, 0x00,
0x00, 0x0f, 0xff, 0xff, 0xc3, 0xc1, 0xe0, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xC3, 0xC1, 0xE0, 0x00,
0x00, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00,
0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x00,
0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00,
0x00, 0x01, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00,
0x00, 0x00, 0x7f, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFC, 0x00, 0x00,
0x00, 0x00, 0x1f, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xF0, 0x00, 0x00,
0x00, 0x00, 0x07, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xF8, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; };

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -171,7 +159,7 @@
// Extruder runout prevention. // Extruder runout prevention.
// If the machine is idle and the temperature over MINTEMP // If the machine is idle and the temperature over MINTEMP
// then extrude some filament every couple of SECONDS. // then extrude some filament every couple of SECONDS.
//#define EXTRUDER_RUNOUT_PREVENT #define EXTRUDER_RUNOUT_PREVENT
#if ENABLED(EXTRUDER_RUNOUT_PREVENT) #if ENABLED(EXTRUDER_RUNOUT_PREVENT)
#define EXTRUDER_RUNOUT_MINTEMP 190 #define EXTRUDER_RUNOUT_MINTEMP 190
#define EXTRUDER_RUNOUT_SECONDS 30 #define EXTRUDER_RUNOUT_SECONDS 30
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
//#define E1_AUTO_FAN_PIN -1 //#define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -335,7 +335,7 @@
#define Y_HOME_BUMP_MM 5 #define Y_HOME_BUMP_MM 5
#define Z_HOME_BUMP_MM 2 #define Z_HOME_BUMP_MM 2
#define HOMING_BUMP_DIVISOR {2, 2, 4} // Re-Bump Speed Divisor (Divides the Homing Feedrate) #define HOMING_BUMP_DIVISOR {2, 2, 4} // Re-Bump Speed Divisor (Divides the Homing Feedrate)
//#define QUICK_HOME //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially. #define QUICK_HOME //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially.
// When G28 is called, this option will make Y home before X // When G28 is called, this option will make Y home before X
#define HOME_Y_BEFORE_X #define HOME_Y_BEFORE_X
@@ -369,7 +369,7 @@
#if ENABLED(ULTIPANEL) #if ENABLED(ULTIPANEL)
#define MANUAL_FEEDRATE {50*60, 50*60, 4*60, 60} // Feedrates for manual moves along X, Y, Z, E from panel #define MANUAL_FEEDRATE {50*60, 50*60, 4*60, 60} // Feedrates for manual moves along X, Y, Z, E from panel
#define ULTIPANEL_FEEDMULTIPLY // Comment to disable setting feedrate multiplier via encoder //#define ULTIPANEL_FEEDMULTIPLY // Comment to disable setting feedrate multiplier via encoder
#endif #endif
// @section extras // @section extras
@@ -393,18 +393,37 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
* @section stepper motor current
*
* Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
#define DIGIPOT_MOTOR_CURRENT {150, 170, 180, 190, 180} // Values 0-255 (bq ZUM Mega 3D (default): X = 150 [~1.17A]; Y = 170 [~1.33A]; Z = 180 [~1.41A]; E0 = 190 [~1.49A]) #define DIGIPOT_MOTOR_CURRENT {150, 170, 180, 190, 180} // Values 0-255 (bq ZUM Mega 3D (default): X = 150 [~1.17A]; Y = 170 [~1.33A]; Z = 180 [~1.41A]; E0 = 190 [~1.49A])
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) //#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -420,10 +439,10 @@
// @section lcd // @section lcd
// Include a page of printer information in the LCD Main Menu // Include a page of printer information in the LCD Main Menu
//#define LCD_INFO_MENU #define LCD_INFO_MENU
// On the Info Screen, display XY with one decimal place when possible // On the Info Screen, display XY with one decimal place when possible
//#define LCD_DECIMAL_SMALL_XY #define LCD_DECIMAL_SMALL_XY
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
@@ -440,7 +459,43 @@
#define SDCARD_RATHERRECENTFIRST //reverse file order of sd card menu display. Its sorted practically after the file system block order. #define SDCARD_RATHERRECENTFIRST //reverse file order of sd card menu display. Its sorted practically after the file system block order.
// if a file is deleted, it frees a block. hence, the order is not purely chronological. To still have auto0.g accessible, there is again the option to do that. // if a file is deleted, it frees a block. hence, the order is not purely chronological. To still have auto0.g accessible, there is again the option to do that.
// using: // using:
#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +509,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -470,7 +527,7 @@
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT #define USE_BIG_EDIT_FONT
// A smaller font may be used on the Info Screen. Costs 2300 bytes of PROGMEM. // A smaller font may be used on the Info Screen. Costs 2300 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
@@ -496,45 +553,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +592,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +637,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +655,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -622,9 +682,9 @@
// The number of linear motions that can be in the plan at any give time. // The number of linear motions that can be in the plan at any give time.
// THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ring-buffering. // THE BLOCK_BUFFER_SIZE NEEDS TO BE A POWER OF 2, i.g. 8,16,32 because shifts and ors are used to do the ring-buffering.
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
#define BLOCK_BUFFER_SIZE 16 // SD,LCD,Buttons take more memory, block buffer needs to be smaller #define BLOCK_BUFFER_SIZE 32 // SD,LCD,Buttons take more memory, block buffer needs to be smaller
#else #else
#define BLOCK_BUFFER_SIZE 16 // maximize block buffer #define BLOCK_BUFFER_SIZE 64 // maximize block buffer
#endif #endif
// @section serial // @section serial
@@ -640,7 +700,7 @@
// For debug-echo: 128 bytes for the optimal speed. // For debug-echo: 128 bytes for the optimal speed.
// Other output doesn't need to be that speedy. // Other output doesn't need to be that speedy.
// :[0, 2, 4, 8, 16, 32, 64, 128, 256] // :[0, 2, 4, 8, 16, 32, 64, 128, 256]
#define TX_BUFFER_SIZE 0 #define TX_BUFFER_SIZE 32
// Enable an emergency-command parser to intercept certain commands as they // Enable an emergency-command parser to intercept certain commands as they
// enter the serial receive buffer, so they cannot be blocked. // enter the serial receive buffer, so they cannot be blocked.
@@ -677,43 +737,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +797,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +839,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +872,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E3_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E3_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1017,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1069,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1110,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1124,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

View File

@@ -12,3 +12,4 @@ NOTE: The look and feel of the Hephestos 2 while navigating the LCD menu will ch
SD printing now disables the heater when finished SD printing now disables the heater when finished
* 2016/07/13 - Update the `DEFAULT_AXIS_STEPS_PER_UNIT` for the Z axis * 2016/07/13 - Update the `DEFAULT_AXIS_STEPS_PER_UNIT` for the Z axis
Increased the `DEFAULT_XYJERK` Increased the `DEFAULT_XYJERK`
* 2016/12/13 - Configuration updated.

View File

@@ -36,35 +36,35 @@
#define CUSTOM_BOOTSCREEN_BMPHEIGHT 64 #define CUSTOM_BOOTSCREEN_BMPHEIGHT 64
const unsigned char custom_start_bmp[512] PROGMEM = { const unsigned char custom_start_bmp[512] PROGMEM = {
0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xF0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x1f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x1f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x1f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x1f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x1f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x00,
0x00, 0x03, 0xc0, 0x0f, 0xf0, 0x07, 0x80, 0x00, 0x00, 0x03, 0xC0, 0x0F, 0xF0, 0x07, 0x80, 0x00,
0x00, 0x07, 0xe0, 0x07, 0xe0, 0x0f, 0xc0, 0x00, 0x00, 0x07, 0xE0, 0x07, 0xE0, 0x0F, 0xC0, 0x00,
0x00, 0x0f, 0xf0, 0x03, 0xc0, 0x1f, 0xe0, 0x00, 0x00, 0x0F, 0xF0, 0x03, 0xC0, 0x1F, 0xE0, 0x00,
0x00, 0x1f, 0xf8, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x3F, 0xF0, 0x00,
0x00, 0x1f, 0xf8, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x3F, 0xF0, 0x00,
0x00, 0x1f, 0xf8, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x3F, 0xF0, 0x00,
0x00, 0x1f, 0xf8, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x3F, 0xF0, 0x00,
0x00, 0x1f, 0xf8, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x3F, 0xF0, 0x00,
0x00, 0x0f, 0xf0, 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x0F, 0xF0, 0x00, 0x00, 0x1F, 0xE0, 0x00,
0x00, 0x07, 0xe0, 0x00, 0x00, 0x0f, 0xc0, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0x0F, 0xC0, 0x00,
0x00, 0x03, 0xc0, 0x00, 0x00, 0x07, 0x80, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x07, 0x80, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xF8,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFC,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFC,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFC,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFC,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFC,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFC,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFC,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xF8,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -73,28 +73,28 @@ const unsigned char custom_start_bmp[512] PROGMEM = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x1e, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00,
0x3f, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00,
0x7f, 0x80, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x7F, 0x80, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00,
0xff, 0xc0, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xFF, 0xC0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00,
0xff, 0xc0, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xFF, 0xC0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00,
0xff, 0xc0, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xFF, 0xC0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00,
0xff, 0xc0, 0x00, 0x00, 0xf7, 0xc0, 0x1f, 0x80, 0xFF, 0xC0, 0x00, 0x00, 0xF7, 0xC0, 0x1F, 0x80,
0xff, 0xc0, 0x00, 0x00, 0xff, 0xf0, 0x7f, 0xc0, 0xFF, 0xC0, 0x00, 0x00, 0xFF, 0xF0, 0x7F, 0xC0,
0x7f, 0x80, 0x00, 0x00, 0xff, 0xf8, 0xff, 0xe0, 0x7F, 0x80, 0x00, 0x00, 0xFF, 0xF8, 0xFF, 0xE0,
0x3f, 0x00, 0x00, 0x00, 0xfc, 0xf8, 0xf0, 0xf8, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0xF8, 0xF0, 0xF8,
0x1e, 0x00, 0x00, 0x00, 0xf8, 0x7d, 0xe0, 0x78, 0x1E, 0x00, 0x00, 0x00, 0xF8, 0x7D, 0xE0, 0x78,
0x00, 0x00, 0x00, 0x00, 0xf0, 0x3d, 0xe0, 0x78, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3D, 0xE0, 0x78,
0x00, 0x00, 0x00, 0x00, 0xf0, 0x3d, 0xe0, 0x78, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3D, 0xE0, 0x78,
0x00, 0x00, 0x00, 0x00, 0xf0, 0x3d, 0xe0, 0x78, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3D, 0xE0, 0x78,
0x00, 0x00, 0x00, 0x00, 0xf0, 0x3d, 0xe0, 0x78, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3D, 0xE0, 0x78,
0x00, 0x00, 0x00, 0x00, 0xf0, 0x3d, 0xe0, 0x78, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3D, 0xE0, 0x78,
0x00, 0x00, 0x00, 0x00, 0xf0, 0x3d, 0xe0, 0x78, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3D, 0xE0, 0x78,
0x00, 0x00, 0x00, 0x00, 0xf8, 0x79, 0xf0, 0xf8, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x79, 0xF0, 0xF8,
0x00, 0x00, 0x00, 0x00, 0xff, 0xf8, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xF8, 0xFF, 0xF8,
0x00, 0x00, 0x00, 0x00, 0x3f, 0xf0, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF0, 0x7F, 0xF8,
0x00, 0x00, 0x00, 0x00, 0x0f, 0xe0, 0x3f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xE0, 0x3F, 0xF8,
0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x0e, 0x78, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x0E, 0x78,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78,

File diff suppressed because it is too large Load Diff

View File

@@ -41,18 +41,6 @@
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -199,12 +187,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -234,6 +229,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -268,7 +264,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -298,6 +293,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -321,13 +317,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -339,7 +335,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -406,18 +406,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -455,6 +473,42 @@
// using: // using:
#define MENU_ADDAUTOSTART #define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
#define LCD_PROGRESS_BAR #define LCD_PROGRESS_BAR
@@ -467,6 +521,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -479,8 +535,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -509,45 +582,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
#define BABYSTEPPING #define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -571,19 +621,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 140 // start value for PLA on K8200 #define LIN_ADVANCE_K 140 // start value for PLA on K8200
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -596,6 +666,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -609,6 +684,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -690,43 +766,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
#define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS (X_MAX_POS-3) // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS (X_MAX_POS-3) // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -739,6 +826,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -780,27 +868,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -813,181 +901,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -1010,6 +1046,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1061,6 +1098,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1097,7 +1139,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1111,4 +1153,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

View File

@@ -4,7 +4,7 @@
* updated manually with parameters from genuine Vellemann Firmware "firmware_k8200_marlinv2" based on the recent development branch * updated manually with parameters from genuine Vellemann Firmware "firmware_k8200_marlinv2" based on the recent development branch
* VM8201 uses "DISPLAY_CHARSET_HD44870_JAPAN" and "ULTIMAKERCONTROLLER" * VM8201 uses "DISPLAY_CHARSET_HD44870 JAPANESE" and "ULTIMAKERCONTROLLER"
* german (de) translation with umlaut is supported now - thanks to @AnHardt for the great hardware based umlaut support * german (de) translation with umlaut is supported now - thanks to @AnHardt for the great hardware based umlaut support
I [@CONSULitAS](https://github.com/CONSULitAS) tested the changes on my K8200 with 20x4-LCD and Arduino 1.6.12 for Mac (SD library added to IDE manually), 2016-11-18 - everything works well. I [@CONSULitAS](https://github.com/CONSULitAS) tested the changes on my K8200 with 20x4-LCD and Arduino 1.6.12 for Mac (SD library added to IDE manually), 2016-11-18 - everything works well.

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN 2 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
#define CONTROLLER_FAN_PIN 2 // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
#define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 100 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 100 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 20 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 5 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 100 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 100 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 600 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 20 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 5 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 600 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 600 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 100 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 100 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN 4 // RigidBot: Fans/Water Pump to cool the hotend cool side. *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
#define CONTROLLER_FAN_PIN 4 // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,20 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
*
/********************************************************** * The fan will turn on automatically whenever any stepper is enabled
Fan Pins * and turn off after a set period after all steppers are turned off.
Fan_0 8 - Extruder 0 fan */
Fan_1 6 - Extruder 1 fan #define USE_CONTROLLER_FAN
Fan_2 2 - Case fan #if ENABLED(USE_CONTROLLER_FAN)
***********************************************************/ #define CONTROLLER_FAN_PIN 2 // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_PIN 2 //Pin used for the fan to cool controller (-1 to disable) #define CONTROLLERFAN_SPEED 130 // 255 == full speed
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run #endif
#define CONTROLLERFAN_SPEED 130 // 255 == full speed
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -229,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -263,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -293,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -316,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -334,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -401,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,4,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,4,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {175,175,240,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -450,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -462,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -474,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -504,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -566,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -591,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -604,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -685,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
#define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -734,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -775,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -808,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -1005,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1056,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1092,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1106,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -94,8 +82,8 @@
* Thermal Protection parameters for the bed are just as above for hotends. * Thermal Protection parameters for the bed are just as above for hotends.
*/ */
#if ENABLED(THERMAL_PROTECTION_BED) #if ENABLED(THERMAL_PROTECTION_BED)
#define THERMAL_PROTECTION_BED_PERIOD 120 // Seconds #define THERMAL_PROTECTION_BED_PERIOD 20 // Seconds
#define THERMAL_PROTECTION_BED_HYSTERESIS 4 // Degrees Celsius #define THERMAL_PROTECTION_BED_HYSTERESIS 2 // Degrees Celsius
/** /**
* Whenever an M140 or M190 increases the target temperature the firmware will wait for the * Whenever an M140 or M190 increases the target temperature the firmware will wait for the
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine/test this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,14 +322,18 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
//homing hits the endstop, then retracts by this distance, before it tries to slowly bump again: //homing hits the endstop, then retracts by this distance, before it tries to slowly bump again:
#define X_HOME_BUMP_MM 5 #define X_HOME_BUMP_MM 5
#define Y_HOME_BUMP_MM 5 #define Y_HOME_BUMP_MM 5
#define Z_HOME_BUMP_MM 5 // deltas need the same for all three axis #define Z_HOME_BUMP_MM 5 // deltas need the same for all three axes
#define HOMING_BUMP_DIVISOR {10, 10, 10} // Re-Bump Speed Divisor (Divides the Homing Feedrate) #define HOMING_BUMP_DIVISOR {10, 10, 10} // Re-Bump Speed Divisor (Divides the Homing Feedrate)
//#define QUICK_HOME //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially. //#define QUICK_HOME //if this is defined, if both x and y are to be homed, a diagonal move will be performed initially.
@@ -356,7 +356,7 @@
// Default stepper release if idle. Set to 0 to deactivate. // Default stepper release if idle. Set to 0 to deactivate.
// Steppers will shut down DEFAULT_STEPPER_DEACTIVE_TIME seconds after the last move when DISABLE_INACTIVE_? is true. // Steppers will shut down DEFAULT_STEPPER_DEACTIVE_TIME seconds after the last move when DISABLE_INACTIVE_? is true.
// Time can be set by M18 and M84. // Time can be set by M18 and M84.
#define DEFAULT_STEPPER_DEACTIVE_TIME 0 #define DEFAULT_STEPPER_DEACTIVE_TIME 60
#define DISABLE_INACTIVE_X true #define DISABLE_INACTIVE_X true
#define DISABLE_INACTIVE_Y true #define DISABLE_INACTIVE_Y true
#define DISABLE_INACTIVE_Z true // set to false if the nozzle will fall down on your printed part when print has finished. #define DISABLE_INACTIVE_Z true // set to false if the nozzle will fall down on your printed part when print has finished.
@@ -395,18 +395,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -427,6 +445,9 @@
// On the Info Screen, display XY with one decimal place when possible // On the Info Screen, display XY with one decimal place when possible
//#define LCD_DECIMAL_SMALL_XY //#define LCD_DECIMAL_SMALL_XY
// The timeout (in ms) to return to the status screen from sub-menus
//#define LCD_TIMEOUT_TO_STATUS 15000
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
// Some RAMPS and other boards don't detect when an SD card is inserted. You can work // Some RAMPS and other boards don't detect when an SD card is inserted. You can work
@@ -444,6 +465,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -456,6 +513,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -468,8 +527,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -498,45 +574,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions //#define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -560,19 +613,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -585,6 +658,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -598,6 +676,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -667,55 +746,66 @@
// until then, intended retractions can be detected by moves that only extrude and the direction. // until then, intended retractions can be detected by moves that only extrude and the direction.
// the moves are than replaced by the firmware controlled ones. // the moves are than replaced by the firmware controlled ones.
#define FWRETRACT //ONLY PARTIALLY TESTED //#define FWRETRACT //ONLY PARTIALLY TESTED
#if ENABLED(FWRETRACT) #if ENABLED(FWRETRACT)
#define MIN_RETRACT 0.1 //minimum extruded mm to accept a automatic gcode retraction attempt #define MIN_RETRACT 0.1 //minimum extruded mm to accept a automatic gcode retraction attempt
#define RETRACT_LENGTH 5 //default retract length (positive mm) #define RETRACT_LENGTH 3 //default retract length (positive mm)
#define RETRACT_LENGTH_SWAP 13 //default swap retract length (positive mm), for extruder change #define RETRACT_LENGTH_SWAP 13 //default swap retract length (positive mm), for extruder change
#define RETRACT_FEEDRATE 100 //default feedrate for retracting (mm/s) #define RETRACT_FEEDRATE 45 //default feedrate for retracting (mm/s)
#define RETRACT_ZLIFT 0 //default retract Z-lift #define RETRACT_ZLIFT 0 //default retract Z-lift
#define RETRACT_RECOVER_LENGTH 0 //default additional recover length (mm, added to retract length when recovering) #define RETRACT_RECOVER_LENGTH 0 //default additional recover length (mm, added to retract length when recovering)
#define RETRACT_RECOVER_LENGTH_SWAP 0 //default additional swap recover length (mm, added to retract length when recovering from extruder change) #define RETRACT_RECOVER_LENGTH_SWAP 0 //default additional swap recover length (mm, added to retract length when recovering from extruder change)
#define RETRACT_RECOVER_FEEDRATE 100 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -728,6 +818,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -769,27 +860,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -802,181 +893,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -999,6 +1038,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1050,6 +1090,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1086,7 +1131,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1100,4 +1145,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,4 +1,4 @@
/** /**
* Marlin 3D Printer Firmware * Marlin 3D Printer Firmware
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* *
@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -395,18 +395,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -444,6 +462,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -456,6 +510,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -468,8 +524,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -498,45 +571,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -560,19 +610,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -585,6 +655,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -598,6 +673,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -679,43 +755,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -728,6 +815,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -769,27 +857,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -802,181 +890,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -999,6 +1035,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1050,6 +1087,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1086,7 +1128,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1100,4 +1142,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

View File

@@ -1,4 +1,4 @@
/** /**
* Marlin 3D Printer Firmware * Marlin 3D Printer Firmware
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* *
@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -395,18 +395,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -444,6 +462,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -456,6 +510,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -468,8 +524,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -498,45 +571,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -560,19 +610,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -585,6 +655,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -598,6 +673,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -679,43 +755,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -728,6 +815,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -769,27 +857,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -802,181 +890,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -999,6 +1035,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1050,6 +1087,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1086,7 +1128,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1100,4 +1142,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

View File

@@ -1,4 +1,4 @@
/** /**
* Marlin 3D Printer Firmware * Marlin 3D Printer Firmware
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* *
@@ -37,18 +37,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -191,12 +179,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -226,6 +221,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -260,7 +256,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -290,6 +285,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -313,13 +309,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -331,7 +327,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -400,18 +400,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -449,6 +467,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -461,6 +515,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -473,8 +529,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -503,45 +576,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -565,19 +615,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -590,6 +660,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -603,6 +678,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -684,43 +760,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -733,6 +820,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -774,27 +862,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -807,181 +895,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -1004,6 +1040,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1055,6 +1092,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1091,7 +1133,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1105,4 +1147,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

View File

@@ -1,4 +1,4 @@
/** /**
* Marlin 3D Printer Firmware * Marlin 3D Printer Firmware
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin] * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
* *
@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -395,18 +395,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -444,6 +462,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -456,6 +510,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -468,8 +524,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -498,45 +571,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -560,19 +610,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -585,6 +655,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -598,6 +673,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -679,43 +755,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -728,6 +815,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -769,27 +857,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -802,181 +890,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -999,6 +1035,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1050,6 +1087,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1086,7 +1128,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1100,4 +1142,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,108 @@
/**
* 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
*/
//custom screen can be up to 112 wide and 64 high
#include <avr/pgmspace.h>
#define CUSTOM_BOOTSCREEN_TIMEOUT 2500
#define CUSTOM_BOOTSCREEN_BMPWIDTH 112
#define CUSTOM_BOOTSCREEN_BMPHEIGHT 64
// Width: 112, Height: 64
const unsigned char custom_start_bmp[896] PROGMEM = {
0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x00, 0x00, 0x01, 0xf9, 0x00, 0x00, 0x03, 0xf8, 0x00, 0x00, 0x01, 0xc0, 0x01,
0x80, 0x00, 0x00, 0x06, 0x4d, 0x00, 0x00, 0x07, 0x38, 0x00, 0x00, 0x01, 0xc0, 0x01,
0x80, 0x00, 0x00, 0x0c, 0x26, 0x00, 0x0e, 0xe7, 0x39, 0xd3, 0xe1, 0xf3, 0xe7, 0xc1,
0x80, 0x00, 0x00, 0x19, 0x12, 0x00, 0x0f, 0xe7, 0x39, 0xf7, 0xf3, 0xfb, 0xef, 0xe1,
0x80, 0x00, 0x00, 0x37, 0xce, 0x00, 0x0e, 0xe7, 0x01, 0xf7, 0x73, 0xb9, 0xce, 0xe1,
0x80, 0x00, 0x00, 0x64, 0x66, 0x00, 0x0e, 0xe7, 0x01, 0xc7, 0xf3, 0xb9, 0xcf, 0xe1,
0x80, 0x00, 0x00, 0x4b, 0xa6, 0x00, 0x0e, 0xe7, 0x39, 0xc7, 0xf0, 0xf9, 0xcf, 0xe1,
0x80, 0x00, 0x00, 0xca, 0xb4, 0x00, 0x0f, 0xe7, 0x39, 0xc7, 0x03, 0xf9, 0xce, 0x01,
0x80, 0x00, 0x00, 0xcd, 0xa4, 0x00, 0x06, 0xe7, 0x39, 0xc7, 0x73, 0xb9, 0xce, 0xe1,
0x80, 0x00, 0x03, 0xa6, 0x6c, 0x00, 0x00, 0xe7, 0x39, 0xc7, 0x73, 0xb9, 0xce, 0xe1,
0x80, 0x00, 0xff, 0x13, 0xd8, 0x00, 0x0e, 0xe3, 0xf1, 0xc7, 0xf3, 0xf9, 0xef, 0xe1,
0x80, 0x01, 0x21, 0x88, 0x18, 0x00, 0x0f, 0xe1, 0xe1, 0xc3, 0xe1, 0xb9, 0xe7, 0xc1,
0x80, 0x06, 0x61, 0x16, 0x30, 0x00, 0x07, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x04, 0x41, 0x23, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x04, 0xfe, 0x41, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x0b, 0x86, 0x8f, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x1f, 0x80, 0x00, 0x00, 0x01,
0x80, 0x1e, 0x01, 0x9a, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x1f, 0x80, 0x00, 0x00, 0x01,
0x80, 0x1c, 0x07, 0x22, 0x00, 0x00, 0x07, 0xbc, 0x3f, 0x9f, 0x81, 0xf8, 0xf1, 0xe1,
0x80, 0x08, 0x1f, 0xe2, 0x00, 0x00, 0x0f, 0xfc, 0x3f, 0xbf, 0x87, 0xfe, 0x71, 0xc1,
0x80, 0x00, 0x33, 0x62, 0x00, 0x00, 0x0f, 0x3c, 0x3d, 0xb7, 0x87, 0x9e, 0x7b, 0xc1,
0x80, 0x00, 0xc2, 0x22, 0x00, 0x00, 0x0f, 0x3c, 0x3d, 0xb7, 0x87, 0x9e, 0x7b, 0xc1,
0x80, 0x00, 0xc2, 0x3e, 0x00, 0x00, 0x0f, 0x3c, 0x3d, 0xf7, 0x80, 0x7e, 0x3b, 0x81,
0x80, 0x01, 0xe6, 0x1e, 0x00, 0x00, 0x0f, 0x3c, 0x3d, 0xf7, 0x83, 0xfe, 0x3f, 0x81,
0x80, 0x01, 0x3c, 0x12, 0x00, 0x00, 0x0f, 0x3c, 0x3d, 0xf7, 0x87, 0x9e, 0x3b, 0x81,
0x80, 0x01, 0x1c, 0x26, 0x00, 0x00, 0x0f, 0xfc, 0x3d, 0xf7, 0x87, 0x9e, 0x7b, 0xc1,
0x80, 0x01, 0x70, 0x64, 0x00, 0x00, 0x07, 0xbc, 0x3c, 0xe7, 0x87, 0x9e, 0x7b, 0xc1,
0x80, 0x03, 0xc0, 0x58, 0x00, 0x00, 0x00, 0x3c, 0x3c, 0xe7, 0x87, 0xfe, 0x71, 0xc1,
0x80, 0x0d, 0x80, 0xf0, 0x00, 0x00, 0x0f, 0x3c, 0x3c, 0xe7, 0x83, 0xde, 0xf1, 0xe1,
0x80, 0x1a, 0x00, 0xe0, 0x00, 0x00, 0x0f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x26, 0x00, 0x40, 0x00, 0x00, 0x03, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x80, 0xb2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x81, 0x06, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1c, 0x03, 0xc0, 0x20, 0x10, 0x00, 0x01,
0x83, 0x24, 0x00, 0x00, 0x00, 0x00, 0x08, 0x92, 0x02, 0x20, 0x00, 0x10, 0x00, 0x01,
0x02, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91, 0x02, 0x23, 0x27, 0x39, 0x8c, 0xe1,
0x06, 0x38, 0x00, 0x00, 0x00, 0x00, 0x03, 0x11, 0x03, 0xc2, 0x24, 0x92, 0x49, 0x01,
0x04, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91, 0x02, 0x02, 0x24, 0x93, 0xc8, 0xc1,
0x0d, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x08, 0x92, 0x02, 0x02, 0x24, 0x92, 0x08, 0x21,
0x08, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1c, 0x02, 0x02, 0x24, 0x99, 0xc9, 0xc1,
0x18, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x10, 0x30, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x0f, 0xe0, 0x0f, 0x00, 0x01,
0x30, 0x20, 0x00, 0x37, 0x00, 0x00, 0x00, 0x12, 0x24, 0x08, 0x10, 0x09, 0x00, 0x01,
0x20, 0x30, 0x00, 0x6d, 0x80, 0x00, 0x00, 0x12, 0x24, 0x09, 0x88, 0x09, 0x00, 0x01,
0x10, 0x18, 0x1f, 0x60, 0xc0, 0x00, 0x00, 0x12, 0x24, 0x09, 0x48, 0x09, 0x00, 0x01,
0x30, 0x0c, 0x39, 0xe0, 0x60, 0x00, 0x00, 0x12, 0x24, 0x09, 0x90, 0x09, 0x00, 0x01,
0x30, 0x07, 0x90, 0x70, 0x60, 0x00, 0x00, 0x12, 0x24, 0x08, 0x60, 0x09, 0x00, 0x01,
0x10, 0x16, 0xf0, 0x18, 0x20, 0x00, 0x00, 0x12, 0x24, 0x08, 0x10, 0x09, 0x00, 0x01,
0x1a, 0x10, 0x60, 0x08, 0x30, 0x00, 0x00, 0x12, 0x24, 0x09, 0xc8, 0x09, 0x00, 0x01,
0x0b, 0x09, 0x80, 0x00, 0x30, 0x00, 0x00, 0x12, 0x24, 0x09, 0x24, 0x09, 0x00, 0x01,
0x0e, 0x07, 0x80, 0x00, 0x10, 0x00, 0x00, 0x13, 0xe4, 0x89, 0xc4, 0x89, 0xf9, 0x01,
0x06, 0x1e, 0x40, 0x10, 0x10, 0x00, 0x00, 0x10, 0x05, 0xc8, 0x09, 0xc8, 0x0b, 0x81,
0x06, 0x00, 0x40, 0x20, 0x10, 0x00, 0x00, 0x0f, 0xf8, 0x8f, 0xf0, 0x8f, 0xf9, 0x01,
0x03, 0x80, 0x00, 0x20, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x01, 0xff, 0xff, 0xff, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
};

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN -1 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
//#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
//#define CONTROLLER_FAN_PIN FAN1_PIN // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 4 #define DIGIPOT_I2C_NUM_CHANNELS 4 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS { 1.7, 1.7, 1.7, 1.7 } #define DIGIPOT_I2C_MOTOR_CURRENTS { 1.7, 1.7, 1.7, 1.7 } // 5DPRINT
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

View File

@@ -32,18 +32,6 @@
*/ */
#ifndef CONFIGURATION_ADV_H #ifndef CONFIGURATION_ADV_H
#define CONFIGURATION_ADV_H #define CONFIGURATION_ADV_H
/**
*
* ***********************************
* ** ATTENTION TO ALL DEVELOPERS **
* ***********************************
*
* You must increment this version number for every significant change such as,
* but not limited to: ADD, DELETE RENAME OR REPURPOSE any directive/option.
*
* Note: Update also Version.h !
*/
#define CONFIGURATION_ADV_H_VERSION 010100 #define CONFIGURATION_ADV_H_VERSION 010100
// @section temperature // @section temperature
@@ -186,12 +174,19 @@
#define TEMP_SENSOR_AD595_OFFSET 0.0 #define TEMP_SENSOR_AD595_OFFSET 0.0
#define TEMP_SENSOR_AD595_GAIN 1.0 #define TEMP_SENSOR_AD595_GAIN 1.0
//This is for controlling a fan to cool down the stepper drivers /**
//it will turn on when any driver is enabled * Controller Fan
//and turn off after the set amount of seconds from last driver being disabled again * To cool down the stepper drivers and MOSFETs.
#define CONTROLLERFAN_PIN 23 //Pin used for the fan to cool controller (-1 to disable) *
#define CONTROLLERFAN_SECS 60 //How many seconds, after all motors were disabled, the fan should run * The fan will turn on automatically whenever any stepper is enabled
#define CONTROLLERFAN_SPEED 255 // == full speed * and turn off after a set period after all steppers are turned off.
*/
#define USE_CONTROLLER_FAN
#if ENABLED(USE_CONTROLLER_FAN)
#define CONTROLLER_FAN_PIN 23 // Set a custom pin for the controller fan
#define CONTROLLERFAN_SECS 60 // Duration in seconds for the fan to run after all motors are disabled
#define CONTROLLERFAN_SPEED 255 // 255 == full speed
#endif
// When first starting the main fan, run it at full speed for the // When first starting the main fan, run it at full speed for the
// given number of milliseconds. This gets the fan spinning reliably // given number of milliseconds. This gets the fan spinning reliably
@@ -221,6 +216,7 @@
#define E1_AUTO_FAN_PIN -1 #define E1_AUTO_FAN_PIN -1
#define E2_AUTO_FAN_PIN -1 #define E2_AUTO_FAN_PIN -1
#define E3_AUTO_FAN_PIN -1 #define E3_AUTO_FAN_PIN -1
#define E4_AUTO_FAN_PIN -1
#define EXTRUDER_AUTO_FAN_TEMPERATURE 50 #define EXTRUDER_AUTO_FAN_TEMPERATURE 50
#define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed #define EXTRUDER_AUTO_FAN_SPEED 255 // == full speed
@@ -255,7 +251,6 @@
#define INVERT_X2_VS_X_DIR true #define INVERT_X2_VS_X_DIR true
#endif #endif
// Dual Y Steppers // Dual Y Steppers
// Uncomment this option to drive two Y axis motors. // Uncomment this option to drive two Y axis motors.
// The next unused E driver will be assigned to the second Y stepper. // The next unused E driver will be assigned to the second Y stepper.
@@ -285,6 +280,7 @@
#if ENABLED(Z_DUAL_ENDSTOPS) #if ENABLED(Z_DUAL_ENDSTOPS)
#define Z2_USE_ENDSTOP _XMAX_ #define Z2_USE_ENDSTOP _XMAX_
#define Z_DUAL_ENDSTOPS_ADJUSTMENT 0 // use M666 command to determine this value
#endif #endif
#endif // Z_DUAL_STEPPER_DRIVERS #endif // Z_DUAL_STEPPER_DRIVERS
@@ -308,13 +304,13 @@
// Remember: you should set the second extruder x-offset to 0 in your slicer. // Remember: you should set the second extruder x-offset to 0 in your slicer.
// There are a few selectable movement modes for dual x-carriages using M605 S<mode> // There are a few selectable movement modes for dual x-carriages using M605 S<mode>
// Mode 0: Full control. The slicer has full control over both x-carriages and can achieve optimal travel results // Mode 0 (DXC_FULL_CONTROL_MODE): Full control. The slicer has full control over both x-carriages and can achieve optimal travel results
// as long as it supports dual x-carriages. (M605 S0) // as long as it supports dual x-carriages. (M605 S0)
// Mode 1: Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so // Mode 1 (DXC_AUTO_PARK_MODE) : Auto-park mode. The firmware will automatically park and unpark the x-carriages on tool changes so
// that additional slicer support is not required. (M605 S1) // that additional slicer support is not required. (M605 S1)
// Mode 2: Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all // Mode 2 (DXC_DUPLICATION_MODE) : Duplication mode. The firmware will transparently make the second x-carriage and extruder copy all
// actions of the first x-carriage. This allows the printer to print 2 arbitrary items at // actions of the first x-carriage. This allows the printer to print 2 arbitrary items at
// once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm]) // once. (2nd extruder x offset and temp offset are set using: M605 S2 [Xnnn] [Rmmm])
// This is the default power-up mode which can be later using M605. // This is the default power-up mode which can be later using M605.
#define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE #define DEFAULT_DUAL_X_CARRIAGE_MODE DXC_FULL_CONTROL_MODE
@@ -326,7 +322,11 @@
// Default x offset in duplication mode (typically set to half print bed width) // Default x offset in duplication mode (typically set to half print bed width)
#define DEFAULT_DUPLICATION_X_OFFSET 100 #define DEFAULT_DUPLICATION_X_OFFSET 100
#endif //DUAL_X_CARRIAGE #endif // DUAL_X_CARRIAGE
// Activate a solenoid on the active extruder with M380. Disable all with M381.
// Define SOL0_PIN, SOL1_PIN, etc., for each extruder that has a solenoid.
//#define EXT_SOLENOID
// @section homing // @section homing
@@ -393,18 +393,36 @@
// Microstep setting (Only functional when stepper driver microstep pins are connected to MCU. // Microstep setting (Only functional when stepper driver microstep pins are connected to MCU.
#define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16] #define MICROSTEP_MODES {16,16,16,16,16} // [1,2,4,8,16]
// Motor Current setting (Only functional when motor driver current ref pins are connected to a digital trimpot on supported boards) /**
#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A) * @section stepper motor current
*
// Motor Current controlled via PWM (Overridable on supported boards with PWM-driven motor driver current) * Some boards have a means of setting the stepper motor current via firmware.
*
* The power on motor currents are set by:
* PWM_MOTOR_CURRENT - used by MINIRAMBO & ULTIMAIN_2
* known compatible chips: A4982
* DIGIPOT_MOTOR_CURRENT - used by BQ_ZUM_MEGA_3D, RAMBO & SCOOVO_X9H
* known compatible chips: AD5206
* DAC_MOTOR_CURRENT_DEFAULT - used by PRINTRBOARD_REVF & RIGIDBOARD_V2
* known compatible chips: MCP4728
* DIGIPOT_I2C_MOTOR_CURRENTS - used by 5DPRINT, AZTEEG_X3_PRO, MIGHTYBOARD_REVE
* known compatible chips: MCP4451, MCP4018
*
* Motor currents can also be set by M907 - M910 and by the LCD.
* M907 - applies to all.
* M908 - BQ_ZUM_MEGA_3D, RAMBO, PRINTRBOARD_REVF, RIGIDBOARD_V2 & SCOOVO_X9H
* M909, M910 & LCD - only PRINTRBOARD_REVF & RIGIDBOARD_V2
*/
//#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps //#define PWM_MOTOR_CURRENT {1300, 1300, 1250} // Values in milliamps
//#define DIGIPOT_MOTOR_CURRENT {135,135,135,135,135} // Values 0-255 (RAMBO 135 = ~0.75A, 185 = ~1A)
//#define DAC_MOTOR_CURRENT_DEFAULT { 70, 80, 90, 80 } // Default drive percent - X, Y, Z, E axis
// uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro // Uncomment to enable an I2C based DIGIPOT like on the Azteeg X3 Pro
//#define DIGIPOT_I2C //#define DIGIPOT_I2C
// Number of channels available for I2C digipot, For Azteeg X3 Pro we have 8 //#define DIGIPOT_MCP4018
#define DIGIPOT_I2C_NUM_CHANNELS 8 #define DIGIPOT_I2C_NUM_CHANNELS 8 // 5DPRINT: 4 AZTEEG_X3_PRO: 8
// actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS // Actual motor currents in Amps, need as many here as DIGIPOT_I2C_NUM_CHANNELS
#define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} #define DIGIPOT_I2C_MOTOR_CURRENTS {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0} // AZTEEG_X3_PRO
//=========================================================================== //===========================================================================
//=============================Additional Features=========================== //=============================Additional Features===========================
@@ -442,6 +460,42 @@
// using: // using:
//#define MENU_ADDAUTOSTART //#define MENU_ADDAUTOSTART
/**
* Sort SD file listings in alphabetical order.
*
* With this option enabled, items on SD cards will be sorted
* by name for easier navigation.
*
* By default...
*
* - Use the slowest -but safest- method for sorting.
* - Folders are sorted to the top.
* - The sort key is statically allocated.
* - No added G-code (M34) support.
* - 40 item sorting limit. (Items after the first 40 are unsorted.)
*
* SD sorting uses static allocation (as set by SDSORT_LIMIT), allowing the
* compiler to calculate the worst-case usage and throw an error if the SRAM
* limit is exceeded.
*
* - SDSORT_USES_RAM provides faster sorting via a static directory buffer.
* - SDSORT_USES_STACK does the same, but uses a local stack-based buffer.
* - SDSORT_CACHE_NAMES will retain the sorted file listing in RAM. (Expensive!)
* - SDSORT_DYNAMIC_RAM only uses RAM when the SD menu is visible. (Use with caution!)
*/
//#define SDCARD_SORT_ALPHA
// SD Card Sorting options
#if ENABLED(SDCARD_SORT_ALPHA)
#define SDSORT_LIMIT 40 // Maximum number of sorted items (10-256).
#define FOLDER_SORTING -1 // -1=above 0=none 1=below
#define SDSORT_GCODE false // Allow turning sorting on/off with LCD and M34 g-code.
#define SDSORT_USES_RAM false // Pre-allocate a static array for faster pre-sorting.
#define SDSORT_USES_STACK false // Prefer the stack for pre-sorting to give back some SRAM. (Negated by next 2 options.)
#define SDSORT_CACHE_NAMES false // Keep sorted items in RAM longer for speedy performance. Most expensive option.
#define SDSORT_DYNAMIC_RAM false // Use dynamic allocation (within SD menus). Least expensive option. Set SDSORT_LIMIT before use!
#endif
// Show a progress bar on HD44780 LCDs for SD printing // Show a progress bar on HD44780 LCDs for SD printing
//#define LCD_PROGRESS_BAR //#define LCD_PROGRESS_BAR
@@ -454,6 +508,8 @@
#define PROGRESS_MSG_EXPIRE 0 #define PROGRESS_MSG_EXPIRE 0
// Enable this to show messages for MSG_TIME then hide them // Enable this to show messages for MSG_TIME then hide them
//#define PROGRESS_MSG_ONCE //#define PROGRESS_MSG_ONCE
// Add a menu item to test the progress bar:
//#define LCD_PROGRESS_BAR_TEST
#endif #endif
// This allows hosts to request long names for files and folders with M33 // This allows hosts to request long names for files and folders with M33
@@ -466,8 +522,25 @@
#endif // SDSUPPORT #endif // SDSUPPORT
// Some additional options are available for graphical displays: /**
* Additional options for Graphical Displays
*
* Use the optimizations here to improve printing performance,
* which can be adversely affected by graphical display drawing,
* especially when doing several short moves, and when printing
* on DELTA and SCARA machines.
*
* Some of these options may result in the display lagging behind
* controller events, as there is a trade-off between reliable
* printing performance versus fast display updates.
*/
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
// Enable to save many cycles by drawing a hollow frame on the Info Screen
#define XYZ_HOLLOW_FRAME
// Enable to save many cycles by drawing a hollow frame on Menu Screens
#define MENU_HOLLOW_FRAME
// A bigger font is available for edit items. Costs 3120 bytes of PROGMEM. // A bigger font is available for edit items. Costs 3120 bytes of PROGMEM.
// Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese. // Western only. Not available for Cyrillic, Kana, Turkish, Greek, or Chinese.
//#define USE_BIG_EDIT_FONT //#define USE_BIG_EDIT_FONT
@@ -496,45 +569,22 @@
// @section lcd // @section lcd
// Babystepping enables the user to control the axis in tiny amounts, independently from the normal printing process /**
// it can e.g. be used to change z-positions in the print startup phase in real-time * Babystepping enables movement of the axes by tiny increments without changing
// does not respect endstops! * the current position values. This feature is used primarily to adjust the Z
* axis in the first layer of a print in real-time.
*
* Warning: Does not respect endstops!
*/
//#define BABYSTEPPING //#define BABYSTEPPING
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)
#define BABYSTEP_XY //not only z, but also XY in the menu. more clutter, more functions #define BABYSTEP_XY // Also enable X/Y Babystepping. Not supported on DELTA!
//not implemented for deltabots! #define BABYSTEP_INVERT_Z false // Change if Z babysteps should go the other way
#define BABYSTEP_INVERT_Z false //true for inverse movements in Z #define BABYSTEP_MULTIPLICATOR 1 // Babysteps are very small. Increase for faster motion.
#define BABYSTEP_MULTIPLICATOR 1 //faster movements //#define BABYSTEP_ZPROBE_OFFSET // Enable to combine M851 and Babystepping
#endif //#define DOUBLECLICK_FOR_Z_BABYSTEPPING // Double-click on the Status Screen for Z Babystepping.
#define DOUBLECLICK_MAX_INTERVAL 1250 // Maximum interval between clicks, in milliseconds.
// // Note: Extra time may be added to mitigate controller latency.
// Ensure Smooth Moves
//
// Enable this option to prevent the machine from stuttering when printing multiple short segments.
// This feature uses two strategies to eliminate stuttering:
//
// 1. During short segments a Graphical LCD update may take so much time that the planner buffer gets
// completely drained. When this happens pauses are introduced between short segments, and print moves
// will become jerky until a longer segment provides enough time for the buffer to be filled again.
// This jerkiness negatively affects print quality. The ENSURE_SMOOTH_MOVES option addresses the issue
// by pausing the LCD until there's enough time to safely update.
//
// NOTE: This will cause the Info Screen to lag and controller buttons may become unresponsive.
// Enable ALWAYS_ALLOW_MENU to keep the controller responsive.
//
// 2. No block is allowed to take less time than MIN_BLOCK_TIME. That's the time it takes in the main
// loop to add a new block to the buffer, check temperatures, etc., including all blocked time due to
// interrupts (without LCD update). By enforcing a minimum time-per-move, the buffer is prevented from
// draining.
//
//#define ENSURE_SMOOTH_MOVES
#if ENABLED(ENSURE_SMOOTH_MOVES)
//#define ALWAYS_ALLOW_MENU // If enabled, the menu will always be responsive.
// WARNING: Menu navigation during short moves may cause stuttering!
#define LCD_UPDATE_THRESHOLD 135 // (ms) Minimum duration for the current segment to allow an LCD update.
// Default value is good for graphical LCDs (e.g., REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER).
// You may try to lower this value until you printer starts stuttering again as if ENSURE_SMOOTH_MOVES is disabled.
#define MIN_BLOCK_TIME 6 // (ms) Minimum duration of a single block. You shouldn't need to modify this.
#endif #endif
// @section extruder // @section extruder
@@ -558,19 +608,39 @@
* *
* Assumption: advance = k * (delta velocity) * Assumption: advance = k * (delta velocity)
* K=0 means advance disabled. * K=0 means advance disabled.
* To get a rough start value for calibration, measure your "free filament length" * See Marlin documentation for calibration instructions.
* between the hobbed bolt and the nozzle (in cm). Use the formula below that fits
* your setup, where L is the "free filament length":
*
* Filament diameter | 1.75mm | 3.0mm |
* ----------------------------|-----------|------------|
* Stiff filament (PLA) | K=47*L/10 | K=139*L/10 |
* Softer filament (ABS, nGen) | K=88*L/10 | K=260*L/10 |
*/ */
//#define LIN_ADVANCE //#define LIN_ADVANCE
#if ENABLED(LIN_ADVANCE) #if ENABLED(LIN_ADVANCE)
#define LIN_ADVANCE_K 75 #define LIN_ADVANCE_K 75
/**
* Some Slicers produce Gcode with randomly jumping extrusion widths occasionally.
* For example within a 0.4mm perimeter it may produce a single segment of 0.05mm width.
* While this is harmless for normal printing (the fluid nature of the filament will
* close this very, very tiny gap), it throws off the LIN_ADVANCE pressure adaption.
*
* For this case LIN_ADVANCE_E_D_RATIO can be used to set the extrusion:distance ratio
* to a fixed value. Note that using a fixed ratio will lead to wrong nozzle pressures
* if the slicer is using variable widths or layer heights within one print!
*
* This option sets the default E:D ratio at startup. Use `M900` to override this value.
*
* Example: `M900 W0.4 H0.2 D1.75`, where:
* - W is the extrusion width in mm
* - H is the layer height in mm
* - D is the filament diameter in mm
*
* Example: `M900 R0.0458` to set the ratio directly.
*
* Set to 0 to auto-detect the ratio based on given Gcode G1 print moves.
*
* Slic3r (including Prusa Slic3r) produces Gcode compatible with the automatic mode.
* Cura (as of this writing) may produce Gcode incompatible with the automatic mode.
*/
#define LIN_ADVANCE_E_D_RATIO 0 // The calculated ratio (or 0) according to the formula W * H / ((D / 2) ^ 2 * PI)
// Example: 0.4 * 0.2 / ((1.75 / 2) ^ 2 * PI) = 0.033260135
#endif #endif
// @section leveling // @section leveling
@@ -583,6 +653,11 @@
#define MESH_MAX_X (X_MAX_POS - (MESH_INSET)) #define MESH_MAX_X (X_MAX_POS - (MESH_INSET))
#define MESH_MIN_Y (Y_MIN_POS + MESH_INSET) #define MESH_MIN_Y (Y_MIN_POS + MESH_INSET)
#define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET)) #define MESH_MAX_Y (Y_MAX_POS - (MESH_INSET))
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X (X_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_MAX_POS - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y (Y_MIN_POS + UBL_MESH_INSET)
#define UBL_MESH_MAX_Y (Y_MAX_POS - (UBL_MESH_INSET))
#endif #endif
// @section extras // @section extras
@@ -596,6 +671,7 @@
//#define BEZIER_CURVE_SUPPORT //#define BEZIER_CURVE_SUPPORT
// G38.2 and G38.3 Probe Target // G38.2 and G38.3 Probe Target
// Enable PROBE_DOUBLE_TOUCH if you want G38 to double touch
//#define G38_PROBE_TARGET //#define G38_PROBE_TARGET
#if ENABLED(G38_PROBE_TARGET) #if ENABLED(G38_PROBE_TARGET)
#define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move) #define G38_MINIMUM_MOVE 0.0275 // minimum distance in mm that will produce a move (determined using the print statement in check_move)
@@ -677,43 +753,54 @@
#define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s) #define RETRACT_RECOVER_FEEDRATE 8 //default feedrate for recovering from retraction (mm/s)
#endif #endif
// Add support for experimental filament exchange support M600; requires display /**
#if ENABLED(ULTIPANEL) * Filament Change
// #define FILAMENT_CHANGE_FEATURE // Enable filament exchange menu and M600 g-code (used for runout sensor too) * Experimental filament change support.
#if ENABLED(FILAMENT_CHANGE_FEATURE) * Adds the GCode M600 for initiating filament change.
#define FILAMENT_CHANGE_X_POS 3 // X position of hotend *
#define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend * Requires an LCD display.
#define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift) * This feature is required for the default FILAMENT_RUNOUT_SCRIPT.
#define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis) */
#define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers) //#define FILAMENT_CHANGE_FEATURE
#define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm #if ENABLED(FILAMENT_CHANGE_FEATURE)
// It is a short retract used immediately after print interrupt before move to filament exchange position #define FILAMENT_CHANGE_X_POS 3 // X position of hotend
#define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s #define FILAMENT_CHANGE_Y_POS 3 // Y position of hotend
#define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm #define FILAMENT_CHANGE_Z_ADD 10 // Z addition of hotend (lift)
// Longer length for bowden printers to unload filament from whole bowden tube, #define FILAMENT_CHANGE_XY_FEEDRATE 100 // X and Y axes feedrate in mm/s (also used for delta printers Z axis)
// shorter lenght for printers without bowden to unload filament from extruder only, #define FILAMENT_CHANGE_Z_FEEDRATE 5 // Z axis feedrate in mm/s (not used for delta printers)
// 0 to disable unloading for manual unloading #define FILAMENT_CHANGE_RETRACT_FEEDRATE 60 // Initial retract feedrate in mm/s
#define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast #define FILAMENT_CHANGE_RETRACT_LENGTH 2 // Initial retract in mm
#define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm // It is a short retract used immediately after print interrupt before move to filament exchange position
// Longer length for bowden printers to fast load filament into whole bowden tube over the hotend, #define FILAMENT_CHANGE_UNLOAD_FEEDRATE 10 // Unload filament feedrate in mm/s - filament unloading can be fast
// Short or zero length for printers without bowden where loading is not used #define FILAMENT_CHANGE_UNLOAD_LENGTH 100 // Unload filament length from hotend in mm
#define FILAMENT_CHANGE_LOAD_FEEDRATE 10 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast // Longer length for bowden printers to unload filament from whole bowden tube,
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is load over the hotend, // shorter length for printers without bowden to unload filament from extruder only,
// 0 to disable for manual extrusion // 0 to disable unloading for manual unloading
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend, #define FILAMENT_CHANGE_LOAD_FEEDRATE 6 // Load filament feedrate in mm/s - filament loading into the bowden tube can be fast
// or until outcoming filament color is not clear for filament color change #define FILAMENT_CHANGE_LOAD_LENGTH 0 // Load filament length over hotend in mm
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate // Longer length for bowden printers to fast load filament into whole bowden tube over the hotend,
#endif // Short or zero length for printers without bowden where loading is not used
#define FILAMENT_CHANGE_EXTRUDE_FEEDRATE 3 // Extrude filament feedrate in mm/s - must be slower than load feedrate
#define FILAMENT_CHANGE_EXTRUDE_LENGTH 50 // Extrude filament length in mm after filament is loaded over the hotend,
// 0 to disable for manual extrusion
// Filament can be extruded repeatedly from the filament exchange menu to fill the hotend,
// or until outcoming filament color is not clear for filament color change
#define FILAMENT_CHANGE_NOZZLE_TIMEOUT 45 // Turn off nozzle if user doesn't change filament within this time limit in seconds
#define FILAMENT_CHANGE_NUMBER_OF_ALERT_BEEPS 5 // Number of alert beeps before printer goes quiet
#define FILAMENT_CHANGE_NO_STEPPER_TIMEOUT // Enable to have stepper motors hold position during filament change
// even if it takes longer than DEFAULT_STEPPER_DEACTIVE_TIME.
//#define PARK_HEAD_ON_PAUSE // Go to filament change position on pause, return to print position on resume
#endif #endif
/******************************************************************************\
* enable this section if you have TMC26X motor drivers.
* you need to import the TMC26XStepper library into the Arduino IDE for this
******************************************************************************/
// @section tmc // @section tmc
/**
* Enable this section if you have TMC26X motor drivers.
* You will need to import the TMC26XStepper library into the Arduino IDE for this
* (https://github.com/trinamic/TMC26XStepper.git)
*/
//#define HAVE_TMCDRIVER //#define HAVE_TMCDRIVER
#if ENABLED(HAVE_TMCDRIVER) #if ENABLED(HAVE_TMCDRIVER)
//#define X_IS_TMC //#define X_IS_TMC
@@ -726,6 +813,7 @@
//#define E1_IS_TMC //#define E1_IS_TMC
//#define E2_IS_TMC //#define E2_IS_TMC
//#define E3_IS_TMC //#define E3_IS_TMC
//#define E4_IS_TMC
#define X_MAX_CURRENT 1000 // in mA #define X_MAX_CURRENT 1000 // in mA
#define X_SENSE_RESISTOR 91 // in mOhms #define X_SENSE_RESISTOR 91 // in mOhms
@@ -767,27 +855,27 @@
#define E3_SENSE_RESISTOR 91 #define E3_SENSE_RESISTOR 91
#define E3_MICROSTEPS 16 #define E3_MICROSTEPS 16
#define E4_MAX_CURRENT 1000
#define E4_SENSE_RESISTOR 91
#define E4_MICROSTEPS 16
#endif #endif
// @section TMC2130 // @section TMC2130
/** /**
* Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers. * Enable this for SilentStepStick Trinamic TMC2130 SPI-configurable stepper drivers.
* *
* To use TMC2130 drivers in SPI mode, you'll also need the TMC2130 Arduino library * You'll also need the TMC2130Stepper Arduino library
* (https://github.com/makertum/Trinamic_TMC2130). * (https://github.com/teemuatlut/TMC2130Stepper).
* *
* To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to * To use TMC2130 stepper drivers in SPI mode connect your SPI2130 pins to
* the hardware SPI interface on your board and define the required CS pins * the hardware SPI interface on your board and define the required CS pins
* in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.). * in your `pins_MYBOARD.h` file. (e.g., RAMPS 1.4 uses AUX3 pins `X_CS_PIN 53`, `Y_CS_PIN 49`, etc.).
*/ */
//#define HAVE_TMC2130
//#define HAVE_TMC2130DRIVER #if ENABLED(HAVE_TMC2130)
#if ENABLED(HAVE_TMC2130DRIVER)
//#define TMC2130_ADVANCED_CONFIGURATION
// CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY // CHOOSE YOUR MOTORS HERE, THIS IS MANDATORY
//#define X_IS_TMC2130 //#define X_IS_TMC2130
@@ -800,181 +888,129 @@
//#define E1_IS_TMC2130 //#define E1_IS_TMC2130
//#define E2_IS_TMC2130 //#define E2_IS_TMC2130
//#define E3_IS_TMC2130 //#define E3_IS_TMC2130
//#define E4_IS_TMC2130
#if ENABLED(TMC2130_ADVANCED_CONFIGURATION) /**
* Stepper driver settings
*/
// If you've enabled TMC2130_ADVANCED_CONFIGURATION, define global settings below. #define R_SENSE 0.11 // R_sense resistor for SilentStepStick2130
// Enabled settings will be automatically applied to all axes specified above. #define HOLD_MULTIPLIER 0.5 // Scales down the holding current from run current
// #define INTERPOLATE 1 // Interpolate X/Y/Z_MICROSTEPS to 256
// Please read the TMC2130 datasheet:
// http://www.trinamic.com/_articles/products/integrated-circuits/tmc2130/_datasheet/TMC2130_datasheet.pdf
// All settings here have the same (sometimes cryptic) names as in the datasheet.
//
// The following, uncommented settings are only suggestion.
/* GENERAL CONFIGURATION */ #define X_CURRENT 1000 // rms current in mA. Multiply by 1.41 for peak current.
#define X_MICROSTEPS 16 // 0..256
//#define GLOBAL_EN_PWM_MODE 0 #define Y_CURRENT 1000
#define GLOBAL_I_SCALE_ANALOG 1 // [0,1] 0: Normal, 1: AIN #define Y_MICROSTEPS 16
//#define GLOBAL_INTERNAL_RSENSE 0 // [0,1] 0: Normal, 1: Internal
#define GLOBAL_EN_PWM_MODE 0 // [0,1] 0: Normal, 1: stealthChop with velocity threshold
//#define GLOBAL_ENC_COMMUTATION 0 // [0,1]
#define GLOBAL_SHAFT 0 // [0,1] 0: normal, 1: invert
//#define GLOBAL_DIAG0_ERROR 0 // [0,1]
//#define GLOBAL_DIAG0_OTPW 0 // [0,1]
//#define GLOBAL_DIAG0_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_STALL 0 // [0,1]
//#define GLOBAL_DIAG1_INDEX 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG1_ONSTATE 0 // [0,1]
//#define GLOBAL_DIAG0_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_DIAG1_INT_PUSHPULL 0 // [0,1]
//#define GLOBAL_SMALL_HYSTERESIS 0 // [0,1]
//#define GLOBAL_STOP_ENABLE 0 // [0,1]
//#define GLOBAL_DIRECT_MODE 0 // [0,1]
/* VELOCITY-DEPENDENT DRIVE FEATURES */ #define Z_CURRENT 1000
#define Z_MICROSTEPS 16
#define GLOBAL_IHOLD 22 // [0-31] 0: min, 31: max //#define X2_CURRENT 1000
#define GLOBAL_IRUN 31 // [0-31] 0: min, 31: max //#define X2_MICROSTEPS 16
#define GLOBAL_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds
//#define GLOBAL_TPOWERDOWN 0 // [0-255] 0: min, 255: about 4 seconds
//#define GLOBAL_TPWMTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
//#define GLOBAL_TCOOLTHRS 0 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
#define GLOBAL_THIGH 10 // [0-1048576] e.g. 20 corresponds with 2000 steps/s
/* SPI MODE CONFIGURATION */ //#define Y2_CURRENT 1000
//#define Y2_MICROSTEPS 16
//#define GLOBAL_XDIRECT 0 //#define Z2_CURRENT 1000
//#define Z2_MICROSTEPS 16
/* DCSTEP MINIMUM VELOCITY */ //#define E0_CURRENT 1000
//#define E0_MICROSTEPS 16
//#define GLOBAL_VDCMIN 0 //#define E1_CURRENT 1000
//#define E1_MICROSTEPS 16
/* MOTOR DRIVER CONFIGURATION*/ //#define E2_CURRENT 1000
//#define E2_MICROSTEPS 16
//#define GLOBAL_DEDGE 0 //#define E3_CURRENT 1000
//#define GLOBAL_DISS2G 0 //#define E3_MICROSTEPS 16
#define GLOBAL_INTPOL 1 // 0: off 1: 256 microstep interpolation
#define GLOBAL_MRES 16 // number of microsteps
#define GLOBAL_SYNC 1 // [0-15]
#define GLOBAL_VHIGHCHM 1 // [0,1] 0: normal, 1: high velocity stepper mode
#define GLOBAL_VHIGHFS 0 // [0,1] 0: normal, 1: switch to full steps for high velocities
// #define GLOBAL_VSENSE 0 // [0,1] 0: normal, 1: high sensitivity (not recommended)
#define GLOBAL_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended
#define GLOBAL_CHM 0 // [0,1] 0: spreadCycle, 1: Constant off time with fast decay time.
//#define GLOBAL_RNDTF 0
//#define GLOBAL_DISFDCC 0
//#define GLOBAL_FD 0
//#define GLOBAL_HEND 0
//#define GLOBAL_HSTRT 0
#define GLOBAL_TOFF 10 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase
//#define GLOBAL_SFILT 0 //#define E4_CURRENT 1000
//#define GLOBAL_SGT 0 //#define E4_MICROSTEPS 16
//#define GLOBAL_SEIMIN 0
//#define GLOBAL_SEDN 0
//#define GLOBAL_SEMAX 0
//#define GLOBAL_SEUP 0
//#define GLOBAL_SEMIN 0
//#define GLOBAL_DC_TIME 0 /**
//#define GLOBAL_DC_SG 0 * Use Trinamic's ultra quiet stepping mode.
* When disabled, Marlin will use spreadCycle stepping mode.
*/
#define STEALTHCHOP
//#define GLOBAL_FREEWHEEL 0 /**
//#define GLOBAL_PWM_SYMMETRIC 0 * Let Marlin automatically control stepper current.
//#define GLOBAL_PWM_AUTOSCALE 0 * This is still an experimental feature.
//#define GLOBAL_PWM_FREQ 0 * Increase current every 5s by CURRENT_STEP until stepper temperature prewarn gets triggered,
//#define GLOBAL_PWM_GRAD 0 * then decrease current by CURRENT_STEP until temperature prewarn is cleared.
//#define GLOBAL_PWM_AMPL 0 * Adjusting starts from X/Y/Z/E_CURRENT but will not increase over AUTO_ADJUST_MAX
* Relevant g-codes:
* M906 - Set or get motor current in milliamps using axis codes X, Y, Z, E. Report values if no axis codes given.
* M906 S1 - Start adjusting current
* M906 S0 - Stop adjusting current
* M911 - Report stepper driver overtemperature pre-warn condition.
* M912 - Clear stepper driver overtemperature pre-warn condition flag.
*/
//#define AUTOMATIC_CURRENT_CONTROL
//#define GLOBAL_ENCM_CTRL 0 #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
#define CURRENT_STEP 50 // [mA]
#define AUTO_ADJUST_MAX 1300 // [mA], 1300mA_rms = 1840mA_peak
#define REPORT_CURRENT_CHANGE
#endif
#else /**
* The driver will switch to spreadCycle when stepper speed is over HYBRID_THRESHOLD.
* This mode allows for faster movements at the expense of higher noise levels.
* STEALTHCHOP needs to be enabled.
* M913 X/Y/Z/E to live tune the setting
*/
//#define HYBRID_THRESHOLD
#define X_IHOLD 31 // [0-31] 0: min, 31: max #define X_HYBRID_THRESHOLD 100 // [mm/s]
#define X_IRUN 31 // [0-31] 0: min, 31: max #define X2_HYBRID_THRESHOLD 100
#define X_IHOLDDELAY 15 // [0-15] 0: min, 15: about 4 seconds #define Y_HYBRID_THRESHOLD 100
#define X_I_SCALE_ANALOG 1 // 0: Normal, 1: AIN #define Y2_HYBRID_THRESHOLD 100
#define X_MRES 16 // number of microsteps #define Z_HYBRID_THRESHOLD 4
#define X_TBL 1 // 0-3: set comparator blank time to 16, 24, 36 or 54 clocks, 1 or 2 is recommended #define Z2_HYBRID_THRESHOLD 4
#define X_TOFF 8 // 0: driver disable, 1: use only with TBL>2, 2-15: off time setting during slow decay phase #define E0_HYBRID_THRESHOLD 30
#define E1_HYBRID_THRESHOLD 30
#define E2_HYBRID_THRESHOLD 30
#define E3_HYBRID_THRESHOLD 30
#define E4_HYBRID_THRESHOLD 30
#define X2_IHOLD 31 /**
#define X2_IRUN 31 * Use stallGuard2 to sense an obstacle and trigger an endstop.
#define X2_IHOLDDELAY 15 * You need to place a wire from the driver's DIAG1 pin to the X/Y endstop pin.
#define X2_I_SCALE_ANALOG 1 * If used along with STEALTHCHOP, the movement will be louder when homing. This is normal.
#define X2_MRES 16 *
#define X2_TBL 1 * X/Y_HOMING_SENSITIVITY is used for tuning the trigger sensitivity.
#define X2_TOFF 8 * Higher values make the system LESS sensitive.
* Lower value make the system MORE sensitive.
* Too low values can lead to false positives, while too high values will collide the axis without triggering.
* It is advised to set X/Y_HOME_BUMP_MM to 0.
* M914 X/Y to live tune the setting
*/
//#define SENSORLESS_HOMING
#define Y_IHOLD 31 #if ENABLED(SENSORLESS_HOMING)
#define Y_IRUN 31 #define X_HOMING_SENSITIVITY 19
#define Y_IHOLDDELAY 15 #define Y_HOMING_SENSITIVITY 19
#define Y_I_SCALE_ANALOG 1 #endif
#define Y_MRES 16
#define Y_TBL 1
#define Y_TOFF 8
#define Y2_IHOLD 31 /**
#define Y2_IRUN 31 * You can set your own advanced settings by filling in predefined functions.
#define Y2_IHOLDDELAY 15 * A list of available functions can be found on the library github page
#define Y2_I_SCALE_ANALOG 1 * https://github.com/teemuatlut/TMC2130Stepper
#define Y2_MRES 16 *
#define Y2_TBL 1 * Example:
#define Y2_TOFF 8 * #define TMC2130_ADV() { \
* stepperX.diag0_temp_prewarn(1); \
* stepperX.interpolate(0); \
* }
*/
#define TMC2130_ADV() { }
#define Z_IHOLD 31 #endif // ENABLED(HAVE_TMC2130)
#define Z_IRUN 31
#define Z_IHOLDDELAY 15
#define Z_I_SCALE_ANALOG 1
#define Z_MRES 16
#define Z_TBL 1
#define Z_TOFF 8
#define Z2_IHOLD 31
#define Z2_IRUN 31
#define Z2_IHOLDDELAY 15
#define Z2_I_SCALE_ANALOG 1
#define Z2_MRES 16
#define Z2_TBL 1
#define Z2_TOFF 8
#define E0_IHOLD 31
#define E0_IRUN 31
#define E0_IHOLDDELAY 15
#define E0_I_SCALE_ANALOG 1
#define E0_MRES 16
#define E0_TBL 1
#define E0_TOFF 8
#define E1_IHOLD 31
#define E1_IRUN 31
#define E1_IHOLDDELAY 15
#define E1_I_SCALE_ANALOG 1
#define E1_MRES 16
#define E1_TBL 1
#define E1_TOFF 8
#define E2_IHOLD 31
#define E2_IRUN 31
#define E2_IHOLDDELAY 15
#define E2_I_SCALE_ANALOG 1
#define E2_MRES 16
#define E2_TBL 1
#define E2_TOFF 8
#define E3_IHOLD 31
#define E3_IRUN 31
#define E3_IHOLDDELAY 15
#define E3_I_SCALE_ANALOG 1
#define E3_MRES 16
#define E3_TBL 1
#define E3_TOFF 8
#endif // TMC2130_ADVANCED_CONFIGURATION
#endif // HAVE_TMC2130DRIVER
// @section L6470 // @section L6470
@@ -997,6 +1033,7 @@
//#define E1_IS_L6470 //#define E1_IS_L6470
//#define E2_IS_L6470 //#define E2_IS_L6470
//#define E3_IS_L6470 //#define E3_IS_L6470
//#define E4_IS_L6470
#define X_MICROSTEPS 16 // number of microsteps #define X_MICROSTEPS 16 // number of microsteps
#define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high #define X_K_VAL 50 // 0 - 255, Higher values, are higher power. Be careful not to go too high
@@ -1048,6 +1085,11 @@
#define E3_OVERCURRENT 2000 #define E3_OVERCURRENT 2000
#define E3_STALLCURRENT 1500 #define E3_STALLCURRENT 1500
#define E4_MICROSTEPS 16
#define E4_K_VAL 50
#define E4_OVERCURRENT 2000
#define E4_STALLCURRENT 1500
#endif #endif
/** /**
@@ -1084,7 +1126,7 @@
#define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave #define I2C_SLAVE_ADDRESS 0 // Set a value from 8 to 127 to act as a slave
/** /**
* Add M43 command for pins info and testing * M43 - display pin status, watch pins for changes, watch endstops & toggle LED, Z servo probe test, toggle pins
*/ */
//#define PINS_DEBUGGING //#define PINS_DEBUGGING
@@ -1098,4 +1140,22 @@
*/ */
//#define EXTENDED_CAPABILITIES_REPORT //#define EXTENDED_CAPABILITIES_REPORT
/**
* Volumetric extrusion default state
* Activate to make volumetric extrusion the default method,
* with DEFAULT_NOMINAL_FILAMENT_DIA as the default diameter.
*
* M200 D0 to disable, M200 Dn to set a new diameter.
*/
//#define VOLUMETRIC_DEFAULT_ON
/**
* Enable this option for a leaner build of Marlin that removes all
* workspace offsets, simplifying coordinate transformations, leveling, etc.
*
* - M206 and M428 are disabled.
* - G92 will revert to its behavior from Marlin 1.0.
*/
//#define NO_WORKSPACE_OFFSETS
#endif // CONFIGURATION_ADV_H #endif // CONFIGURATION_ADV_H

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -21,99 +21,197 @@
*/ */
/** /**
This code contributed by Triffid_Hunter and modified by Kliment * Contributed by Triffid_Hunter, modified by Kliment, extended by the Marlin team
why double up on these macros? see http://gcc.gnu.org/onlinedocs/cpp/Stringification.html * Why double up on these macros? see http://gcc.gnu.org/onlinedocs/cpp/Stringification.html
*/ */
#ifndef _FASTIO_ARDUINO_H #ifndef _FASTIO_ARDUINO_H
#define _FASTIO_ARDUINO_H #define _FASTIO_ARDUINO_H
#include <avr/io.h> #include <avr/io.h>
/** #ifndef _BV
utility functions #define _BV(PIN) (1 << PIN)
*/
#ifndef MASK
#define MASK(PIN) (1 << PIN)
#endif #endif
/** /**
magic I/O routines * Magic I/O routines
now you can simply SET_OUTPUT(STEP); WRITE(STEP, 1); WRITE(STEP, 0); *
*/ * Now you can simply SET_OUTPUT(PIN); WRITE(PIN, HIGH); WRITE(PIN, LOW);
*/
/// Read a pin #define _READ(IO) ((bool)(DIO ## IO ## _RPORT & _BV(DIO ## IO ## _PIN)))
#define _READ(IO) ((bool)(DIO ## IO ## _RPORT & MASK(DIO ## IO ## _PIN)))
/// write to a pin
// On some boards pins > 0x100 are used. These are not converted to atomic actions. An critical section is needed.
#define _WRITE_NC(IO, v) do { if (v) {DIO ## IO ## _WPORT |= MASK(DIO ## IO ## _PIN); } else {DIO ## IO ## _WPORT &= ~MASK(DIO ## IO ## _PIN); }; } while (0) // On some boards pins > 0x100 are used. These are not converted to atomic actions. A critical section is needed.
#define _WRITE_NC(IO, v) do { if (v) {DIO ## IO ## _WPORT |= _BV(DIO ## IO ## _PIN); } else {DIO ## IO ## _WPORT &= ~_BV(DIO ## IO ## _PIN); }; } while (0)
#define _WRITE_C(IO, v) do { if (v) { \ #define _WRITE_C(IO, v) do { if (v) { \
CRITICAL_SECTION_START; \ CRITICAL_SECTION_START; \
{DIO ## IO ## _WPORT |= MASK(DIO ## IO ## _PIN); } \ {DIO ## IO ## _WPORT |= _BV(DIO ## IO ## _PIN); } \
CRITICAL_SECTION_END; \ CRITICAL_SECTION_END; \
} \ } \
else { \ else { \
CRITICAL_SECTION_START; \ CRITICAL_SECTION_START; \
{DIO ## IO ## _WPORT &= ~MASK(DIO ## IO ## _PIN); } \ {DIO ## IO ## _WPORT &= ~_BV(DIO ## IO ## _PIN); } \
CRITICAL_SECTION_END; \ CRITICAL_SECTION_END; \
} \ } \
} \ } \
while (0) while (0)
#define _WRITE(IO, v) do { if (&(DIO ## IO ## _RPORT) >= (uint8_t *)0x100) {_WRITE_C(IO, v); } else {_WRITE_NC(IO, v); }; } while (0) #define _WRITE(IO, v) do { if (&(DIO ## IO ## _RPORT) >= (uint8_t *)0x100) {_WRITE_C(IO, v); } else {_WRITE_NC(IO, v); }; } while (0)
/// toggle a pin #define _TOGGLE(IO) do {DIO ## IO ## _RPORT ^= _BV(DIO ## IO ## _PIN); } while (0)
#define _TOGGLE(IO) do {DIO ## IO ## _RPORT = MASK(DIO ## IO ## _PIN); } while (0)
/// set pin as input #define _SET_INPUT(IO) do {DIO ## IO ## _DDR &= ~_BV(DIO ## IO ## _PIN); } while (0)
#define _SET_INPUT(IO) do {DIO ## IO ## _DDR &= ~MASK(DIO ## IO ## _PIN); } while (0) #define _SET_OUTPUT(IO) do {DIO ## IO ## _DDR |= _BV(DIO ## IO ## _PIN); } while (0)
/// set pin as output
#define _SET_OUTPUT(IO) do {DIO ## IO ## _DDR |= MASK(DIO ## IO ## _PIN); } while (0)
/// check if pin is an input #define _GET_INPUT(IO) ((DIO ## IO ## _DDR & _BV(DIO ## IO ## _PIN)) == 0)
#define _GET_INPUT(IO) ((DIO ## IO ## _DDR & MASK(DIO ## IO ## _PIN)) == 0) #define _GET_OUTPUT(IO) ((DIO ## IO ## _DDR & _BV(DIO ## IO ## _PIN)) != 0)
/// check if pin is an output #define _GET_TIMER(IO) (DIO ## IO ## _PWM)
#define _GET_OUTPUT(IO) ((DIO ## IO ## _DDR & MASK(DIO ## IO ## _PIN)) != 0)
/// check if pin is an timer #define READ(IO) _READ(IO)
#define _GET_TIMER(IO) (DIO ## IO ## _PWM) #define WRITE(IO,V) _WRITE(IO,V)
#define TOGGLE(IO) _TOGGLE(IO)
// why double up on these macros? see http://gcc.gnu.org/onlinedocs/cpp/Stringification.html #define SET_INPUT(IO) _SET_INPUT(IO)
/// Read a pin wrapper
#define READ(IO) _READ(IO)
/// Write to a pin wrapper
#define WRITE(IO, v) _WRITE(IO, v)
/// toggle a pin wrapper
#define TOGGLE(IO) _TOGGLE(IO)
/// set pin as input wrapper
#define SET_INPUT(IO) _SET_INPUT(IO)
/// set pin as input with pullup wrapper
#define SET_INPUT_PULLUP(IO) do{ _SET_INPUT(IO); _WRITE(IO, HIGH); }while(0) #define SET_INPUT_PULLUP(IO) do{ _SET_INPUT(IO); _WRITE(IO, HIGH); }while(0)
/// set pin as output wrapper #define SET_OUTPUT(IO) _SET_OUTPUT(IO)
#define SET_OUTPUT(IO) _SET_OUTPUT(IO)
/// check if pin is an input wrapper #define GET_INPUT(IO) _GET_INPUT(IO)
#define GET_INPUT(IO) _GET_INPUT(IO) #define GET_OUTPUT(IO) _GET_OUTPUT(IO)
/// check if pin is an output wrapper #define GET_TIMER(IO) _GET_TIMER(IO)
#define GET_OUTPUT(IO) _GET_OUTPUT(IO)
/// check if pin is an timer wrapper #define OUT_WRITE(IO, v) do{ SET_OUTPUT(IO); WRITE(IO, v); }while(0)
#define GET_TIMER(IO) _GET_TIMER(IO)
// Shorthand
#define OUT_WRITE(IO, v) { SET_OUTPUT(IO); WRITE(IO, v); }
/** /**
ports and functions * Timer and Interrupt Control
*/
added as necessary or if I feel like it- not a comprehensive list! // Waveform Generation Modes
*/ typedef enum {
WGM_NORMAL, // 0
WGM_PWM_PC_8, // 1
WGM_PWM_PC_9, // 2
WGM_PWM_PC_10, // 3
WGM_CTC_OCRnA, // 4 COM OCnx
WGM_FAST_PWM_8, // 5
WGM_FAST_PWM_9, // 6
WGM_FAST_PWM_10, // 7
WGM_PWM_PC_FC_ICRn, // 8
WGM_PWM_PC_FC_OCRnA, // 9 COM OCnA
WGM_PWM_PC_ICRn, // 10
WGM_PWM_PC_OCRnA, // 11 COM OCnA
WGM_CTC_ICRn, // 12 COM OCnx
WGM_reserved, // 13
WGM_FAST_PWM_ICRn, // 14 COM OCnA
WGM_FAST_PWM_OCRnA // 15 COM OCnA
} WaveGenMode;
// Compare Modes
typedef enum {
COM_NORMAL, // 0
COM_TOGGLE, // 1 Non-PWM: OCnx ... Both PWM (WGM 9,11,14,15): OCnA only ... else NORMAL
COM_CLEAR_SET, // 2 Non-PWM: OCnx ... Fast PWM: OCnx/Bottom ... PF-FC: OCnx Up/Down
COM_SET_CLEAR // 3 Non-PWM: OCnx ... Fast PWM: OCnx/Bottom ... PF-FC: OCnx Up/Down
} CompareMode;
// Clock Sources
typedef enum {
CS_NONE, // 0
CS_PRESCALER_1, // 1
CS_PRESCALER_8, // 2
CS_PRESCALER_64, // 3
CS_PRESCALER_256, // 4
CS_PRESCALER_1024, // 5
CS_EXT_FALLING, // 6
CS_EXT_RISING // 7
} ClockSource;
// Clock Sources (Timer 2 only)
typedef enum {
CS2_NONE, // 0
CS2_PRESCALER_1, // 1
CS2_PRESCALER_8, // 2
CS2_PRESCALER_32, // 3
CS2_PRESCALER_64, // 4
CS2_PRESCALER_128, // 5
CS2_PRESCALER_256, // 6
CS2_PRESCALER_1024 // 7
} ClockSource2;
// Get interrupt bits in an orderly way
#define GET_WGM(T) (((TCCR##T##A >> WGM##T##0) & 0x3) | ((TCCR##T##B >> WGM##T##2 << 2) & 0xC))
#define GET_CS(T) ((TCCR##T##B >> CS##T##0) & 0x7)
#define GET_COM(T,Q) ((TCCR##T##Q >> COM##T##Q##0) & 0x3)
#define GET_COMA(T) GET_COM(T,A)
#define GET_COMB(T) GET_COM(T,B)
#define GET_COMC(T) GET_COM(T,C)
#define GET_ICNC(T) (!!(TCCR##T##B & _BV(ICNC##T)))
#define GET_ICES(T) (!!(TCCR##T##B & _BV(ICES##T)))
#define GET_FOC(T,Q) (!!(TCCR##T##C & _BV(FOC##T##Q)))
#define GET_FOCA(T) GET_FOC(T,A)
#define GET_FOCB(T) GET_FOC(T,B)
#define GET_FOCC(T) GET_FOC(T,C)
// Set Wave Generation Mode bits
#define _SET_WGM(T,V) do{ \
TCCR##T##A = (TCCR##T##A & ~(0x3 << WGM##T##0)) | (( int(V) & 0x3) << WGM##T##0); \
TCCR##T##B = (TCCR##T##B & ~(0x3 << WGM##T##2)) | (((int(V) >> 2) & 0x3) << WGM##T##2); \
}while(0)
#define SET_WGM(T,V) _SET_WGM(T,WGM_##V)
// Set Clock Select bits
#define _SET_CS(T,V) (TCCR##T##B = (TCCR##T##B & ~(0x7 << CS##T##0)) | ((int(V) & 0x7) << CS##T##0))
#define _SET_CS0(V) _SET_CS(0,V)
#define _SET_CS1(V) _SET_CS(1,V)
#ifdef TCCR2
#define _SET_CS2(V) (TCCR2 = (TCCR2 & ~(0x7 << CS20)) | (int(V) << CS20))
#else
#define _SET_CS2(V) _SET_CS(2,V)
#endif
#define _SET_CS3(V) _SET_CS(3,V)
#define _SET_CS4(V) _SET_CS(4,V)
#define _SET_CS5(V) _SET_CS(5,V)
#define SET_CS0(V) _SET_CS0(CS_##V)
#define SET_CS1(V) _SET_CS1(CS_##V)
#ifdef TCCR2
#define SET_CS2(V) _SET_CS2(CS2_##V)
#else
#define SET_CS2(V) _SET_CS2(CS_##V)
#endif
#define SET_CS3(V) _SET_CS3(CS_##V)
#define SET_CS4(V) _SET_CS4(CS_##V)
#define SET_CS5(V) _SET_CS5(CS_##V)
#define SET_CS(T,V) SET_CS##T(V)
// Set Compare Mode bits
#define _SET_COM(T,Q,V) (TCCR##T##Q = (TCCR##T##Q & ~(0x3 << COM##T##Q##0)) | (int(V) << COM##T##Q##0))
#define _SET_COMA(T,V) _SET_COM(T,A,V)
#define _SET_COMB(T,V) _SET_COM(T,B,V)
#define _SET_COMC(T,V) _SET_COM(T,C,V)
#define _SET_COMS(T,V1,V2,V3) do{ _SET_COMA(T,V1); _SET_COMB(T,V2); _SET_COMC(T,V3); }while(0)
#define SET_COM(T,Q,V) _SET_COM(T,Q,COM_##V)
#define SET_COMA(T,V) SET_COM(T,A,V)
#define SET_COMB(T,V) SET_COM(T,B,V)
#define SET_COMC(T,V) SET_COM(T,C,V)
#define SET_COMS(T,V1,V2,V3) do{ SET_COMA(T,V1); SET_COMB(T,V2); SET_COMC(T,V3); }while(0)
// Set Noise Canceler bit
#define SET_ICNC(T,V) (TCCR##T##B = (V) ? TCCR##T##B | _BV(ICNC##T) : TCCR##T##B & ~_BV(ICNC##T))
// Set Input Capture Edge Select bit
#define SET_ICES(T,V) (TCCR##T##B = (V) ? TCCR##T##B | _BV(ICES##T) : TCCR##T##B & ~_BV(ICES##T))
// Set Force Output Compare bit
#define SET_FOC(T,Q,V) (TCCR##T##C = (V) ? TCCR##T##C | _BV(FOC##T##Q) : TCCR##T##C & ~_BV(FOC##T##Q))
#define SET_FOCA(T,V) SET_FOC(T,A,V)
#define SET_FOCB(T,V) SET_FOC(T,B,V)
#define SET_FOCC(T,V) SET_FOC(T,C,V)
/**
* Ports and Functions
*/
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__) #if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__)
// UART // UART
@@ -141,8 +239,8 @@
#define DEBUG_LED AIO5 #define DEBUG_LED AIO5
/** /**
pins * Pins Info
*/ */
#define DIO0_PIN PIND0 #define DIO0_PIN PIND0
#define DIO0_RPORT PIND #define DIO0_RPORT PIND
@@ -446,7 +544,7 @@
#define PD7_WPORT PORTD #define PD7_WPORT PORTD
#define PD7_DDR DDRD #define PD7_DDR DDRD
#define PD7_PWM NULL #define PD7_PWM NULL
#endif /* _AVR_ATmega{168,328,328P}__ */ #endif // __AVR_ATmega(168|328|328P)__
#if defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__) #if defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__)
// UART // UART
@@ -477,9 +575,10 @@
#define OC2B DIO14 #define OC2B DIO14
#define DEBUG_LED DIO0 #define DEBUG_LED DIO0
/** /**
pins * Pins Info
*/ */
#define DIO0_PIN PINB0 #define DIO0_PIN PINB0
#define DIO0_RPORT PINB #define DIO0_RPORT PINB
@@ -721,8 +820,6 @@
#define AIO7_DDR DDRA #define AIO7_DDR DDRA
#define AIO7_PWM NULL #define AIO7_PWM NULL
#undef PA0 #undef PA0
#define PA0_PIN PINA0 #define PA0_PIN PINA0
#define PA0_RPORT PINA #define PA0_RPORT PINA
@@ -949,7 +1046,7 @@
#define PD7_WPORT PORTD #define PD7_WPORT PORTD
#define PD7_DDR DDRD #define PD7_DDR DDRD
#define PD7_PWM OCR2A #define PD7_PWM OCR2A
#endif /* _AVR_ATmega{644,644P,644PA}__ */ #endif // __AVR_ATmega(644|644P|644PA)__
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// UART // UART
@@ -987,8 +1084,9 @@
#define DEBUG_LED DIO21 #define DEBUG_LED DIO21
/** /**
pins * Pins Info
*/ */
#define DIO0_PIN PINE0 #define DIO0_PIN PINE0
#define DIO0_RPORT PINE #define DIO0_RPORT PINE
#define DIO0_WPORT PORTE #define DIO0_WPORT PORTE
@@ -2031,8 +2129,7 @@
#define PL7_WPORT PORTL #define PL7_WPORT PORTL
#define PL7_DDR DDRL #define PL7_DDR DDRL
#define PL7_PWM NULL #define PL7_PWM NULL
#endif // __AVR_ATmega(1280|2560)__
#endif
#if defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) #if defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__)
@@ -2040,8 +2137,8 @@
#define DEBUG_LED DIO31 /* led D5 red */ #define DEBUG_LED DIO31 /* led D5 red */
/** /**
pins * Pins Info
*/ */
//#define AT90USBxx_TEENSYPP_ASSIGNMENTS // Use Teensy++ 2.0 assignments //#define AT90USBxx_TEENSYPP_ASSIGNMENTS // Use Teensy++ 2.0 assignments
#ifndef AT90USBxx_TEENSYPP_ASSIGNMENTS // Use traditional Marlin pin assignments #ifndef AT90USBxx_TEENSYPP_ASSIGNMENTS // Use traditional Marlin pin assignments
@@ -3335,8 +3432,7 @@
#define PF7_DDR DDRF #define PF7_DDR DDRF
#endif // AT90USBxx_TEENSYPP_ASSIGNMENTS Teensyduino assignments #endif // AT90USBxx_TEENSYPP_ASSIGNMENTS Teensyduino assignments
#endif // __AVR_AT90usbxxx__ #endif // __AVR_AT90USB(1287|1286|646|647)__
#if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__) #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
// UART // UART
@@ -3368,8 +3464,9 @@
#define DEBUG_LED DIO46 #define DEBUG_LED DIO46
/** /**
pins * Pins Info
*/ */
#define DIO0_PIN PINE0 #define DIO0_PIN PINE0
#define DIO0_RPORT PINE #define DIO0_RPORT PINE
#define DIO0_WPORT PORTE #define DIO0_WPORT PORTE
@@ -3694,9 +3791,6 @@
#define DIO53_DDR DDRF #define DIO53_DDR DDRF
#define DIO53_PWM NULL #define DIO53_PWM NULL
#undef PA0 #undef PA0
#define PA0_PIN PINA0 #define PA0_PIN PINA0
#define PA0_RPORT PINA #define PA0_RPORT PINA
@@ -4027,12 +4121,10 @@
#define PG5_WPORT PORTG #define PG5_WPORT PORTG
#define PG5_DDR DDRG #define PG5_DDR DDRG
#define PG5_PWM &OCR0B #define PG5_PWM &OCR0B
#endif // __AVR_ATmega(1281|2561)__
#endif
#ifndef DIO0_PIN #ifndef DIO0_PIN
#error "pins for this chip not defined in arduino.h! If you write an appropriate pin definition and have this firmware work on your chip, please submit a pull request" #error "pins for this chip not defined in arduino.h! If you write an appropriate pin definition and have this firmware work on your chip, please submit a pull request"
#endif #endif
#endif /* _FASTIO_ARDUINO_H */ #endif // _FASTIO_ARDUINO_H

View File

@@ -0,0 +1,53 @@
/**
* 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/>.
*
*/
#include "Marlin.h"
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER)
#include "hex_print_routines.h"
static char _hex[7] = "0x0000";
char* hex_byte(const uint8_t b) {
_hex[4] = hex_nybble(b >> 4);
_hex[5] = hex_nybble(b);
return &_hex[4];
}
char* hex_word(const uint16_t w) {
_hex[2] = hex_nybble(w >> 12);
_hex[3] = hex_nybble(w >> 8);
_hex[4] = hex_nybble(w >> 4);
_hex[5] = hex_nybble(w);
return &_hex[2];
}
char* hex_address(const void * const w) {
(void)hex_word((uint16_t)w);
return _hex;
}
void print_hex_nybble(const uint8_t n) { SERIAL_CHAR(hex_nybble(n)); }
void print_hex_byte(const uint8_t b) { SERIAL_ECHO(hex_byte(b)); }
void print_hex_word(const uint16_t w) { SERIAL_ECHO(hex_word(w)); }
void print_hex_address(const void * const w) { SERIAL_ECHO(hex_address(w)); }
#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER

View File

@@ -0,0 +1,47 @@
/**
* 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/>.
*
*/
#ifndef HEX_PRINT_ROUTINES_H
#define HEX_PRINT_ROUTINES_H
#include "MarlinConfig.h"
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER)
//
// Utility functions to create and print hex strings as nybble, byte, and word.
//
inline char hex_nybble(const uint8_t n) {
return (n & 0xF) + ((n & 0xF) < 10 ? '0' : 'A' - 10);
}
char* hex_byte(const uint8_t b);
char* hex_word(const uint16_t w);
char* hex_address(const void * const w);
void print_hex_nybble(const uint8_t n);
void print_hex_byte(const uint8_t b);
void print_hex_word(const uint16_t w);
void print_hex_address(const void * const w);
#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER
#endif // HEX_PRINT_ROUTINES_H

View File

@@ -25,6 +25,8 @@
#include "MarlinConfig.h" #include "MarlinConfig.h"
#define _UxGT(a) a
// Define SIMULATE_ROMFONT to see what is seen on the character based display defined in Configuration.h // Define SIMULATE_ROMFONT to see what is seen on the character based display defined in Configuration.h
//#define SIMULATE_ROMFONT //#define SIMULATE_ROMFONT
@@ -106,7 +108,7 @@
// Serial Console Messages (do not translate those!) // Serial Console Messages (do not translate those!)
#define MSG_Enqueueing "enqueueing \"" #define MSG_ENQUEUEING "enqueueing \""
#define MSG_POWERUP "PowerUp" #define MSG_POWERUP "PowerUp"
#define MSG_EXTERNAL_RESET " External Reset" #define MSG_EXTERNAL_RESET " External Reset"
#define MSG_BROWNOUT_RESET " Brown out Reset" #define MSG_BROWNOUT_RESET " Brown out Reset"
@@ -131,8 +133,8 @@
#define MSG_INVALID_SOLENOID "Invalid solenoid" #define MSG_INVALID_SOLENOID "Invalid solenoid"
#define MSG_ERR_NO_THERMISTORS "No thermistors - no temperature" #define MSG_ERR_NO_THERMISTORS "No thermistors - no temperature"
#define MSG_M115_REPORT "FIRMWARE_NAME:Marlin " DETAILED_BUILD_VERSION " SOURCE_CODE_URL:" SOURCE_CODE_URL " PROTOCOL_VERSION:" PROTOCOL_VERSION " MACHINE_TYPE:" MACHINE_NAME " EXTRUDER_COUNT:" STRINGIFY(EXTRUDERS) " UUID:" MACHINE_UUID #define MSG_M115_REPORT "FIRMWARE_NAME:Marlin " DETAILED_BUILD_VERSION " SOURCE_CODE_URL:" SOURCE_CODE_URL " PROTOCOL_VERSION:" PROTOCOL_VERSION " MACHINE_TYPE:" MACHINE_NAME " EXTRUDER_COUNT:" STRINGIFY(EXTRUDERS) " UUID:" MACHINE_UUID
#define MSG_COUNT_X " Count X: " #define MSG_COUNT_X " Count X:"
#define MSG_COUNT_A " Count A: " #define MSG_COUNT_A " Count A:"
#define MSG_ERR_KILLED "Printer halted. kill() called!" #define MSG_ERR_KILLED "Printer halted. kill() called!"
#define MSG_ERR_STOPPED "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)" #define MSG_ERR_STOPPED "Printer stopped due to errors. Fix the error and use M999 to restart. (Temperature is reset. Set it after restarting)"
#define MSG_BUSY_PROCESSING "busy: processing" #define MSG_BUSY_PROCESSING "busy: processing"
@@ -150,11 +152,14 @@
#define MSG_Z2_MIN "z2_min: " #define MSG_Z2_MIN "z2_min: "
#define MSG_Z2_MAX "z2_max: " #define MSG_Z2_MAX "z2_max: "
#define MSG_Z_PROBE "z_probe: " #define MSG_Z_PROBE "z_probe: "
#define MSG_FILAMENT_RUNOUT_SENSOR "filament: "
#define MSG_ERR_MATERIAL_INDEX "M145 S<index> out of range (0-1)" #define MSG_ERR_MATERIAL_INDEX "M145 S<index> out of range (0-1)"
#define MSG_ERR_M421_PARAMETERS "M421 requires XYZ or IJZ parameters" #define MSG_ERR_M355_NONE "No case light"
#define MSG_ERR_MESH_XY "Mesh XY or IJ cannot be resolved" #define MSG_ERR_M421_PARAMETERS "M421 required parameters missing"
#define MSG_ERR_MESH_XY "Mesh point cannot be resolved"
#define MSG_ERR_ARC_ARGS "G2/G3 bad parameters" #define MSG_ERR_ARC_ARGS "G2/G3 bad parameters"
#define MSG_ERR_PROTECTED_PIN "Protected Pin" #define MSG_ERR_PROTECTED_PIN "Protected Pin"
#define MSG_ERR_M420_FAILED "Failed to enable Bed Leveling"
#define MSG_ERR_M428_TOO_FAR "Too far from reference point" #define MSG_ERR_M428_TOO_FAR "Too far from reference point"
#define MSG_ERR_M303_DISABLED "PIDTEMP disabled" #define MSG_ERR_M303_DISABLED "PIDTEMP disabled"
#define MSG_M119_REPORT "Reporting endstop status" #define MSG_M119_REPORT "Reporting endstop status"
@@ -195,6 +200,11 @@
#define MSG_ERR_EEPROM_WRITE "Error writing to EEPROM!" #define MSG_ERR_EEPROM_WRITE "Error writing to EEPROM!"
#define MSG_STOP_BLTOUCH "STOP called because of BLTouch error - restart with M999"
#define MSG_STOP_UNHOMED "STOP called because of unhomed error - restart with M999"
#define MSG_KILL_INACTIVE_TIME "KILL caused by too much inactive time - current command: "
#define MSG_KILL_BUTTON "KILL caused by KILL button/pin"
// temperature.cpp strings // temperature.cpp strings
#define MSG_PID_AUTOTUNE "PID Autotune" #define MSG_PID_AUTOTUNE "PID Autotune"
#define MSG_PID_AUTOTUNE_START MSG_PID_AUTOTUNE " start" #define MSG_PID_AUTOTUNE_START MSG_PID_AUTOTUNE " start"
@@ -258,22 +268,27 @@
#define MSG_H2 "2" #define MSG_H2 "2"
#define MSG_H3 "3" #define MSG_H3 "3"
#define MSG_H4 "4" #define MSG_H4 "4"
#define MSG_H5 "5"
#define MSG_N1 " 1" #define MSG_N1 " 1"
#define MSG_N2 " 2" #define MSG_N2 " 2"
#define MSG_N3 " 3" #define MSG_N3 " 3"
#define MSG_N4 " 4" #define MSG_N4 " 4"
#define MSG_E1 " E1" #define MSG_N5 " 5"
#define MSG_E2 " E2" #define MSG_E1 "E1"
#define MSG_E3 " E3" #define MSG_E2 "E2"
#define MSG_E4 " E4" #define MSG_E3 "E3"
#define MSG_E4 "E4"
#define MSG_E5 "E5"
#define MSG_MOVE_E1 "1" #define MSG_MOVE_E1 "1"
#define MSG_MOVE_E2 "2" #define MSG_MOVE_E2 "2"
#define MSG_MOVE_E3 "3" #define MSG_MOVE_E3 "3"
#define MSG_MOVE_E4 "4" #define MSG_MOVE_E4 "4"
#define MSG_MOVE_E5 "5"
#define MSG_DIAM_E1 " 1" #define MSG_DIAM_E1 " 1"
#define MSG_DIAM_E2 " 2" #define MSG_DIAM_E2 " 2"
#define MSG_DIAM_E3 " 3" #define MSG_DIAM_E3 " 3"
#define MSG_DIAM_E4 " 4" #define MSG_DIAM_E4 " 4"
#define MSG_DIAM_E5 " 5"
#include INCLUDE_LANGUAGE #include INCLUDE_LANGUAGE
@@ -283,7 +298,8 @@
&& DISABLED(DISPLAY_CHARSET_ISO10646_KANA) \ && DISABLED(DISPLAY_CHARSET_ISO10646_KANA) \
&& DISABLED(DISPLAY_CHARSET_ISO10646_GREEK) \ && DISABLED(DISPLAY_CHARSET_ISO10646_GREEK) \
&& DISABLED(DISPLAY_CHARSET_ISO10646_CN) \ && DISABLED(DISPLAY_CHARSET_ISO10646_CN) \
&& DISABLED(DISPLAY_CHARSET_ISO10646_TR) && DISABLED(DISPLAY_CHARSET_ISO10646_TR) \
&& DISABLED(DISPLAY_CHARSET_ISO10646_PL)
#define DISPLAY_CHARSET_ISO10646_1 // use the better font on full graphic displays. #define DISPLAY_CHARSET_ISO10646_1 // use the better font on full graphic displays.
#endif #endif

View File

@@ -32,121 +32,220 @@
#define DISPLAY_CHARSET_ISO10646_1 #define DISPLAY_CHARSET_ISO10646_1
#define WELCOME_MSG MACHINE_NAME " parada." #define WELCOME_MSG MACHINE_NAME _UxGT(" parada.")
#define MSG_SD_INSERTED "Tarcheta colocada" #define MSG_SD_INSERTED _UxGT("Tarcheta mesa")
#define MSG_SD_REMOVED "Tarcheta retirada" #define MSG_SD_REMOVED _UxGT("Tarcheta sacada")
#define MSG_MAIN "Menu prencipal" #define MSG_LCD_ENDSTOPS _UxGT("Endstops") // Max length 8 characters
#define MSG_AUTOSTART " Autostart" #define MSG_MAIN _UxGT("Menu prencipal")
#define MSG_DISABLE_STEPPERS "Amortar motors" #define MSG_AUTOSTART _UxGT("Inicio automatico")
#define MSG_AUTO_HOME "Levar a l'orichen" #define MSG_DISABLE_STEPPERS _UxGT("Amortar motors")
#define MSG_LEVEL_BED_HOMING "Homing XYZ" #define MSG_AUTO_HOME _UxGT("Levar a l'orichen")
#define MSG_LEVEL_BED_WAITING "Click to Begin" #define MSG_AUTO_HOME_X _UxGT("Orichen X")
#define MSG_LEVEL_BED_DONE "Leveling Done!" #define MSG_AUTO_HOME_Y _UxGT("Orichen Y")
#define MSG_LEVEL_BED_CANCEL "Cancel" #define MSG_AUTO_HOME_Z _UxGT("Orichen Z")
#define MSG_SET_HOME_OFFSETS "Set home offsets" #define MSG_LEVEL_BED_HOMING _UxGT("Orichen XYZ")
#define MSG_HOME_OFFSETS_APPLIED "Offsets applied" #define MSG_LEVEL_BED_WAITING _UxGT("Encetar (pretar)")
#define MSG_SET_ORIGIN "Establir zero" #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Vinient punto")
#define MSG_PREHEAT_1 "Precalentar PLA" #define MSG_LEVEL_BED_DONE _UxGT("Nivelacion feita!")
#define MSG_PREHEAT_1_N "Precalentar PLA " #define MSG_LEVEL_BED_CANCEL _UxGT("Cancelar")
#define MSG_PREHEAT_1_ALL "Precalentar PLA a" #define MSG_SET_HOME_OFFSETS _UxGT("Achustar desfases")
#define MSG_PREHEAT_1_BEDONLY "Prec. PLA Base" #define MSG_HOME_OFFSETS_APPLIED _UxGT("Desfase aplicau")
#define MSG_PREHEAT_1_SETTINGS "Achustar tem. PLA" #define MSG_SET_ORIGIN _UxGT("Establir orichen")
#define MSG_PREHEAT_2 "Precalentar ABS" #define MSG_PREHEAT_1 _UxGT("Precalentar PLA")
#define MSG_PREHEAT_2_N "Precalentar ABS " #define MSG_PREHEAT_1_N MSG_PREHEAT_1 _UxGT(" ")
#define MSG_PREHEAT_2_ALL "Precalentar ABS a" #define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 _UxGT(" Tot")
#define MSG_PREHEAT_2_BEDONLY "Prec. ABS Base" #define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 _UxGT(" Base")
#define MSG_PREHEAT_2_SETTINGS "Achustar tem. ABS" #define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 _UxGT(" Conf")
#define MSG_COOLDOWN "Enfriar" #define MSG_PREHEAT_2 _UxGT("Precalentar ABS")
#define MSG_SWITCH_PS_ON "Enchegar Fuent" #define MSG_PREHEAT_2_N MSG_PREHEAT_2 _UxGT(" ")
#define MSG_SWITCH_PS_OFF "Desenchegar Fuent" #define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 _UxGT(" Tot")
#define MSG_EXTRUDE "Extruir" #define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 _UxGT(" Base")
#define MSG_RETRACT "Retraer" #define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 _UxGT(" Conf")
#define MSG_MOVE_AXIS "Mover Eixes" #define MSG_COOLDOWN _UxGT("Enfriar")
#define MSG_MOVE_X "Move X" #define MSG_SWITCH_PS_ON _UxGT("Enchegar Fuent")
#define MSG_MOVE_Y "Move Y" #define MSG_SWITCH_PS_OFF _UxGT("Amortar Fuent")
#define MSG_MOVE_Z "Move Z" #define MSG_EXTRUDE _UxGT("Extruir")
#define MSG_MOVE_E "Extruder" #define MSG_RETRACT _UxGT("Retraer")
#define MSG_MOVE_01MM "Move 0.1mm" #define MSG_MOVE_AXIS _UxGT("Mover Eixes")
#define MSG_MOVE_1MM "Move 1mm" #define MSG_LEVEL_BED _UxGT("Nivelar base")
#define MSG_MOVE_10MM "Move 10mm" #define MSG_MOVE_X _UxGT("Mover X")
#define MSG_SPEED "Velocidat" #define MSG_MOVE_Y _UxGT("Mover Y")
#define MSG_NOZZLE "Nozzle" #define MSG_MOVE_Z _UxGT("Mover Z")
#define MSG_BED "Base" #define MSG_MOVE_E _UxGT("Extrusor")
#define MSG_FAN_SPEED "Ixoriador" #define MSG_MOVE_01MM _UxGT("Mover 0.1mm")
#define MSG_FLOW "Fluxo" #define MSG_MOVE_1MM _UxGT("Mover 1mm")
#define MSG_CONTROL "Control" #define MSG_MOVE_10MM _UxGT("Mover 10mm")
#define MSG_MIN LCD_STR_THERMOMETER " Min" #define MSG_SPEED _UxGT("Velocidat")
#define MSG_MAX LCD_STR_THERMOMETER " Max" #define MSG_BED_Z _UxGT("Base Z")
#define MSG_FACTOR LCD_STR_THERMOMETER " Fact" #define MSG_NOZZLE _UxGT("Boquilla")
#define MSG_AUTOTEMP "Autotemp" #define MSG_BED _UxGT("Base")
#define MSG_ON "On" #define MSG_FAN_SPEED _UxGT("Ixoriador")
#define MSG_OFF "Off" #define MSG_FLOW _UxGT("Fluxo")
#define MSG_PID_P "PID-P" #define MSG_CONTROL _UxGT("Control")
#define MSG_PID_I "PID-I" #define MSG_MIN _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Min")
#define MSG_PID_D "PID-D" #define MSG_MAX _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Max")
#define MSG_PID_C "PID-C" #define MSG_FACTOR _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Fact")
#define MSG_ACC "Acel" #define MSG_AUTOTEMP _UxGT("Temperatura Auto.")
#define MSG_VX_JERK "Vx-jerk" #define MSG_ON _UxGT("On")
#define MSG_VY_JERK "Vy-jerk" #define MSG_OFF _UxGT("Off")
#define MSG_VZ_JERK "Vz-jerk" #define MSG_PID_P _UxGT("PID-P")
#define MSG_VE_JERK "Ves-jerk" #define MSG_PID_I _UxGT("PID-I")
#define MSG_VMAX "Vmax" #define MSG_PID_D _UxGT("PID-D")
#define MSG_VMIN "Vmin" #define MSG_PID_C _UxGT("PID-C")
#define MSG_VTRAV_MIN "VTrav min" #define MSG_SELECT _UxGT("Trigar")
#define MSG_AMAX "Amax" #define MSG_ACC _UxGT("Aceleracion")
#define MSG_A_RETRACT "A-retrac." #define MSG_VX_JERK _UxGT("Vx-jerk")
#define MSG_XSTEPS "X trangos/mm" #define MSG_VY_JERK _UxGT("Vy-jerk")
#define MSG_YSTEPS "Y trangos/mm" #define MSG_VZ_JERK _UxGT("Vz-jerk")
#define MSG_ZSTEPS "Z trangos/mm" #define MSG_VE_JERK _UxGT("Ve-jerk")
#define MSG_ESTEPS "E trangos/mm" #define MSG_VMAX _UxGT("Vmax")
#define MSG_TEMPERATURE "Temperatura" #define MSG_VMIN _UxGT("Vmin")
#define MSG_MOTION "Movimiento" #define MSG_VTRAV_MIN _UxGT("Vel. viache min")
#define MSG_VOLUMETRIC "Filament" #define MSG_AMAX _UxGT("Acel. max")
#define MSG_VOLUMETRIC_ENABLED "E in mm3" #define MSG_A_RETRACT _UxGT("Acel. retrac.")
#define MSG_FILAMENT_DIAM "Fil. Dia." #define MSG_A_TRAVEL _UxGT("Acel. Viaje")
#define MSG_CONTRAST "Contrast" #define MSG_XSTEPS _UxGT("X trangos/mm")
#define MSG_STORE_EPROM "Alzar Memoria" #define MSG_YSTEPS _UxGT("Y trangos/mm")
#define MSG_LOAD_EPROM "Cargar Memoria" #define MSG_ZSTEPS _UxGT("Z trangos/mm")
#define MSG_RESTORE_FAILSAFE "Rest. d'emerchen." #define MSG_ESTEPS _UxGT("E trangos/mm")
#define MSG_REFRESH "Tornar a cargar" #define MSG_E1STEPS _UxGT("E1 trangos/mm")
#define MSG_WATCH "Monitorizar" #define MSG_E2STEPS _UxGT("E2 trangos/mm")
#define MSG_PREPARE "Preparar" #define MSG_E3STEPS _UxGT("E3 trangos/mm")
#define MSG_TUNE "Achustar" #define MSG_E4STEPS _UxGT("E4 trangos/mm")
#define MSG_PAUSE_PRINT "Pausar impresion" #define MSG_E5STEPS _UxGT("E5 trangos/mm")
#define MSG_RESUME_PRINT "Contin. impresion" #define MSG_TEMPERATURE _UxGT("Temperatura")
#define MSG_STOP_PRINT "Detener Impresion" #define MSG_MOTION _UxGT("Movimiento")
#define MSG_CARD_MENU "Menu de SD" #define MSG_FILAMENT _UxGT("Filamento")
#define MSG_NO_CARD "No i hai tarcheta" #define MSG_VOLUMETRIC_ENABLED _UxGT("E in mm3")
#define MSG_DWELL "Reposo..." #define MSG_FILAMENT_DIAM _UxGT("Fil. Dia.")
#define MSG_USERWAIT "Asperan. ordines" #define MSG_CONTRAST _UxGT("Contraste")
#define MSG_RESUMING "Contin. impresion" #define MSG_STORE_EEPROM _UxGT("Alzar memoria")
#define MSG_PRINT_ABORTED "Print aborted" #define MSG_LOAD_EEPROM _UxGT("Cargar memoria")
#define MSG_NO_MOVE "Sin movimiento" #define MSG_RESTORE_FAILSAFE _UxGT("Restaurar memoria")
#define MSG_KILLED "ATURADA D'EMERCH." #define MSG_REFRESH _UxGT("Tornar a cargar")
#define MSG_STOPPED "ATURADA." #define MSG_WATCH _UxGT("Informacion")
#define MSG_CONTROL_RETRACT "Retraer mm" #define MSG_PREPARE _UxGT("Preparar")
#define MSG_CONTROL_RETRACT_SWAP "Swap Retraer mm" #define MSG_TUNE _UxGT("Achustar")
#define MSG_CONTROL_RETRACTF "Retraer F" #define MSG_PAUSE_PRINT _UxGT("Pausar impresion")
#define MSG_CONTROL_RETRACT_ZLIFT "Devantar mm" #define MSG_RESUME_PRINT _UxGT("Contin. impresion")
#define MSG_CONTROL_RETRACT_RECOVER "DesRet +mm" #define MSG_STOP_PRINT _UxGT("Detener Impresion")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "Swap DesRet +mm" #define MSG_CARD_MENU _UxGT("Menu de SD")
#define MSG_CONTROL_RETRACT_RECOVERF "DesRet F" #define MSG_NO_CARD _UxGT("No i hai tarcheta")
#define MSG_AUTORETRACT "AutoRetr." #define MSG_DWELL _UxGT("Reposo...")
#define MSG_FILAMENTCHANGE "Cambear" #define MSG_USERWAIT _UxGT("Aguardand ordines")
#define MSG_INIT_SDCARD "Encetan. tarcheta" #define MSG_RESUMING _UxGT("Contin. impresion")
#define MSG_CNG_SDCARD "Cambiar tarcheta" #define MSG_PRINT_ABORTED _UxGT("Impres. cancelada")
#define MSG_ZPROBE_OUT "Z probe out. bed" #define MSG_NO_MOVE _UxGT("Sin movimiento")
#define MSG_HOME "Home" // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST #define MSG_KILLED _UxGT("Aturada d'emerch.")
#define MSG_FIRST "first" #define MSG_STOPPED _UxGT("Aturada.")
#define MSG_ZPROBE_ZOFFSET "Z Offset" #define MSG_CONTROL_RETRACT _UxGT("Retraer mm")
#define MSG_BABYSTEP_X "Babystep X" #define MSG_CONTROL_RETRACT_SWAP _UxGT("Swap Retraer mm")
#define MSG_BABYSTEP_Y "Babystep Y" #define MSG_CONTROL_RETRACTF _UxGT("Retraer F")
#define MSG_BABYSTEP_Z "Babystep Z" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Devantar mm")
#define MSG_ENDSTOP_ABORT "Endstop abort" #define MSG_CONTROL_RETRACT_RECOVER _UxGT("DesRet mm")
#define MSG_DELTA_CALIBRATE "Delta Calibration" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("Swap DesRet mm")
#define MSG_DELTA_CALIBRATE_X "Calibrate X" #define MSG_CONTROL_RETRACT_RECOVERF _UxGT("DesRet F")
#define MSG_DELTA_CALIBRATE_Y "Calibrate Y" #define MSG_AUTORETRACT _UxGT("Retraccion auto.")
#define MSG_DELTA_CALIBRATE_Z "Calibrate Z" #define MSG_FILAMENTCHANGE _UxGT("Cambear filamento")
#define MSG_DELTA_CALIBRATE_CENTER "Calibrate Center" #define MSG_INIT_SDCARD _UxGT("Encetan. tarcheta")
#define MSG_CNG_SDCARD _UxGT("Cambiar tarcheta")
#define MSG_ZPROBE_OUT _UxGT("Sonda Z fuera")
#define MSG_BLTOUCH_SELFTEST _UxGT("BLTouch Auto-Test")
#define MSG_BLTOUCH_RESET _UxGT("Reset BLTouch")
#define MSG_HOME _UxGT("Home") // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#define MSG_FIRST _UxGT("first")
#define MSG_ZPROBE_ZOFFSET _UxGT("Desfase Z")
#define MSG_BABYSTEP_X _UxGT("Micropaso X")
#define MSG_BABYSTEP_Y _UxGT("Micropaso Y")
#define MSG_BABYSTEP_Z _UxGT("Micropaso Z")
#define MSG_ENDSTOP_ABORT _UxGT("Cancelado - Endstop")
#define MSG_HEATING_FAILED_LCD _UxGT("Error: en calentar")
#define MSG_ERR_REDUNDANT_TEMP _UxGT("Error: temperatura")
#define MSG_THERMAL_RUNAWAY _UxGT("Error de temperatura")
#define MSG_ERR_MAXTEMP _UxGT("Error: Temp Maxima")
#define MSG_ERR_MINTEMP _UxGT("Error: Temp Menima")
#define MSG_ERR_MAXTEMP_BED _UxGT("Error: Temp Max base")
#define MSG_ERR_MINTEMP_BED _UxGT("Error: Temp Min base")
#define MSG_ERR_Z_HOMING _UxGT("G28 Z vedau")
#define MSG_HALTED _UxGT("IMPRESORA ATURADA")
#define MSG_PLEASE_RESET _UxGT("Per favor reinic.")
#define MSG_SHORT_DAY _UxGT("d")
#define MSG_SHORT_HOUR _UxGT("h")
#define MSG_SHORT_MINUTE _UxGT("m")
#define MSG_HEATING _UxGT("Calentando...")
#define MSG_HEATING_COMPLETE _UxGT("Calentamiento listo")
#define MSG_BED_HEATING _UxGT("Calentando base...")
#define MSG_BED_DONE _UxGT("Base calient")
#define MSG_DELTA_CALIBRATE _UxGT("Calibracion Delta")
#define MSG_DELTA_CALIBRATE_X _UxGT("Calibrar X")
#define MSG_DELTA_CALIBRATE_Y _UxGT("Calibrar Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Calibrar Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Calibrar Centro")
#define MSG_INFO_MENU _UxGT("Inf. Impresora")
#define MSG_INFO_PRINTER_MENU _UxGT("Inf. Impresora")
#define MSG_INFO_STATS_MENU _UxGT("Estadisticas Imp.")
#define MSG_INFO_BOARD_MENU _UxGT("Inf. Controlador")
#define MSG_INFO_THERMISTOR_MENU _UxGT("Termistors")
#define MSG_INFO_EXTRUDERS _UxGT("Extrusors")
#define MSG_INFO_BAUDRATE _UxGT("Baudios")
#define MSG_INFO_PROTOCOL _UxGT("Protocolo")
#define MSG_LIGHTS_ON _UxGT("Enchegar luz")
#define MSG_LIGHTS_OFF _UxGT("Desenchegar luz")
#if LCD_WIDTH >= 20
#define MSG_INFO_PRINT_COUNT _UxGT("Conteo de impresion")
#define MSG_INFO_COMPLETED_PRINTS _UxGT("Completadas")
#define MSG_INFO_PRINT_TIME _UxGT("Tiempo total d'imp.")
#define MSG_INFO_PRINT_LONGEST _UxGT("Impresion mas larga")
#define MSG_INFO_PRINT_FILAMENT _UxGT("Total d'extrusion")
#else
#define MSG_INFO_PRINT_COUNT _UxGT("Impresions")
#define MSG_INFO_COMPLETED_PRINTS _UxGT("Completadas")
#define MSG_INFO_PRINT_TIME _UxGT("Total")
#define MSG_INFO_PRINT_LONGEST _UxGT("Mas larga")
#define MSG_INFO_PRINT_FILAMENT _UxGT("Extrusion")
#endif
#define MSG_INFO_MIN_TEMP _UxGT("Temperatura menima")
#define MSG_INFO_MAX_TEMP _UxGT("Temperatura maxima")
#define MSG_INFO_PSU _UxGT("Fuente de aliment")
#define MSG_DRIVE_STRENGTH _UxGT("Fuerza d'o driver")
#define MSG_DAC_PERCENT _UxGT("Driver %")
#define MSG_DAC_EEPROM_WRITE _UxGT("Escri. DAC EEPROM")
#define MSG_FILAMENT_CHANGE_HEADER _UxGT("Cambear filamento")
#define MSG_FILAMENT_CHANGE_OPTION_HEADER _UxGT("Opcion de cambio:")
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Extruir mas")
#define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Resumir imp.")
//
// Filament Change screens show up to 3 lines on a 4-line display
// ...or up to 2 lines on a 3-line display
//
#define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Aguardand iniciar")
#define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Meta o filamento")
#define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("y prete lo boton")
#if LCD_HEIGHT >= 4
// Up to 3 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("d'o filamento")
#define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("cambear")
#define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("pa continar...")
#else // LCD_HEIGHT < 4
// Up to 2 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("d'o fil. cambear")
#define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Meta o filamento")
#endif // LCD_HEIGHT < 4
#define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Aguardando a")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("expulsar filament")
#define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Aguardando a")
#define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("cargar filamento")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Aguardando a")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("extruir filamento")
#define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Aguardando impre.")
#define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("pa continar")
#endif // LANGUAGE_AN_H #endif // LANGUAGE_AN_H

View File

@@ -33,213 +33,218 @@
#define MAPPER_D0D1 // For Cyrillic #define MAPPER_D0D1 // For Cyrillic
#define DISPLAY_CHARSET_ISO10646_5 #define DISPLAY_CHARSET_ISO10646_5
#define WELCOME_MSG MACHINE_NAME " Готов." #define WELCOME_MSG MACHINE_NAME _UxGT(" Готов.")
#define MSG_SD_INSERTED "Картата е поставена" #define MSG_SD_INSERTED _UxGT("Картата е поставена")
#define MSG_SD_REMOVED "Картата е извадена" #define MSG_SD_REMOVED _UxGT("Картата е извадена")
#define MSG_LCD_ENDSTOPS "Endstops" // Max length 8 characters #define MSG_LCD_ENDSTOPS _UxGT("Endstops") // Max length 8 characters
#define MSG_MAIN "Меню" #define MSG_MAIN _UxGT("Меню")
#define MSG_AUTOSTART "Автостарт" #define MSG_AUTOSTART _UxGT("Автостарт")
#define MSG_DISABLE_STEPPERS "Изкл. двигатели" #define MSG_DISABLE_STEPPERS _UxGT("Изкл. двигатели")
#define MSG_AUTO_HOME "Паркиране" #define MSG_AUTO_HOME _UxGT("Паркиране")
#define MSG_AUTO_HOME_X "Home X" #define MSG_AUTO_HOME_X _UxGT("Home X")
#define MSG_AUTO_HOME_Y "Home Y" #define MSG_AUTO_HOME_Y _UxGT("Home Y")
#define MSG_AUTO_HOME_Z "Home Z" #define MSG_AUTO_HOME_Z _UxGT("Home Z")
#define MSG_LEVEL_BED_HOMING "Homing XYZ" #define MSG_LEVEL_BED_HOMING _UxGT("Homing XYZ")
#define MSG_LEVEL_BED_WAITING "Click to Begin" #define MSG_LEVEL_BED_WAITING _UxGT("Click to Begin")
#define MSG_LEVEL_BED_NEXT_POINT "Next Point" #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Next Point")
#define MSG_LEVEL_BED_DONE "Leveling Done!" #define MSG_LEVEL_BED_DONE _UxGT("Leveling Done!")
#define MSG_LEVEL_BED_CANCEL "Cancel" #define MSG_LEVEL_BED_CANCEL _UxGT("Cancel")
#define MSG_SET_HOME_OFFSETS "Задай Начало" #define MSG_SET_HOME_OFFSETS _UxGT("Задай Начало")
#define MSG_HOME_OFFSETS_APPLIED "Offsets applied" #define MSG_HOME_OFFSETS_APPLIED _UxGT("Offsets applied")
#define MSG_SET_ORIGIN "Изходна точка" #define MSG_SET_ORIGIN _UxGT("Изходна точка")
#define MSG_PREHEAT_1 "Подгряване PLA" #define MSG_PREHEAT_1 _UxGT("Подгряване PLA")
#define MSG_PREHEAT_1_N "Подгряване PLA" #define MSG_PREHEAT_1_N _UxGT("Подгряване PLA")
#define MSG_PREHEAT_1_ALL "Подгр. PLA Всички" #define MSG_PREHEAT_1_ALL _UxGT("Подгр. PLA Всички")
#define MSG_PREHEAT_1_BEDONLY "Подгр. PLA Легло" #define MSG_PREHEAT_1_BEDONLY _UxGT("Подгр. PLA Легло")
#define MSG_PREHEAT_1_SETTINGS "Настройки PLA" #define MSG_PREHEAT_1_SETTINGS _UxGT("Настройки PLA")
#define MSG_PREHEAT_2 "Подгряване ABS" #define MSG_PREHEAT_2 _UxGT("Подгряване ABS")
#define MSG_PREHEAT_2_N "Подгряване ABS" #define MSG_PREHEAT_2_N _UxGT("Подгряване ABS")
#define MSG_PREHEAT_2_ALL "Подгр. ABS Всички" #define MSG_PREHEAT_2_ALL _UxGT("Подгр. ABS Всички")
#define MSG_PREHEAT_2_BEDONLY "Подгр. ABS Легло" #define MSG_PREHEAT_2_BEDONLY _UxGT("Подгр. ABS Легло")
#define MSG_PREHEAT_2_SETTINGS "Настройки ABS" #define MSG_PREHEAT_2_SETTINGS _UxGT("Настройки ABS")
#define MSG_COOLDOWN "Охлаждане" #define MSG_COOLDOWN _UxGT("Охлаждане")
#define MSG_SWITCH_PS_ON "Вкл. захранване" #define MSG_SWITCH_PS_ON _UxGT("Вкл. захранване")
#define MSG_SWITCH_PS_OFF "Изкл. захранване" #define MSG_SWITCH_PS_OFF _UxGT("Изкл. захранване")
#define MSG_EXTRUDE "Екструзия" #define MSG_EXTRUDE _UxGT("Екструзия")
#define MSG_RETRACT "Откат" #define MSG_RETRACT _UxGT("Откат")
#define MSG_MOVE_AXIS "Движение по ос" #define MSG_MOVE_AXIS _UxGT("Движение по ос")
#define MSG_LEVEL_BED "Нивелиране" #define MSG_LEVEL_BED _UxGT("Нивелиране")
#define MSG_MOVE_X "Движение по X" #define MSG_MOVE_X _UxGT("Движение по X")
#define MSG_MOVE_Y "Движение по Y" #define MSG_MOVE_Y _UxGT("Движение по Y")
#define MSG_MOVE_Z "Движение по Z" #define MSG_MOVE_Z _UxGT("Движение по Z")
#define MSG_MOVE_E "Екструдер" #define MSG_MOVE_E _UxGT("Екструдер")
#define MSG_MOVE_01MM "Премести с 0.1mm" #define MSG_MOVE_01MM _UxGT("Премести с 0.1mm")
#define MSG_MOVE_1MM "Премести с 1mm" #define MSG_MOVE_1MM _UxGT("Премести с 1mm")
#define MSG_MOVE_10MM "Премести с 10mm" #define MSG_MOVE_10MM _UxGT("Премести с 10mm")
#define MSG_SPEED "Скорост" #define MSG_SPEED _UxGT("Скорост")
#define MSG_BED_Z "Bed Z" #define MSG_BED_Z _UxGT("Bed Z")
#define MSG_NOZZLE LCD_STR_THERMOMETER " Дюза" #define MSG_NOZZLE LCD_STR_THERMOMETER _UxGT(" Дюза")
#define MSG_BED LCD_STR_THERMOMETER " Легло" #define MSG_BED LCD_STR_THERMOMETER _UxGT(" Легло")
#define MSG_FAN_SPEED "Вентилатор" #define MSG_FAN_SPEED _UxGT("Вентилатор")
#define MSG_FLOW "Поток" #define MSG_FLOW _UxGT("Поток")
#define MSG_CONTROL "Управление" #define MSG_CONTROL _UxGT("Управление")
#define MSG_MIN LCD_STR_THERMOMETER " Минимум" #define MSG_MIN LCD_STR_THERMOMETER _UxGT(" Минимум")
#define MSG_MAX LCD_STR_THERMOMETER " Максимум" #define MSG_MAX LCD_STR_THERMOMETER _UxGT(" Максимум")
#define MSG_FACTOR LCD_STR_THERMOMETER " Фактор" #define MSG_FACTOR LCD_STR_THERMOMETER _UxGT(" Фактор")
#define MSG_AUTOTEMP "Авто-темп." #define MSG_AUTOTEMP _UxGT("Авто-темп.")
#define MSG_ON "Вкл. " #define MSG_ON _UxGT("Вкл. ")
#define MSG_OFF "Изкл. " #define MSG_OFF _UxGT("Изкл. ")
#define MSG_PID_P "PID-P" #define MSG_PID_P _UxGT("PID-P")
#define MSG_PID_I "PID-I" #define MSG_PID_I _UxGT("PID-I")
#define MSG_PID_D "PID-D" #define MSG_PID_D _UxGT("PID-D")
#define MSG_PID_C "PID-C" #define MSG_PID_C _UxGT("PID-C")
#define MSG_SELECT "Select" #define MSG_SELECT _UxGT("Select")
#define MSG_ACC "Acc" #define MSG_ACC _UxGT("Acc")
#define MSG_VX_JERK "Vx-jerk" #define MSG_VX_JERK _UxGT("Vx-jerk")
#define MSG_VY_JERK "Vy-jerk" #define MSG_VY_JERK _UxGT("Vy-jerk")
#define MSG_VZ_JERK "Vz-jerk" #define MSG_VZ_JERK _UxGT("Vz-jerk")
#define MSG_VE_JERK "Ve-jerk" #define MSG_VE_JERK _UxGT("Ve-jerk")
#define MSG_VMAX "Vmax " #define MSG_VMAX _UxGT("Vmax ")
#define MSG_VMIN "Vmin" #define MSG_VMIN _UxGT("Vmin")
#define MSG_VTRAV_MIN "VTrav min" #define MSG_VTRAV_MIN _UxGT("VTrav min")
#define MSG_AMAX "Amax " #define MSG_AMAX _UxGT("Amax ")
#define MSG_A_RETRACT "A-откат" #define MSG_A_RETRACT _UxGT("A-откат")
#define MSG_A_TRAVEL "A-travel" #define MSG_A_TRAVEL _UxGT("A-travel")
#define MSG_XSTEPS "X стъпки/mm" #define MSG_XSTEPS _UxGT("X стъпки/mm")
#define MSG_YSTEPS "Y стъпки/mm" #define MSG_YSTEPS _UxGT("Y стъпки/mm")
#define MSG_ZSTEPS "Z стъпки/mm" #define MSG_ZSTEPS _UxGT("Z стъпки/mm")
#define MSG_ESTEPS "E стъпки/mm" #define MSG_ESTEPS _UxGT("E стъпки/mm")
#define MSG_TEMPERATURE "Температура" #define MSG_E1STEPS _UxGT("E1 стъпки/mm")
#define MSG_MOTION "Движение" #define MSG_E2STEPS _UxGT("E2 стъпки/mm")
#define MSG_VOLUMETRIC "Нишка" #define MSG_E3STEPS _UxGT("E3 стъпки/mm")
#define MSG_VOLUMETRIC_ENABLED "E in mm3" #define MSG_E4STEPS _UxGT("E4 стъпки/mm")
#define MSG_FILAMENT_DIAM "Диам. нишка" #define MSG_E5STEPS _UxGT("E5 стъпки/mm")
#define MSG_CONTRAST "LCD контраст" #define MSG_TEMPERATURE _UxGT("Температура")
#define MSG_STORE_EPROM "Запази в EPROM" #define MSG_MOTION _UxGT("Движение")
#define MSG_LOAD_EPROM "Зареди от EPROM" #define MSG_FILAMENT _UxGT("Нишка")
#define MSG_RESTORE_FAILSAFE "Фабрични настройки" #define MSG_VOLUMETRIC_ENABLED _UxGT("E in mm3")
#define MSG_REFRESH LCD_STR_REFRESH "Обнови" #define MSG_FILAMENT_DIAM _UxGT("Диам. нишка")
#define MSG_WATCH "Преглед" #define MSG_CONTRAST _UxGT("LCD контраст")
#define MSG_PREPARE "Действия" #define MSG_STORE_EEPROM _UxGT("Запази в EPROM")
#define MSG_TUNE "Настройка" #define MSG_LOAD_EEPROM _UxGT("Зареди от EPROM")
#define MSG_PAUSE_PRINT "Пауза" #define MSG_RESTORE_FAILSAFE _UxGT("Фабрични настройки")
#define MSG_RESUME_PRINT "Възобнови печата" #define MSG_REFRESH LCD_STR_REFRESH _UxGT("Обнови")
#define MSG_STOP_PRINT "Спри печата" #define MSG_WATCH _UxGT("Преглед")
#define MSG_CARD_MENU "Меню карта" #define MSG_PREPARE _UxGT("Действия")
#define MSG_NO_CARD "Няма карта" #define MSG_TUNE _UxGT("Настройка")
#define MSG_DWELL "Почивка..." #define MSG_PAUSE_PRINT _UxGT("Пауза")
#define MSG_USERWAIT "Изчакване" #define MSG_RESUME_PRINT _UxGT("Възобнови печата")
#define MSG_RESUMING "Продълж. печата" #define MSG_STOP_PRINT _UxGT("Спри печата")
#define MSG_PRINT_ABORTED "Печатът е прекъснат" #define MSG_CARD_MENU _UxGT("Меню карта")
#define MSG_NO_MOVE "Няма движение" #define MSG_NO_CARD _UxGT("Няма карта")
#define MSG_KILLED "УБИТО." #define MSG_DWELL _UxGT("Почивка...")
#define MSG_STOPPED "СПРЯНО." #define MSG_USERWAIT _UxGT("Изчакване")
#define MSG_CONTROL_RETRACT "Откат mm" #define MSG_RESUMING _UxGT("Продълж. печата")
#define MSG_CONTROL_RETRACT_SWAP "Смяна Откат mm" #define MSG_PRINT_ABORTED _UxGT("Печатът е прекъснат")
#define MSG_CONTROL_RETRACTF "Откат V" #define MSG_NO_MOVE _UxGT("Няма движение")
#define MSG_CONTROL_RETRACT_ZLIFT "Скок mm" #define MSG_KILLED _UxGT("УБИТО.")
#define MSG_CONTROL_RETRACT_RECOVER "Възврат +mm" #define MSG_STOPPED _UxGT("СПРЯНО.")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "Смяна Възврат +mm" #define MSG_CONTROL_RETRACT _UxGT("Откат mm")
#define MSG_CONTROL_RETRACT_RECOVERF "Възврат V" #define MSG_CONTROL_RETRACT_SWAP _UxGT("Смяна Откат mm")
#define MSG_AUTORETRACT "Автоoткат" #define MSG_CONTROL_RETRACTF _UxGT("Откат V")
#define MSG_FILAMENTCHANGE "Смяна нишка" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Скок mm")
#define MSG_INIT_SDCARD "Иниц. SD-Карта" #define MSG_CONTROL_RETRACT_RECOVER _UxGT("Възврат mm")
#define MSG_CNG_SDCARD "Смяна SD-Карта" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("Смяна Възврат mm")
#define MSG_ZPROBE_OUT "Z-сондата е извадена" #define MSG_CONTROL_RETRACT_RECOVERF _UxGT("Възврат V")
#define MSG_BLTOUCH_SELFTEST "BLTouch Self-Test" #define MSG_AUTORETRACT _UxGT("Автоoткат")
#define MSG_BLTOUCH_RESET "Reset BLTouch" #define MSG_FILAMENTCHANGE _UxGT("Смяна нишка")
#define MSG_HOME "Home" // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST #define MSG_INIT_SDCARD _UxGT("Иниц. SD-Карта")
#define MSG_FIRST "first" #define MSG_CNG_SDCARD _UxGT("Смяна SD-Карта")
#define MSG_ZPROBE_ZOFFSET "Z Отстояние" #define MSG_ZPROBE_OUT _UxGT("Z-сондата е извадена")
#define MSG_BABYSTEP_X "Министъпка X" #define MSG_BLTOUCH_SELFTEST _UxGT("BLTouch Self-Test")
#define MSG_BABYSTEP_Y "Министъпка Y" #define MSG_BLTOUCH_RESET _UxGT("Reset BLTouch")
#define MSG_BABYSTEP_Z "Министъпка Z" #define MSG_HOME _UxGT("Home") // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#define MSG_ENDSTOP_ABORT "Стоп Кр.Изключватели" #define MSG_FIRST _UxGT("first")
#define MSG_HEATING_FAILED_LCD "Heating failed" #define MSG_ZPROBE_ZOFFSET _UxGT("Z Отстояние")
#define MSG_ERR_REDUNDANT_TEMP "Err: REDUNDANT TEMP" #define MSG_BABYSTEP_X _UxGT("Министъпка X")
#define MSG_THERMAL_RUNAWAY "THERMAL RUNAWAY" #define MSG_BABYSTEP_Y _UxGT("Министъпка Y")
#define MSG_ERR_MAXTEMP "Err: MAXTEMP" #define MSG_BABYSTEP_Z _UxGT("Министъпка Z")
#define MSG_ERR_MINTEMP "Err: MINTEMP" #define MSG_ENDSTOP_ABORT _UxGT("Стоп Кр.Изключватели")
#define MSG_ERR_MAXTEMP_BED "Err: MAXTEMP BED" #define MSG_HEATING_FAILED_LCD _UxGT("Heating failed")
#define MSG_ERR_MINTEMP_BED "Err: MINTEMP BED" #define MSG_ERR_REDUNDANT_TEMP _UxGT("Err: REDUNDANT TEMP")
#define MSG_ERR_Z_HOMING "G28 Z Forbidden" #define MSG_THERMAL_RUNAWAY _UxGT("THERMAL RUNAWAY")
#define MSG_HALTED "PRINTER HALTED" #define MSG_ERR_MAXTEMP _UxGT("Err: MAXTEMP")
#define MSG_PLEASE_RESET "Please reset" #define MSG_ERR_MINTEMP _UxGT("Err: MINTEMP")
#define MSG_SHORT_DAY "d" // One character only #define MSG_ERR_MAXTEMP_BED _UxGT("Err: MAXTEMP BED")
#define MSG_SHORT_HOUR "h" // One character only #define MSG_ERR_MINTEMP_BED _UxGT("Err: MINTEMP BED")
#define MSG_SHORT_MINUTE "m" // One character only #define MSG_ERR_Z_HOMING _UxGT("G28 Z Forbidden")
#define MSG_HEATING "Heating..." #define MSG_HALTED _UxGT("PRINTER HALTED")
#define MSG_HEATING_COMPLETE "Heating done." #define MSG_PLEASE_RESET _UxGT("Please reset")
#define MSG_BED_HEATING "Bed Heating." #define MSG_SHORT_DAY _UxGT("d") // One character only
#define MSG_BED_DONE "Bed done." #define MSG_SHORT_HOUR _UxGT("h") // One character only
#define MSG_DELTA_CALIBRATE "Делта Калибровка" #define MSG_SHORT_MINUTE _UxGT("m") // One character only
#define MSG_DELTA_CALIBRATE_X "Калибровка X" #define MSG_HEATING _UxGT("Heating...")
#define MSG_DELTA_CALIBRATE_Y "Калибровка Y" #define MSG_HEATING_COMPLETE _UxGT("Heating done.")
#define MSG_DELTA_CALIBRATE_Z "Калибровка Z" #define MSG_BED_HEATING _UxGT("Bed Heating.")
#define MSG_DELTA_CALIBRATE_CENTER "Калибровка Център" #define MSG_BED_DONE _UxGT("Bed done.")
#define MSG_DELTA_CALIBRATE _UxGT("Делта Калибровка")
#define MSG_DELTA_CALIBRATE_X _UxGT("Калибровка X")
#define MSG_DELTA_CALIBRATE_Y _UxGT("Калибровка Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Калибровка Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Калибровка Център")
#define MSG_INFO_MENU "About Printer" #define MSG_INFO_MENU _UxGT("About Printer")
#define MSG_INFO_PRINTER_MENU "Printer Info" #define MSG_INFO_PRINTER_MENU _UxGT("Printer Info")
#define MSG_INFO_STATS_MENU "Printer Stats" #define MSG_INFO_STATS_MENU _UxGT("Printer Stats")
#define MSG_INFO_BOARD_MENU "Board Info" #define MSG_INFO_BOARD_MENU _UxGT("Board Info")
#define MSG_INFO_THERMISTOR_MENU "Thermistors" #define MSG_INFO_THERMISTOR_MENU _UxGT("Thermistors")
#define MSG_INFO_EXTRUDERS "Extruders" #define MSG_INFO_EXTRUDERS _UxGT("Extruders")
#define MSG_INFO_BAUDRATE "Baud" #define MSG_INFO_BAUDRATE _UxGT("Baud")
#define MSG_INFO_PROTOCOL "Protocol" #define MSG_INFO_PROTOCOL _UxGT("Protocol")
#define MSG_LIGHTS_ON "Case light on" #define MSG_LIGHTS_ON _UxGT("Case light on")
#define MSG_LIGHTS_OFF "Case light off" #define MSG_LIGHTS_OFF _UxGT("Case light off")
#if LCD_WIDTH >= 20 #if LCD_WIDTH >= 20
#define MSG_INFO_PRINT_COUNT "Print Count" #define MSG_INFO_PRINT_COUNT _UxGT("Print Count")
#define MSG_INFO_COMPLETED_PRINTS "Completed" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Completed")
#define MSG_INFO_PRINT_TIME "Total print time" #define MSG_INFO_PRINT_TIME _UxGT("Total print time")
#define MSG_INFO_PRINT_LONGEST "Longest job time" #define MSG_INFO_PRINT_LONGEST _UxGT("Longest job time")
#define MSG_INFO_PRINT_FILAMENT "Extruded total" #define MSG_INFO_PRINT_FILAMENT _UxGT("Extruded total")
#else #else
#define MSG_INFO_PRINT_COUNT "Prints" #define MSG_INFO_PRINT_COUNT _UxGT("Prints")
#define MSG_INFO_COMPLETED_PRINTS "Completed" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Completed")
#define MSG_INFO_PRINT_TIME "Total" #define MSG_INFO_PRINT_TIME _UxGT("Total")
#define MSG_INFO_PRINT_LONGEST "Longest" #define MSG_INFO_PRINT_LONGEST _UxGT("Longest")
#define MSG_INFO_PRINT_FILAMENT "Extruded" #define MSG_INFO_PRINT_FILAMENT _UxGT("Extruded")
#endif #endif
#define MSG_INFO_MIN_TEMP "Min Temp" #define MSG_INFO_MIN_TEMP _UxGT("Min Temp")
#define MSG_INFO_MAX_TEMP "Max Temp" #define MSG_INFO_MAX_TEMP _UxGT("Max Temp")
#define MSG_INFO_PSU "Power Supply" #define MSG_INFO_PSU _UxGT("Power Supply")
#define MSG_DRIVE_STRENGTH "Drive Strength" #define MSG_DRIVE_STRENGTH _UxGT("Drive Strength")
#define MSG_DAC_PERCENT "Driver %" #define MSG_DAC_PERCENT _UxGT("Driver %")
#define MSG_DAC_EEPROM_WRITE "DAC EEPROM Write" #define MSG_DAC_EEPROM_WRITE _UxGT("DAC EEPROM Write")
#define MSG_FILAMENT_CHANGE_HEADER "CHANGE FILAMENT" #define MSG_FILAMENT_CHANGE_HEADER _UxGT("CHANGE FILAMENT")
#define MSG_FILAMENT_CHANGE_OPTION_HEADER "CHANGE OPTIONS:" #define MSG_FILAMENT_CHANGE_OPTION_HEADER _UxGT("CHANGE OPTIONS:")
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE "Extrude more" #define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Extrude more")
#define MSG_FILAMENT_CHANGE_OPTION_RESUME "Resume print" #define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Resume print")
#if LCD_HEIGHT >= 4 #if LCD_HEIGHT >= 4
// Up to 3 lines allowed // Up to 3 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_1 "Wait for start" #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Wait for start")
#define MSG_FILAMENT_CHANGE_INIT_2 "of the filament" #define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("of the filament")
#define MSG_FILAMENT_CHANGE_INIT_3 "change" #define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("change")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Wait for" #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 "filament unload" #define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("filament unload")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Insert filament" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Insert filament")
#define MSG_FILAMENT_CHANGE_INSERT_2 "and press button" #define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("and press button")
#define MSG_FILAMENT_CHANGE_INSERT_3 "to continue..." #define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("to continue...")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Wait for" #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_LOAD_2 "filament load" #define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("filament load")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Wait for" #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 "filament extrude" #define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("filament extrude")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Wait for print" #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Wait for print")
#define MSG_FILAMENT_CHANGE_RESUME_2 "to resume" #define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("to resume")
#else // LCD_HEIGHT < 4 #else // LCD_HEIGHT < 4
// Up to 2 lines allowed // Up to 2 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_1 "Please wait..." #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Please wait...")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Ejecting..." #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Ejecting...")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Insert and Click" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Insert and Click")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Loading..." #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Loading...")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Extruding..." #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Extruding...")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Resuming..." #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Resuming...")
#endif // LCD_HEIGHT < 4 #endif // LCD_HEIGHT < 4
#endif // LANGUAGE_BG_H #endif // LANGUAGE_BG_H

View File

@@ -33,121 +33,228 @@
#define MAPPER_C2C3 // because of "ó" #define MAPPER_C2C3 // because of "ó"
#define DISPLAY_CHARSET_ISO10646_1 #define DISPLAY_CHARSET_ISO10646_1
#define WELCOME_MSG MACHINE_NAME " preparada." #define WELCOME_MSG MACHINE_NAME _UxGT(" preparada.")
#define MSG_SD_INSERTED "SD detectada." #define MSG_SD_INSERTED _UxGT("Targeta detectada.")
#define MSG_SD_REMOVED "SD expulsada." #define MSG_SD_REMOVED _UxGT("Targeta extreta.")
#define MSG_MAIN "Menu principal" #define MSG_LCD_ENDSTOPS _UxGT("Endstops")
#define MSG_AUTOSTART "Inici automatic" #define MSG_MAIN _UxGT("Menú principal")
#define MSG_DISABLE_STEPPERS "Apagar motors" #define MSG_AUTOSTART _UxGT("Inici automatic")
#define MSG_AUTO_HOME "Home global" #define MSG_DISABLE_STEPPERS _UxGT("Desactiva motors")
#define MSG_LEVEL_BED_HOMING "Homing XYZ" #define MSG_DEBUG_MENU _UxGT("Menu de depuracio")
#define MSG_LEVEL_BED_WAITING "Click to Begin" #define MSG_PROGRESS_BAR_TEST _UxGT("Test barra progres")
#define MSG_LEVEL_BED_DONE "Leveling Done!" #define MSG_AUTO_HOME _UxGT("Ves a l'origen")
#define MSG_LEVEL_BED_CANCEL "Cancel" #define MSG_AUTO_HOME_X _UxGT("X a origen")
#define MSG_SET_HOME_OFFSETS "Set home offsets" #define MSG_AUTO_HOME_Y _UxGT("Y a origen")
#define MSG_HOME_OFFSETS_APPLIED "Offsets applied" #define MSG_AUTO_HOME_Z _UxGT("Z a origen")
#define MSG_SET_ORIGIN "Establir origen" #define MSG_LEVEL_BED_HOMING _UxGT("Origen XYZ")
#define MSG_PREHEAT_1 "Preescalfar PLA" #define MSG_LEVEL_BED_WAITING _UxGT("Premeu per iniciar")
#define MSG_PREHEAT_1_N "Preescalfar PLA " #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Següent punt")
#define MSG_PREHEAT_1_ALL "Preesc. tot PLA" #define MSG_LEVEL_BED_DONE _UxGT("Anivellament fet!")
#define MSG_PREHEAT_1_BEDONLY "Preesc. llit PLA" #define MSG_LEVEL_BED_CANCEL _UxGT("Cancel.la")
#define MSG_PREHEAT_1_SETTINGS "Configuració PLA" #define MSG_SET_HOME_OFFSETS _UxGT("Ajusta decalatge")
#define MSG_PREHEAT_2 "Preescalfar ABS" #define MSG_HOME_OFFSETS_APPLIED _UxGT("Decalatge aplicat")
#define MSG_PREHEAT_2_N "Preescalfar ABS " #define MSG_SET_ORIGIN _UxGT("Estableix origen")
#define MSG_PREHEAT_2_ALL "Preesc. tot ABS" #define MSG_PREHEAT_1 _UxGT("Preescalfa PLA")
#define MSG_PREHEAT_2_BEDONLY "Preesc. llit ABS" #define MSG_PREHEAT_1_N MSG_PREHEAT_1 _UxGT(" ")
#define MSG_PREHEAT_2_SETTINGS "Configuració ABS" #define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 _UxGT(" Tot")
#define MSG_COOLDOWN "Refredar" #define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 _UxGT(" Llit")
#define MSG_SWITCH_PS_ON "Switch power on" #define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 _UxGT(" Conf.")
#define MSG_SWITCH_PS_OFF "Switch power off" #define MSG_PREHEAT_2 _UxGT("Preescalfa ABS")
#define MSG_EXTRUDE "Extruir" #define MSG_PREHEAT_2_N MSG_PREHEAT_2 _UxGT(" ")
#define MSG_RETRACT "Refredar" #define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 _UxGT(" Tot")
#define MSG_MOVE_AXIS "Moure eixos" #define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 _UxGT(" Llit")
#define MSG_MOVE_X "Moure X" #define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 _UxGT(" Conf.")
#define MSG_MOVE_Y "Moure Y" #define MSG_COOLDOWN _UxGT("Refreda")
#define MSG_MOVE_Z "Moure Z" #define MSG_SWITCH_PS_ON _UxGT("Switch power on")
#define MSG_MOVE_E "Extrusor" #define MSG_SWITCH_PS_OFF _UxGT("Switch power off")
#define MSG_MOVE_01MM "Moure 0.1mm" #define MSG_EXTRUDE _UxGT("Extrudeix")
#define MSG_MOVE_1MM "Moure 1mm" #define MSG_RETRACT _UxGT("Retreu")
#define MSG_MOVE_10MM "Moure 10mm" #define MSG_MOVE_AXIS _UxGT("Mou eixos")
#define MSG_SPEED "Velocitat" #define MSG_LEVEL_BED _UxGT("Anivella llit")
#define MSG_NOZZLE "Nozzle" #define MSG_MOVING _UxGT("Movent..")
#define MSG_BED "Llit" #define MSG_FREE_XY _UxGT("XY lliures")
#define MSG_FAN_SPEED "Vel. Ventilador" #define MSG_MOVE_X _UxGT("Mou X")
#define MSG_FLOW "Fluxe" #define MSG_MOVE_Y _UxGT("Mou Y")
#define MSG_CONTROL "Control" #define MSG_MOVE_Z _UxGT("Mou Z")
#define MSG_MIN LCD_STR_THERMOMETER " Min" #define MSG_MOVE_E _UxGT("Extrusor")
#define MSG_MAX LCD_STR_THERMOMETER " Max" #define MSG_MOVE_01MM _UxGT("Mou 0.1mm")
#define MSG_FACTOR LCD_STR_THERMOMETER " Fact" #define MSG_MOVE_1MM _UxGT("Mou 1mm")
#define MSG_AUTOTEMP "Autotemp" #define MSG_MOVE_10MM _UxGT("Mou 10mm")
#define MSG_ON "On " #define MSG_SPEED _UxGT("Velocitat")
#define MSG_OFF "Off" #define MSG_BED_Z _UxGT("Llit Z")
#define MSG_PID_P "PID-P" #define MSG_NOZZLE _UxGT("Nozzle")
#define MSG_PID_I "PID-I" #define MSG_BED _UxGT("Llit")
#define MSG_PID_D "PID-D" #define MSG_FAN_SPEED _UxGT("Vel. Ventilador")
#define MSG_PID_C "PID-C" #define MSG_FLOW _UxGT("Flux")
#define MSG_ACC "Accel" #define MSG_CONTROL _UxGT("Control")
#define MSG_VX_JERK "Vx-jerk" #define MSG_MIN LCD_STR_THERMOMETER _UxGT(" Min")
#define MSG_VY_JERK "Vy-jerk" #define MSG_MAX LCD_STR_THERMOMETER _UxGT(" Max")
#define MSG_VZ_JERK "Vz-jerk" #define MSG_FACTOR LCD_STR_THERMOMETER _UxGT(" Fact")
#define MSG_VE_JERK "Ve-jerk" #define MSG_AUTOTEMP _UxGT("Autotemp")
#define MSG_VMAX "Vmax " #define MSG_ON _UxGT("On ")
#define MSG_VMIN "Vmin" #define MSG_OFF _UxGT("Off")
#define MSG_VTRAV_MIN "VTrav min" #define MSG_PID_P _UxGT("PID-P")
#define MSG_AMAX "Amax " #define MSG_PID_I _UxGT("PID-I")
#define MSG_A_RETRACT "A-retract" #define MSG_PID_D _UxGT("PID-D")
#define MSG_XSTEPS "Xpassos/mm" #define MSG_PID_C _UxGT("PID-C")
#define MSG_YSTEPS "Ypassos/mm" #define MSG_SELECT _UxGT("Select")
#define MSG_ZSTEPS "Zpassos/mm" #define MSG_ACC _UxGT("Accel")
#define MSG_ESTEPS "Epassos/mm" #define MSG_VX_JERK _UxGT("Vx-jerk")
#define MSG_TEMPERATURE "Temperatura" #define MSG_VY_JERK _UxGT("Vy-jerk")
#define MSG_MOTION "Moviment" #define MSG_VZ_JERK _UxGT("Vz-jerk")
#define MSG_VOLUMETRIC "Filament" #define MSG_VE_JERK _UxGT("Ve-jerk")
#define MSG_VOLUMETRIC_ENABLED "E in mm3" #define MSG_VMAX _UxGT("Vmax ")
#define MSG_FILAMENT_DIAM "Fil. Dia." #define MSG_VMIN _UxGT("Vmin")
#define MSG_CONTRAST "Contrast de LCD" #define MSG_VTRAV_MIN _UxGT("VViatge min")
#define MSG_STORE_EPROM "Desar a memoria" #define MSG_AMAX _UxGT("Accel. max ")
#define MSG_LOAD_EPROM "Carregar de mem." #define MSG_A_RETRACT _UxGT("Accel. retracc")
#define MSG_RESTORE_FAILSAFE "Rest. emergencia" #define MSG_A_TRAVEL _UxGT("Accel. Viatge")
#define MSG_REFRESH "Refrescar" #define MSG_XSTEPS _UxGT("Xpassos/mm")
#define MSG_WATCH "Pantalla Info." #define MSG_YSTEPS _UxGT("Ypassos/mm")
#define MSG_PREPARE "Preparar" #define MSG_ZSTEPS _UxGT("Zpassos/mm")
#define MSG_TUNE "Calibrar" #define MSG_ESTEPS _UxGT("Epassos/mm")
#define MSG_PAUSE_PRINT "Pausa imp." #define MSG_E1STEPS _UxGT("E1passos/mm")
#define MSG_RESUME_PRINT "Reprendre imp." #define MSG_E2STEPS _UxGT("E2passos/mm")
#define MSG_STOP_PRINT "Parar inp." #define MSG_E3STEPS _UxGT("E3passos/mm")
#define MSG_CARD_MENU "Imprimir de SD" #define MSG_E4STEPS _UxGT("E4passos/mm")
#define MSG_NO_CARD "-Sense targeta SD" #define MSG_E5STEPS _UxGT("E5passos/mm")
#define MSG_DWELL "Repos..." #define MSG_TEMPERATURE _UxGT("Temperatura")
#define MSG_USERWAIT "Esperant usuari.." #define MSG_MOTION _UxGT("Moviment")
#define MSG_RESUMING "Reprenent imp." #define MSG_FILAMENT _UxGT("Filament")
#define MSG_PRINT_ABORTED "Print aborted" #define MSG_VOLUMETRIC_ENABLED _UxGT("E en mm3")
#define MSG_NO_MOVE "Sense moviment." #define MSG_FILAMENT_DIAM _UxGT("Diam. Fil.")
#define MSG_KILLED "PARADA DE EMERG. " #define MSG_CONTRAST _UxGT("Contrast de LCD")
#define MSG_STOPPED "ATURAT. " #define MSG_STORE_EEPROM _UxGT("Desa memoria")
#define MSG_CONTROL_RETRACT "Retreure mm" #define MSG_LOAD_EEPROM _UxGT("Carrega memoria")
#define MSG_CONTROL_RETRACT_SWAP "Swap Retreure mm" #define MSG_RESTORE_FAILSAFE _UxGT("Restaura valors")
#define MSG_CONTROL_RETRACTF "Retreure F" #define MSG_REFRESH _UxGT("Actualitza")
#define MSG_CONTROL_RETRACT_ZLIFT "Aixecar mm" #define MSG_WATCH _UxGT("Pantalla Info.")
#define MSG_CONTROL_RETRACT_RECOVER "DesRet +mm" #define MSG_PREPARE _UxGT("Prepara")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "Swap DesRet +mm" #define MSG_TUNE _UxGT("Ajusta")
#define MSG_CONTROL_RETRACT_RECOVERF "DesRet F" #define MSG_PAUSE_PRINT _UxGT("Pausa impressio")
#define MSG_AUTORETRACT "AutoRetr." #define MSG_RESUME_PRINT _UxGT("Repren impressio")
#define MSG_FILAMENTCHANGE "Canviar filament" #define MSG_STOP_PRINT _UxGT("Atura impressio.")
#define MSG_INIT_SDCARD "Iniciant SD" #define MSG_CARD_MENU _UxGT("Imprimeix de SD")
#define MSG_CNG_SDCARD "Canviar SD" #define MSG_NO_CARD _UxGT("No hi ha targeta")
#define MSG_ZPROBE_OUT "Z probe out. bed" #define MSG_DWELL _UxGT("En repos...")
#define MSG_HOME "Home" // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST #define MSG_USERWAIT _UxGT("Esperant usuari..")
#define MSG_FIRST "first" #define MSG_RESUMING _UxGT("Reprenent imp.")
#define MSG_ZPROBE_ZOFFSET "Z Offset" #define MSG_PRINT_ABORTED _UxGT("Imp. cancelada")
#define MSG_BABYSTEP_X "Babystep X" #define MSG_NO_MOVE _UxGT("Sense moviment.")
#define MSG_BABYSTEP_Y "Babystep Y" #define MSG_KILLED _UxGT("MATAT.")
#define MSG_BABYSTEP_Z "Babystep Z" #define MSG_STOPPED _UxGT("ATURADA.")
#define MSG_ENDSTOP_ABORT "Endstop abort" #define MSG_CONTROL_RETRACT _UxGT("Retreu mm")
#define MSG_DELTA_CALIBRATE "Delta Calibration" #define MSG_CONTROL_RETRACT_SWAP _UxGT("Swap Retreure mm")
#define MSG_DELTA_CALIBRATE_X "Calibrate X" #define MSG_CONTROL_RETRACTF _UxGT("Retreu V")
#define MSG_DELTA_CALIBRATE_Y "Calibrate Y" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Aixeca mm")
#define MSG_DELTA_CALIBRATE_Z "Calibrate Z" #define MSG_CONTROL_RETRACT_RECOVER _UxGT("DesRet +mm")
#define MSG_DELTA_CALIBRATE_CENTER "Calibrate Center" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("Swap DesRet +mm")
#define MSG_CONTROL_RETRACT_RECOVERF _UxGT("DesRet V")
#define MSG_AUTORETRACT _UxGT("Auto retraccio")
#define MSG_FILAMENTCHANGE _UxGT("Canvia filament")
#define MSG_INIT_SDCARD _UxGT("Inicialitza SD")
#define MSG_CNG_SDCARD _UxGT("Canvia SD")
#define MSG_ZPROBE_OUT _UxGT("Sonda Z fora")
#define MSG_BLTOUCH_RESET _UxGT("Reinicia BLTouch")
#define MSG_HOME _UxGT("Home") // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#define MSG_FIRST _UxGT("primer")
#define MSG_ZPROBE_ZOFFSET _UxGT("Decalatge Z")
#define MSG_BABYSTEP_X _UxGT("Micropas X")
#define MSG_BABYSTEP_Y _UxGT("Micropas Y")
#define MSG_BABYSTEP_Z _UxGT("Micropas Z")
#define MSG_ENDSTOP_ABORT _UxGT("Cancel. Endstop")
#define MSG_HEATING_FAILED_LCD _UxGT("Error al escalfar")
#define MSG_ERR_REDUNDANT_TEMP _UxGT("Err: TEMP REDUNDANT")
#define MSG_THERMAL_RUNAWAY _UxGT("THERMAL RUNAWAY")
#define MSG_ERR_MAXTEMP _UxGT("Err: TEMP MAXIMA")
#define MSG_ERR_MINTEMP _UxGT("Err: TEMP MINIMA")
#define MSG_ERR_MAXTEMP_BED _UxGT("Err: TEMPMAX LLIT")
#define MSG_ERR_MINTEMP_BED _UxGT("Err: TEMPMIN LLIT")
#define MSG_ERR_Z_HOMING _UxGT("G28 Z No permes")
#define MSG_HALTED _UxGT("IMPRESSORA PARADA")
#define MSG_PLEASE_RESET _UxGT("Reinicieu")
#define MSG_SHORT_DAY _UxGT("d") // One character only
#define MSG_SHORT_HOUR _UxGT("h") // One character only
#define MSG_SHORT_MINUTE _UxGT("m") // One character only
#define MSG_HEATING _UxGT("Escalfant...")
#define MSG_HEATING_COMPLETE _UxGT("Escalfament fet.")
#define MSG_BED_HEATING _UxGT("Escalfant llit")
#define MSG_BED_DONE _UxGT("Llit fet.")
#define MSG_DELTA_CALIBRATE _UxGT("Calibratge Delta")
#define MSG_DELTA_CALIBRATE_X _UxGT("Calibra X")
#define MSG_DELTA_CALIBRATE_Y _UxGT("Calibra Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Calibra Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Calibra el centre")
#define MSG_INFO_MENU _UxGT("Quant a la impr.")
#define MSG_INFO_PRINTER_MENU _UxGT("Info Impressora")
#define MSG_INFO_STATS_MENU _UxGT("Estadistiques")
#define MSG_INFO_BOARD_MENU _UxGT("Info placa")
#define MSG_INFO_THERMISTOR_MENU _UxGT("Termistors")
#define MSG_INFO_EXTRUDERS _UxGT("Extrusors")
#define MSG_INFO_BAUDRATE _UxGT("Baud")
#define MSG_INFO_PROTOCOL _UxGT("Protocol")
#define MSG_LIGHTS_ON _UxGT("Encen el llum")
#define MSG_LIGHTS_OFF _UxGT("Apaga el llum")
#if LCD_WIDTH >= 20
#define MSG_INFO_PRINT_COUNT _UxGT("Total impressions")
#define MSG_INFO_COMPLETED_PRINTS _UxGT("Acabades")
#define MSG_INFO_PRINT_TIME _UxGT("Temps imprimint")
#define MSG_INFO_PRINT_LONGEST _UxGT("Treball mes llarg")
#define MSG_INFO_PRINT_FILAMENT _UxGT("Total extrudit")
#else
#define MSG_INFO_PRINT_COUNT _UxGT("Impressions")
#define MSG_INFO_COMPLETED_PRINTS _UxGT("Acabades")
#define MSG_INFO_PRINT_TIME _UxGT("Total")
#define MSG_INFO_PRINT_LONGEST _UxGT("Mes llarg")
#define MSG_INFO_PRINT_FILAMENT _UxGT("Extrudit")
#endif
#define MSG_INFO_MIN_TEMP _UxGT("Temp. mínima")
#define MSG_INFO_MAX_TEMP _UxGT("Temp. màxima")
#define MSG_INFO_PSU _UxGT("Font alimentacio")
#define MSG_DRIVE_STRENGTH _UxGT("Força motor")
#define MSG_DAC_PERCENT _UxGT("Driver %")
#define MSG_DAC_EEPROM_WRITE _UxGT("DAC EEPROM Write")
#define MSG_FILAMENT_CHANGE_HEADER _UxGT("CANVI DE FILAMENT")
#define MSG_FILAMENT_CHANGE_OPTION_HEADER _UxGT("OPCIONS CANVI:")
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Extrudeix mes")
#define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Repren impressió")
#define MSG_FILAMENT_CHANGE_MINTEMP _UxGT("Temp minima es ")
//
// Filament Change screens show up to 3 lines on a 4-line display
// ...or up to 2 lines on a 3-line display
//
#if LCD_HEIGHT >= 4
#define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Esperant per")
#define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("iniciar el canvi")
#define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("de filament")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Esperant per")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("treure filament")
#define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Poseu filament")
#define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("i premeu el boto")
#define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("per continuar...")
#define MSG_FILAMENT_CHANGE_HEAT_1 _UxGT("Premeu boto per")
#define MSG_FILAMENT_CHANGE_HEAT_2 _UxGT("escalfar nozzle.")
#define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Escalfant nozzle")
#define MSG_FILAMENT_CHANGE_HEATING_2 _UxGT("Espereu...")
#define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Esperant carrega")
#define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("de filament")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Esperant per")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("extreure filament")
#define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Esperant per")
#define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("reprendre")
#else // LCD_HEIGHT < 4
#define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Espereu...")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Expulsant...")
#define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Insereix i prem")
#define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Escalfant...")
#define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Carregant...")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Extrudint...")
#define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Reprenent...")
#endif // LCD_HEIGHT < 4
#endif // LANGUAGE_CA_H #endif // LANGUAGE_CA_H

View File

@@ -101,14 +101,19 @@
#define MSG_YSTEPS "Ysteps/mm" #define MSG_YSTEPS "Ysteps/mm"
#define MSG_ZSTEPS "Zsteps/mm" #define MSG_ZSTEPS "Zsteps/mm"
#define MSG_ESTEPS "Esteps/mm" #define MSG_ESTEPS "Esteps/mm"
#define MSG_E1STEPS "E1steps/mm"
#define MSG_E2STEPS "E2steps/mm"
#define MSG_E3STEPS "E3steps/mm"
#define MSG_E4STEPS "E4steps/mm"
#define MSG_E5STEPS "E5steps/mm"
#define MSG_TEMPERATURE "\xc9\xd2" #define MSG_TEMPERATURE "\xc9\xd2"
#define MSG_MOTION "\xdf\xb2" #define MSG_MOTION "\xdf\xb2"
#define MSG_VOLUMETRIC "Filament" #define MSG_FILAMENT "Filament"
#define MSG_VOLUMETRIC_ENABLED "E in mm3" #define MSG_VOLUMETRIC_ENABLED "E in mm3"
#define MSG_FILAMENT_DIAM "Fil. Dia." #define MSG_FILAMENT_DIAM "Fil. Dia."
#define MSG_CONTRAST "LCD contrast" #define MSG_CONTRAST "LCD contrast"
#define MSG_STORE_EPROM "Store memory" #define MSG_STORE_EEPROM "Store memory"
#define MSG_LOAD_EPROM "Load memory" #define MSG_LOAD_EEPROM "Load memory"
#define MSG_RESTORE_FAILSAFE "Restore failsafe" #define MSG_RESTORE_FAILSAFE "Restore failsafe"
#define MSG_REFRESH "Refresh" #define MSG_REFRESH "Refresh"
#define MSG_WATCH "\xec\xed\xee\xef" #define MSG_WATCH "\xec\xed\xee\xef"
@@ -130,8 +135,8 @@
#define MSG_CONTROL_RETRACT_SWAP "Swap Re.mm" #define MSG_CONTROL_RETRACT_SWAP "Swap Re.mm"
#define MSG_CONTROL_RETRACTF "Retract V" #define MSG_CONTROL_RETRACTF "Retract V"
#define MSG_CONTROL_RETRACT_ZLIFT "Hop mm" #define MSG_CONTROL_RETRACT_ZLIFT "Hop mm"
#define MSG_CONTROL_RETRACT_RECOVER "UnRet +mm" #define MSG_CONTROL_RETRACT_RECOVER "UnRet mm"
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "S UnRet+mm" #define MSG_CONTROL_RETRACT_RECOVER_SWAP "S UnRet mm"
#define MSG_CONTROL_RETRACT_RECOVERF "UnRet V" #define MSG_CONTROL_RETRACT_RECOVERF "UnRet V"
#define MSG_AUTORETRACT "AutoRetr." #define MSG_AUTORETRACT "AutoRetr."
#define MSG_FILAMENTCHANGE "Change filament" #define MSG_FILAMENTCHANGE "Change filament"

View File

@@ -36,213 +36,235 @@
#define DISPLAY_CHARSET_ISO10646_1 #define DISPLAY_CHARSET_ISO10646_1
#define WELCOME_MSG MACHINE_NAME " pripraven." #define WELCOME_MSG MACHINE_NAME _UxGT(" pripraven.")
#define MSG_SD_INSERTED "Karta vlozena" #define MSG_BACK _UxGT("Zpet")
#define MSG_SD_REMOVED "Karta vyjmuta" #define MSG_SD_INSERTED _UxGT("Karta vlozena")
#define MSG_LCD_ENDSTOPS "Endstopy" // maximalne 8 znaku #define MSG_SD_REMOVED _UxGT("Karta vyjmuta")
#define MSG_MAIN "Hlavni nabidka" #define MSG_LCD_ENDSTOPS _UxGT("Endstopy") // maximalne 8 znaku
#define MSG_AUTOSTART "Autostart" #define MSG_MAIN _UxGT("Hlavni nabidka")
#define MSG_DISABLE_STEPPERS "Uvolnit motory" #define MSG_AUTOSTART _UxGT("Autostart")
#define MSG_AUTO_HOME "Domovska pozice" #define MSG_DISABLE_STEPPERS _UxGT("Uvolnit motory")
#define MSG_AUTO_HOME_X "Domu osa X" #define MSG_DEBUG_MENU _UxGT("Nabidka ladeni")
#define MSG_AUTO_HOME_Y "Domu osa Y" #define MSG_PROGRESS_BAR_TEST _UxGT("Test uk.prubehu")
#define MSG_AUTO_HOME_Z "Domu osa Z" #define MSG_AUTO_HOME _UxGT("Domovska pozice")
#define MSG_LEVEL_BED_HOMING "Mereni podlozky" #define MSG_AUTO_HOME_X _UxGT("Domu osa X")
#define MSG_LEVEL_BED_WAITING "Kliknutim spustte" #define MSG_AUTO_HOME_Y _UxGT("Domu osa Y")
#define MSG_LEVEL_BED_NEXT_POINT "Dalsi bod" #define MSG_AUTO_HOME_Z _UxGT("Domu osa Z")
#define MSG_LEVEL_BED_DONE "Mereni hotovo!" #define MSG_LEVEL_BED_HOMING _UxGT("Mereni podlozky")
#define MSG_LEVEL_BED_CANCEL "Storno" #define MSG_LEVEL_BED_WAITING _UxGT("Kliknutim spustte")
#define MSG_SET_HOME_OFFSETS "Nastavit ofsety" #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Dalsi bod")
#define MSG_HOME_OFFSETS_APPLIED "Ofsety nastaveny" #define MSG_LEVEL_BED_DONE _UxGT("Mereni hotovo!")
#define MSG_SET_ORIGIN "Nastavit pocatek" #define MSG_LEVEL_BED_CANCEL _UxGT("Storno")
#define MSG_PREHEAT_1 "Zahrat PLA" #define MSG_SET_HOME_OFFSETS _UxGT("Nastavit ofsety")
#define MSG_PREHEAT_1_N MSG_PREHEAT_1 " " #define MSG_HOME_OFFSETS_APPLIED _UxGT("Ofsety nastaveny")
#define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 " Vse" #define MSG_SET_ORIGIN _UxGT("Nastavit pocatek")
#define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 " Podloz" #define MSG_PREHEAT_1 _UxGT("Zahrat PLA")
#define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 " Nast" #define MSG_PREHEAT_1_N MSG_PREHEAT_1 _UxGT(" ")
#define MSG_PREHEAT_2 "Zahrat ABS" #define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 _UxGT(" vse")
#define MSG_PREHEAT_2_N MSG_PREHEAT_2 " " #define MSG_PREHEAT_1_END MSG_PREHEAT_1 _UxGT(" hotend")
#define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 " Vse" #define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 _UxGT(" podloz")
#define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 " Podloz" #define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 _UxGT(" nast")
#define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 " Nast" #define MSG_PREHEAT_2 _UxGT("Zahrat ABS")
#define MSG_COOLDOWN "Zchladit" #define MSG_PREHEAT_2_N MSG_PREHEAT_2 _UxGT(" ")
#define MSG_SWITCH_PS_ON "Zapnout napajeni" #define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 _UxGT(" vse")
#define MSG_SWITCH_PS_OFF "Vypnout napajeni" #define MSG_PREHEAT_2_END MSG_PREHEAT_2 _UxGT(" hotend")
#define MSG_EXTRUDE "Vytlacit (extr.)" #define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 _UxGT(" podloz")
#define MSG_RETRACT "Zatlacit (retr.)" #define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 _UxGT(" nast")
#define MSG_MOVE_AXIS "Posunout osy" #define MSG_COOLDOWN _UxGT("Zchladit")
#define MSG_LEVEL_BED "Vyrovnat podlozku" #define MSG_SWITCH_PS_ON _UxGT("Zapnout napajeni")
#define MSG_MOVE_X "Posunout X" #define MSG_SWITCH_PS_OFF _UxGT("Vypnout napajeni")
#define MSG_MOVE_Y "Posunout Y" #define MSG_EXTRUDE _UxGT("Vytlacit (extr.)")
#define MSG_MOVE_Z "Posunout Z" #define MSG_RETRACT _UxGT("Zatlacit (retr.)")
#define MSG_MOVE_E "Extruder" #define MSG_MOVE_AXIS _UxGT("Posunout osy")
#define MSG_MOVE_01MM "Posunout o 0,1mm" #define MSG_LEVEL_BED _UxGT("Vyrovnat podlozku")
#define MSG_MOVE_1MM "Posunout o 1mm" #define MSG_MOVING _UxGT("Posunování...")
#define MSG_MOVE_10MM "Posunout o 10mm" #define MSG_FREE_XY _UxGT("Uvolnit XY")
#define MSG_SPEED "Rychlost" #define MSG_MOVE_X _UxGT("Posunout X")
#define MSG_BED_Z "Vyska podl." #define MSG_MOVE_Y _UxGT("Posunout Y")
#define MSG_NOZZLE "Tryska" #define MSG_MOVE_Z _UxGT("Posunout Z")
#define MSG_BED "Podlozka" #define MSG_MOVE_E _UxGT("Extruder")
#define MSG_FAN_SPEED "Rychlost vent." #define MSG_MOVE_01MM _UxGT("Posunout o 0,1mm")
#define MSG_FLOW "Prutok" #define MSG_MOVE_1MM _UxGT("Posunout o 1mm")
#define MSG_CONTROL "Ovladani" #define MSG_MOVE_10MM _UxGT("Posunout o 10mm")
#define MSG_MIN " " LCD_STR_THERMOMETER " Min" #define MSG_SPEED _UxGT("Rychlost")
#define MSG_MAX " " LCD_STR_THERMOMETER " Max" #define MSG_BED_Z _UxGT("Vyska podl.")
#define MSG_FACTOR " " LCD_STR_THERMOMETER " Fakt" #define MSG_NOZZLE _UxGT("Tryska")
#define MSG_AUTOTEMP "Autoteplota" #define MSG_BED _UxGT("Podlozka")
#define MSG_ON "Zap" #define MSG_FAN_SPEED _UxGT("Rychlost vent.")
#define MSG_OFF "Vyp" #define MSG_FLOW _UxGT("Prutok")
#define MSG_PID_P "PID-P" #define MSG_CONTROL _UxGT("Ovladani")
#define MSG_PID_I "PID-I" #define MSG_MIN _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Min")
#define MSG_PID_D "PID-D" #define MSG_MAX _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Max")
#define MSG_PID_C "PID-C" #define MSG_FACTOR _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Fakt")
#define MSG_SELECT "Vybrat" #define MSG_AUTOTEMP _UxGT("Autoteplota")
#define MSG_ACC "Zrychl" #define MSG_ON _UxGT("Zap")
#define MSG_VX_JERK "Vx-jerk" #define MSG_OFF _UxGT("Vyp")
#define MSG_VY_JERK "Vy-jerk" #define MSG_PID_P _UxGT("PID-P")
#define MSG_VZ_JERK "Vz-jerk" #define MSG_PID_I _UxGT("PID-I")
#define MSG_VE_JERK "Ve-jerk" #define MSG_PID_D _UxGT("PID-D")
#define MSG_VMAX "Vmax " #define MSG_PID_C _UxGT("PID-C")
#define MSG_VMIN "Vmin" #define MSG_SELECT _UxGT("Vybrat")
#define MSG_VTRAV_MIN "VTrav min" #define MSG_ACC _UxGT("Zrychl")
#define MSG_AMAX "Amax " #define MSG_VX_JERK _UxGT("Vx-jerk")
#define MSG_A_RETRACT "A-retrakt" #define MSG_VY_JERK _UxGT("Vy-jerk")
#define MSG_A_TRAVEL "A-prejezd" #define MSG_VZ_JERK _UxGT("Vz-jerk")
#define MSG_XSTEPS "Xkroku/mm" #define MSG_VE_JERK _UxGT("Ve-jerk")
#define MSG_YSTEPS "Ykroku/mm" #define MSG_VMAX _UxGT("Vmax ")
#define MSG_ZSTEPS "Zkroku/mm" #define MSG_VMIN _UxGT("Vmin")
#define MSG_ESTEPS "Ekroku/mm" #define MSG_VTRAV_MIN _UxGT("VTrav min")
#define MSG_TEMPERATURE "Teplota" #define MSG_AMAX _UxGT("Amax ")
#define MSG_MOTION "Pohyb" #define MSG_A_RETRACT _UxGT("A-retrakt")
#define MSG_VOLUMETRIC "Filament" #define MSG_A_TRAVEL _UxGT("A-prejezd")
#define MSG_VOLUMETRIC_ENABLED "E na mm3" #define MSG_XSTEPS _UxGT("Xkroku/mm")
#define MSG_FILAMENT_DIAM "Fil. Prum." #define MSG_YSTEPS _UxGT("Ykroku/mm")
#define MSG_CONTRAST "Kontrast LCD" #define MSG_ZSTEPS _UxGT("Zkroku/mm")
#define MSG_STORE_EPROM "Ulozit nastaveni" #define MSG_ESTEPS _UxGT("Ekroku/mm")
#define MSG_LOAD_EPROM "Nacist nastaveni" #define MSG_E1STEPS _UxGT("E1kroku/mm")
#define MSG_RESTORE_FAILSAFE "Obnovit vychozi" #define MSG_E2STEPS _UxGT("E2kroku/mm")
#define MSG_REFRESH "Obnovit" #define MSG_E3STEPS _UxGT("E3kroku/mm")
#define MSG_WATCH "Info obrazovka" #define MSG_E4STEPS _UxGT("E4kroku/mm")
#define MSG_PREPARE "Priprava tisku" #define MSG_E5STEPS _UxGT("E5kroku/mm")
#define MSG_TUNE "Doladeni tisku" #define MSG_TEMPERATURE _UxGT("Teplota")
#define MSG_PAUSE_PRINT "Pozastavit tisk" #define MSG_MOTION _UxGT("Pohyb")
#define MSG_RESUME_PRINT "Obnovit tisk" #define MSG_FILAMENT _UxGT("Filament")
#define MSG_STOP_PRINT "Zastavit tisk" #define MSG_VOLUMETRIC_ENABLED _UxGT("E na mm3")
#define MSG_CARD_MENU "Tisknout z SD" #define MSG_FILAMENT_DIAM _UxGT("Fil. Prum.")
#define MSG_NO_CARD "Zadna SD karta" #define MSG_ADVANCE_K _UxGT("K pro posun")
#define MSG_DWELL "Uspano..." #define MSG_CONTRAST _UxGT("Kontrast LCD")
#define MSG_USERWAIT "Cekani na uziv..." #define MSG_STORE_EEPROM _UxGT("Ulozit nastaveni")
#define MSG_RESUMING "Obnovovani tisku" #define MSG_LOAD_EEPROM _UxGT("Nacist nastaveni")
#define MSG_PRINT_ABORTED "Tisk zrusen" #define MSG_RESTORE_FAILSAFE _UxGT("Obnovit vychozi")
#define MSG_NO_MOVE "Zadny pohyb." #define MSG_REFRESH _UxGT("Obnovit")
#define MSG_KILLED "PRERUSENO. " #define MSG_WATCH _UxGT("Info obrazovka")
#define MSG_STOPPED "ZASTAVENO. " #define MSG_PREPARE _UxGT("Priprava tisku")
#define MSG_CONTROL_RETRACT "Retrakt mm" #define MSG_TUNE _UxGT("Doladeni tisku")
#define MSG_CONTROL_RETRACT_SWAP "Vymena Re.mm" #define MSG_PAUSE_PRINT _UxGT("Pozastavit tisk")
#define MSG_CONTROL_RETRACTF "Retraktovat V" #define MSG_RESUME_PRINT _UxGT("Obnovit tisk")
#define MSG_CONTROL_RETRACT_ZLIFT "Zvednuti Z mm" #define MSG_STOP_PRINT _UxGT("Zastavit tisk")
#define MSG_CONTROL_RETRACT_RECOVER "UnRet +mm" #define MSG_CARD_MENU _UxGT("Tisknout z SD")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "S UnRet+mm" #define MSG_NO_CARD _UxGT("Zadna SD karta")
#define MSG_CONTROL_RETRACT_RECOVERF "UnRet V" #define MSG_DWELL _UxGT("Uspano...")
#define MSG_AUTORETRACT "AutoRetr." #define MSG_USERWAIT _UxGT("Cekani na uziv...")
#define MSG_FILAMENTCHANGE "Vymenit filament" #define MSG_RESUMING _UxGT("Obnovovani tisku")
#define MSG_INIT_SDCARD "Nacist SD kartu" #define MSG_PRINT_ABORTED _UxGT("Tisk zrusen")
#define MSG_CNG_SDCARD "Vymenit SD kartu" #define MSG_NO_MOVE _UxGT("Zadny pohyb.")
#define MSG_ZPROBE_OUT "Sonda Z mimo podl" #define MSG_KILLED _UxGT("PRERUSENO. ")
#define MSG_BLTOUCH_SELFTEST "BLTouch Self-Test" #define MSG_STOPPED _UxGT("ZASTAVENO. ")
#define MSG_BLTOUCH_RESET "BLTouch Reset" #define MSG_CONTROL_RETRACT _UxGT("Retrakt mm")
#define MSG_HOME "Domu" // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST #define MSG_CONTROL_RETRACT_SWAP _UxGT("Vymena Re.mm")
#define MSG_FIRST "prvni" #define MSG_CONTROL_RETRACTF _UxGT("Retraktovat V")
#define MSG_ZPROBE_ZOFFSET "Z ofset" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Zvednuti Z mm")
#define MSG_BABYSTEP_X "Babystep X" #define MSG_CONTROL_RETRACT_RECOVER _UxGT("UnRet mm")
#define MSG_BABYSTEP_Y "Babystep Y" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("S UnRet mm")
#define MSG_BABYSTEP_Z "Babystep Z" #define MSG_CONTROL_RETRACT_RECOVERF _UxGT("UnRet V")
#define MSG_ENDSTOP_ABORT "Endstop abort" #define MSG_AUTORETRACT _UxGT("AutoRetr.")
#define MSG_HEATING_FAILED_LCD "Chyba zahrivani" #define MSG_FILAMENTCHANGE _UxGT("Vymenit filament")
#define MSG_ERR_REDUNDANT_TEMP "REDUND. TEPLOTA" #define MSG_INIT_SDCARD _UxGT("Nacist SD kartu")
#define MSG_THERMAL_RUNAWAY "TEPLOTNI SKOK" #define MSG_CNG_SDCARD _UxGT("Vymenit SD kartu")
#define MSG_ERR_MAXTEMP "VYSOKA TEPLOTA" #define MSG_ZPROBE_OUT _UxGT("Sonda Z mimo podl")
#define MSG_ERR_MINTEMP "NIZKA TEPLOTA" #define MSG_BLTOUCH_SELFTEST _UxGT("BLTouch Self-Test")
#define MSG_ERR_MAXTEMP_BED "VYS. TEPL. PODL." #define MSG_BLTOUCH_RESET _UxGT("BLTouch Reset")
#define MSG_ERR_MINTEMP_BED "NIZ. TEPL. PODL." #define MSG_HOME _UxGT("Domu") // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#define MSG_ERR_Z_HOMING "G28 Z ZAKAZANO" #define MSG_FIRST _UxGT("prvni")
#define MSG_HALTED "TISK. ZASTAVENA" #define MSG_ZPROBE_ZOFFSET _UxGT("Z ofset")
#define MSG_PLEASE_RESET "Provedte reset" #define MSG_BABYSTEP_X _UxGT("Babystep X")
#define MSG_SHORT_DAY "d" #define MSG_BABYSTEP_Y _UxGT("Babystep Y")
#define MSG_SHORT_HOUR "h" #define MSG_BABYSTEP_Z _UxGT("Babystep Z")
#define MSG_SHORT_MINUTE "m" #define MSG_ENDSTOP_ABORT _UxGT("Endstop abort")
#define MSG_HEATING "Zahrivani..." #define MSG_HEATING_FAILED_LCD _UxGT("Chyba zahrivani")
#define MSG_HEATING_COMPLETE "Zahrati hotovo." #define MSG_ERR_REDUNDANT_TEMP _UxGT("REDUND. TEPLOTA")
#define MSG_BED_HEATING "Zahrivani podl." #define MSG_THERMAL_RUNAWAY _UxGT("TEPLOTNI SKOK")
#define MSG_BED_DONE "Podlozka hotova." #define MSG_ERR_MAXTEMP _UxGT("VYSOKA TEPLOTA")
#define MSG_DELTA_CALIBRATE "Delta Kalibrace" #define MSG_ERR_MINTEMP _UxGT("NIZKA TEPLOTA")
#define MSG_DELTA_CALIBRATE_X "Kalibrovat X" #define MSG_ERR_MAXTEMP_BED _UxGT("VYS. TEPL. PODL.")
#define MSG_DELTA_CALIBRATE_Y "Kalibrovat Y" #define MSG_ERR_MINTEMP_BED _UxGT("NIZ. TEPL. PODL.")
#define MSG_DELTA_CALIBRATE_Z "Kalibrovat Z" #define MSG_ERR_Z_HOMING _UxGT("G28 Z ZAKAZANO")
#define MSG_DELTA_CALIBRATE_CENTER "Kalibrovat Stred" #define MSG_HALTED _UxGT("TISK. ZASTAVENA")
#define MSG_INFO_MENU "O tiskarne" #define MSG_PLEASE_RESET _UxGT("Provedte reset")
#define MSG_INFO_PRINTER_MENU "Info o tiskarne" #define MSG_SHORT_DAY _UxGT("d")
#define MSG_INFO_STATS_MENU "Statistika" #define MSG_SHORT_HOUR _UxGT("h")
#define MSG_INFO_BOARD_MENU "Info o desce" #define MSG_SHORT_MINUTE _UxGT("m")
#define MSG_INFO_THERMISTOR_MENU "Termistory" #define MSG_HEATING _UxGT("Zahrivani...")
#define MSG_INFO_EXTRUDERS "Extrudery" #define MSG_HEATING_COMPLETE _UxGT("Zahrati hotovo.")
#define MSG_INFO_BAUDRATE "Rychlost" #define MSG_BED_HEATING _UxGT("Zahrivani podl.")
#define MSG_INFO_PROTOCOL "Protokol" #define MSG_BED_DONE _UxGT("Podlozka hotova.")
#define MSG_LIGHTS_ON "Osvetleni Zap" #define MSG_DELTA_CALIBRATE _UxGT("Delta Kalibrace")
#define MSG_LIGHTS_OFF "Osvetleni Vyp" #define MSG_DELTA_CALIBRATE_X _UxGT("Kalibrovat X")
#define MSG_DELTA_CALIBRATE_Y _UxGT("Kalibrovat Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Kalibrovat Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Kalibrovat Stred")
#define MSG_DELTA_AUTO_CALIBRATE _UxGT("Autokalibrace")
#define MSG_DELTA_HEIGHT_CALIBRATE _UxGT("Nast.vysku delty")
#define MSG_INFO_MENU _UxGT("O tiskarne")
#define MSG_INFO_PRINTER_MENU _UxGT("Info o tiskarne")
#define MSG_INFO_STATS_MENU _UxGT("Statistika")
#define MSG_INFO_BOARD_MENU _UxGT("Info o desce")
#define MSG_INFO_THERMISTOR_MENU _UxGT("Termistory")
#define MSG_INFO_EXTRUDERS _UxGT("Extrudery")
#define MSG_INFO_BAUDRATE _UxGT("Rychlost")
#define MSG_INFO_PROTOCOL _UxGT("Protokol")
#define MSG_LIGHTS_ON _UxGT("Osvetleni Zap")
#define MSG_LIGHTS_OFF _UxGT("Osvetleni Vyp")
#if LCD_WIDTH >= 20 #if LCD_WIDTH >= 20
#define MSG_INFO_PRINT_COUNT "Pocet tisku" #define MSG_INFO_PRINT_COUNT _UxGT("Pocet tisku")
#define MSG_INFO_COMPLETED_PRINTS "Dokonceno" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Dokonceno")
#define MSG_INFO_PRINT_TIME "Celkovy cas" #define MSG_INFO_PRINT_TIME _UxGT("Celkovy cas")
#define MSG_INFO_PRINT_LONGEST "Nejdelsi tisk" #define MSG_INFO_PRINT_LONGEST _UxGT("Nejdelsi tisk")
#define MSG_INFO_PRINT_FILAMENT "Celkem vytlaceno" #define MSG_INFO_PRINT_FILAMENT _UxGT("Celkem vytlaceno")
#else #else
#define MSG_INFO_PRINT_COUNT "Tisky" #define MSG_INFO_PRINT_COUNT _UxGT("Tisky")
#define MSG_INFO_COMPLETED_PRINTS "Hotovo" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Hotovo")
#define MSG_INFO_PRINT_TIME "Cas" #define MSG_INFO_PRINT_TIME _UxGT("Cas")
#define MSG_INFO_PRINT_LONGEST "Nejdelsi" #define MSG_INFO_PRINT_LONGEST _UxGT("Nejdelsi")
#define MSG_INFO_PRINT_FILAMENT "Vytlaceno" #define MSG_INFO_PRINT_FILAMENT _UxGT("Vytlaceno")
#endif #endif
#define MSG_INFO_MIN_TEMP "Teplota min" #define MSG_INFO_MIN_TEMP _UxGT("Teplota min")
#define MSG_INFO_MAX_TEMP "Teplota max" #define MSG_INFO_MAX_TEMP _UxGT("Teplota max")
#define MSG_INFO_PSU "Nap. zdroj" #define MSG_INFO_PSU _UxGT("Nap. zdroj")
#define MSG_DRIVE_STRENGTH "Buzeni motoru" #define MSG_DRIVE_STRENGTH _UxGT("Buzeni motoru")
#define MSG_DAC_PERCENT "Motor %" #define MSG_DAC_PERCENT _UxGT("Motor %")
#define MSG_DAC_EEPROM_WRITE "Ulozit do EEPROM" #define MSG_DAC_EEPROM_WRITE _UxGT("Ulozit do EEPROM")
#define MSG_FILAMENT_CHANGE_HEADER "VYMENA FILAMENTU" #define MSG_FILAMENT_CHANGE_HEADER _UxGT("VYMENA FILAMENTU")
#define MSG_FILAMENT_CHANGE_OPTION_HEADER "CO DAL?" #define MSG_FILAMENT_CHANGE_OPTION_HEADER _UxGT("CO DAL?")
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE "Jeste vytlacit" #define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Jeste vytlacit")
#define MSG_FILAMENT_CHANGE_OPTION_RESUME "Obnovit tisk" #define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Obnovit tisk")
#define MSG_FILAMENT_CHANGE_MINTEMP _UxGT("Min. teplota je ")
#define MSG_FILAMENT_CHANGE_NOZZLE _UxGT(" Tryska: ")
#if LCD_HEIGHT >= 4 #if LCD_HEIGHT >= 4
// Up to 3 lines allowed // Up to 3 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_1 "Cekejte prosim" #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Cekejte prosim")
#define MSG_FILAMENT_CHANGE_INIT_2 "na zahajeni" #define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("na zahajeni")
#define MSG_FILAMENT_CHANGE_INIT_3 "vymeny filamentu" #define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("vymeny filamentu")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Cekejte prosim" #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Cekejte prosim")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 "na vysunuti" #define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("na vysunuti")
#define MSG_FILAMENT_CHANGE_UNLOAD_3 "filamentu" #define MSG_FILAMENT_CHANGE_UNLOAD_3 _UxGT("filamentu")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Vlozte filament" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Vlozte filament")
#define MSG_FILAMENT_CHANGE_INSERT_2 "a stisknete" #define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("a stisknete")
#define MSG_FILAMENT_CHANGE_INSERT_3 "tlacitko..." #define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("tlacitko...")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Cekejte prosim" #define MSG_FILAMENT_CHANGE_HEAT_1 _UxGT("Kliknete pro")
#define MSG_FILAMENT_CHANGE_LOAD_2 "na zavedeni" #define MSG_FILAMENT_CHANGE_HEAT_2 _UxGT("nahrati trysky")
#define MSG_FILAMENT_CHANGE_LOAD_3 "filamentu" #define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Cekejte prosim")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Cekejte prosim" #define MSG_FILAMENT_CHANGE_HEATING_2 _UxGT("na nahrati tr.")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 "na vytlaceni" #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Cekejte prosim")
#define MSG_FILAMENT_CHANGE_EXTRUDE_3 "filamentu" #define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("na zavedeni")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Cekejte prosim" #define MSG_FILAMENT_CHANGE_LOAD_3 _UxGT("filamentu")
#define MSG_FILAMENT_CHANGE_RESUME_2 "na pokracovani" #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Cekejte prosim")
#define MSG_FILAMENT_CHANGE_RESUME_3 "tisku" #define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("na vytlaceni")
#define MSG_FILAMENT_CHANGE_EXTRUDE_3 _UxGT("filamentu")
#define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Cekejte prosim")
#define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("na pokracovani")
#define MSG_FILAMENT_CHANGE_RESUME_3 _UxGT("tisku")
#else // LCD_HEIGHT < 4 #else // LCD_HEIGHT < 4
// Up to 2 lines allowed // Up to 2 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_1 "Cekejte..." #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Cekejte...")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Vysouvani..." #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Vysouvani...")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Vlozte, kliknete" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Vlozte, kliknete")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Zavadeni..." #define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Nahrivani...")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Vytlacovani..." #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Zavadeni...")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Pokracovani..." #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Vytlacovani...")
#define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Pokracovani...")
#endif // LCD_HEIGHT < 4 #endif // LCD_HEIGHT < 4
#endif // LANGUAGE_CZ_H #endif // LANGUAGE_CZ_H

View File

@@ -33,210 +33,215 @@
#define MAPPER_C2C3 #define MAPPER_C2C3
#define DISPLAY_CHARSET_ISO10646_1 #define DISPLAY_CHARSET_ISO10646_1
#define WELCOME_MSG MACHINE_NAME " er klar" #define WELCOME_MSG MACHINE_NAME _UxGT(" er klar")
#define MSG_SD_INSERTED "Kort isat" #define MSG_SD_INSERTED _UxGT("Kort isat")
#define MSG_SD_REMOVED "Kort fjernet" #define MSG_SD_REMOVED _UxGT("Kort fjernet")
#define MSG_LCD_ENDSTOPS "Endstops" // Max length 8 characters #define MSG_LCD_ENDSTOPS _UxGT("Endstops") // Max length 8 characters
#define MSG_MAIN "Menu" #define MSG_MAIN _UxGT("Menu")
#define MSG_AUTOSTART "Autostart" #define MSG_AUTOSTART _UxGT("Autostart")
#define MSG_DISABLE_STEPPERS "Slå alle steppere fra" #define MSG_DISABLE_STEPPERS _UxGT("Slå alle steppere fra")
#define MSG_AUTO_HOME "Auto Home" // G28 #define MSG_AUTO_HOME _UxGT("Auto Home") // G28
#define MSG_AUTO_HOME_X "Home X" #define MSG_AUTO_HOME_X _UxGT("Home X")
#define MSG_AUTO_HOME_Y "Home Y" #define MSG_AUTO_HOME_Y _UxGT("Home Y")
#define MSG_AUTO_HOME_Z "Home Z" #define MSG_AUTO_HOME_Z _UxGT("Home Z")
#define MSG_LEVEL_BED_HOMING "Homing XYZ" #define MSG_LEVEL_BED_HOMING _UxGT("Homing XYZ")
#define MSG_LEVEL_BED_WAITING "Klik når du er klar" #define MSG_LEVEL_BED_WAITING _UxGT("Klik når du er klar")
#define MSG_LEVEL_BED_NEXT_POINT "Næste punkt" #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Næste punkt")
#define MSG_LEVEL_BED_DONE "Bed level er færdig!" #define MSG_LEVEL_BED_DONE _UxGT("Bed level er færdig!")
#define MSG_LEVEL_BED_CANCEL "Annuller bed level" #define MSG_LEVEL_BED_CANCEL _UxGT("Annuller bed level")
#define MSG_SET_HOME_OFFSETS "Sæt forsk. af home" #define MSG_SET_HOME_OFFSETS _UxGT("Sæt forsk. af home")
#define MSG_HOME_OFFSETS_APPLIED "Forsk. er nu aktiv" #define MSG_HOME_OFFSETS_APPLIED _UxGT("Forsk. er nu aktiv")
#define MSG_SET_ORIGIN "Sæt origin" #define MSG_SET_ORIGIN _UxGT("Sæt origin")
#define MSG_PREHEAT_1 "Forvarm PLA" #define MSG_PREHEAT_1 _UxGT("Forvarm PLA")
#define MSG_PREHEAT_1_N "Forvarm PLA " #define MSG_PREHEAT_1_N _UxGT("Forvarm PLA ")
#define MSG_PREHEAT_1_ALL "Forvarm PLA Alle" #define MSG_PREHEAT_1_ALL _UxGT("Forvarm PLA Alle")
#define MSG_PREHEAT_1_BEDONLY "Forvarm PLA Bed" #define MSG_PREHEAT_1_BEDONLY _UxGT("Forvarm PLA Bed")
#define MSG_PREHEAT_1_SETTINGS "Forvarm PLA conf" #define MSG_PREHEAT_1_SETTINGS _UxGT("Forvarm PLA conf")
#define MSG_PREHEAT_2 "Forvarm ABS" #define MSG_PREHEAT_2 _UxGT("Forvarm ABS")
#define MSG_PREHEAT_2_N "Forvarm ABS " #define MSG_PREHEAT_2_N _UxGT("Forvarm ABS ")
#define MSG_PREHEAT_2_ALL "Forvarm ABS Alle" #define MSG_PREHEAT_2_ALL _UxGT("Forvarm ABS Alle")
#define MSG_PREHEAT_2_BEDONLY "Forvarm ABS Bed" #define MSG_PREHEAT_2_BEDONLY _UxGT("Forvarm ABS Bed")
#define MSG_PREHEAT_2_SETTINGS "Forvarm ABS conf" #define MSG_PREHEAT_2_SETTINGS _UxGT("Forvarm ABS conf")
#define MSG_COOLDOWN "Afkøl" #define MSG_COOLDOWN _UxGT("Afkøl")
#define MSG_SWITCH_PS_ON "Slå strøm til" #define MSG_SWITCH_PS_ON _UxGT("Slå strøm til")
#define MSG_SWITCH_PS_OFF "Slå strøm fra" #define MSG_SWITCH_PS_OFF _UxGT("Slå strøm fra")
#define MSG_EXTRUDE "Extruder" #define MSG_EXTRUDE _UxGT("Extruder")
#define MSG_RETRACT "Retract" #define MSG_RETRACT _UxGT("Retract")
#define MSG_MOVE_AXIS "Flyt akser" #define MSG_MOVE_AXIS _UxGT("Flyt akser")
#define MSG_LEVEL_BED "Juster bed" #define MSG_LEVEL_BED _UxGT("Juster bed")
#define MSG_MOVE_X "Flyt X" #define MSG_MOVE_X _UxGT("Flyt X")
#define MSG_MOVE_Y "Flyt Y" #define MSG_MOVE_Y _UxGT("Flyt Y")
#define MSG_MOVE_Z "Flyt Z" #define MSG_MOVE_Z _UxGT("Flyt Z")
#define MSG_MOVE_E "Extruder" #define MSG_MOVE_E _UxGT("Extruder")
#define MSG_MOVE_01MM "Flyt 0.1mm" #define MSG_MOVE_01MM _UxGT("Flyt 0.1mm")
#define MSG_MOVE_1MM "Flyt 1mm" #define MSG_MOVE_1MM _UxGT("Flyt 1mm")
#define MSG_MOVE_10MM "Flyt 10mm" #define MSG_MOVE_10MM _UxGT("Flyt 10mm")
#define MSG_SPEED "Hastighed" #define MSG_SPEED _UxGT("Hastighed")
#define MSG_BED_Z "Plade Z" #define MSG_BED_Z _UxGT("Plade Z")
#define MSG_NOZZLE "Dyse" #define MSG_NOZZLE _UxGT("Dyse")
#define MSG_BED "Plade" #define MSG_BED _UxGT("Plade")
#define MSG_FAN_SPEED "Blæser hastighed" #define MSG_FAN_SPEED _UxGT("Blæser hastighed")
#define MSG_FLOW "Flow" #define MSG_FLOW _UxGT("Flow")
#define MSG_CONTROL "Kontrol" #define MSG_CONTROL _UxGT("Kontrol")
#define MSG_MIN " \002 Min" #define MSG_MIN _UxGT(" \002 Min")
#define MSG_MAX " \002 Max" #define MSG_MAX _UxGT(" \002 Max")
#define MSG_FACTOR " \002 Fact" #define MSG_FACTOR _UxGT(" \002 Fact")
#define MSG_AUTOTEMP "Autotemp" #define MSG_AUTOTEMP _UxGT("Autotemp")
#define MSG_ON "Til " #define MSG_ON _UxGT("Til ")
#define MSG_OFF "Fra" #define MSG_OFF _UxGT("Fra")
#define MSG_PID_P "PID-P" #define MSG_PID_P _UxGT("PID-P")
#define MSG_PID_I "PID-I" #define MSG_PID_I _UxGT("PID-I")
#define MSG_PID_D "PID-D" #define MSG_PID_D _UxGT("PID-D")
#define MSG_PID_C "PID-C" #define MSG_PID_C _UxGT("PID-C")
#define MSG_SELECT "Vælg" #define MSG_SELECT _UxGT("Vælg")
#define MSG_ACC "Accel" #define MSG_ACC _UxGT("Accel")
#define MSG_VX_JERK "Vx-jerk" #define MSG_VX_JERK _UxGT("Vx-jerk")
#define MSG_VY_JERK "Vy-jerk" #define MSG_VY_JERK _UxGT("Vy-jerk")
#define MSG_VZ_JERK "Vz-jerk" #define MSG_VZ_JERK _UxGT("Vz-jerk")
#define MSG_VE_JERK "Ve-jerk" #define MSG_VE_JERK _UxGT("Ve-jerk")
#define MSG_VMAX "Vmax " #define MSG_VMAX _UxGT("Vmax ")
#define MSG_VMIN "Vmin" #define MSG_VMIN _UxGT("Vmin")
#define MSG_VTRAV_MIN "VTrav min" #define MSG_VTRAV_MIN _UxGT("VTrav min")
#define MSG_AMAX "Amax " #define MSG_AMAX _UxGT("Amax ")
#define MSG_A_RETRACT "A-retract" #define MSG_A_RETRACT _UxGT("A-retract")
#define MSG_A_TRAVEL "A-rejse" #define MSG_A_TRAVEL _UxGT("A-rejse")
#define MSG_XSTEPS "Xsteps/mm" #define MSG_XSTEPS _UxGT("Xsteps/mm")
#define MSG_YSTEPS "Ysteps/mm" #define MSG_YSTEPS _UxGT("Ysteps/mm")
#define MSG_ZSTEPS "Zsteps/mm" #define MSG_ZSTEPS _UxGT("Zsteps/mm")
#define MSG_ESTEPS "Esteps/mm" #define MSG_ESTEPS _UxGT("Esteps/mm")
#define MSG_TEMPERATURE "Temperatur" #define MSG_E1STEPS _UxGT("E1steps/mm")
#define MSG_MOTION "Bevægelse" #define MSG_E2STEPS _UxGT("E2steps/mm")
#define MSG_VOLUMETRIC "Filament" #define MSG_E3STEPS _UxGT("E3steps/mm")
#define MSG_VOLUMETRIC_ENABLED "E i mm3" #define MSG_E4STEPS _UxGT("E4steps/mm")
#define MSG_FILAMENT_DIAM "Fil. Dia." #define MSG_E5STEPS _UxGT("E5steps/mm")
#define MSG_CONTRAST "LCD kontrast" #define MSG_TEMPERATURE _UxGT("Temperatur")
#define MSG_STORE_EPROM "Gem i EEPROM" #define MSG_MOTION _UxGT("Bevægelse")
#define MSG_LOAD_EPROM "Hent fra EEPROM" #define MSG_FILAMENT _UxGT("Filament")
#define MSG_RESTORE_FAILSAFE "Gendan failsafe" #define MSG_VOLUMETRIC_ENABLED _UxGT("E i mm3")
#define MSG_REFRESH "Genopfrisk" #define MSG_FILAMENT_DIAM _UxGT("Fil. Dia.")
#define MSG_WATCH "Info skærm" #define MSG_CONTRAST _UxGT("LCD kontrast")
#define MSG_PREPARE "Forbered" #define MSG_STORE_EEPROM _UxGT("Gem i EEPROM")
#define MSG_TUNE "Tune" #define MSG_LOAD_EEPROM _UxGT("Hent fra EEPROM")
#define MSG_PAUSE_PRINT "Pause printet" #define MSG_RESTORE_FAILSAFE _UxGT("Gendan failsafe")
#define MSG_RESUME_PRINT "Forsæt printet" #define MSG_REFRESH _UxGT("Genopfrisk")
#define MSG_STOP_PRINT "Stop printet" #define MSG_WATCH _UxGT("Info skærm")
#define MSG_CARD_MENU "Print fra SD" #define MSG_PREPARE _UxGT("Forbered")
#define MSG_NO_CARD "Intet SD kort" #define MSG_TUNE _UxGT("Tune")
#define MSG_DWELL "Dvale..." #define MSG_PAUSE_PRINT _UxGT("Pause printet")
#define MSG_USERWAIT "Venter på bruger..." #define MSG_RESUME_PRINT _UxGT("Forsæt printet")
#define MSG_RESUMING "Forsætter printet" #define MSG_STOP_PRINT _UxGT("Stop printet")
#define MSG_PRINT_ABORTED "Print annulleret" #define MSG_CARD_MENU _UxGT("Print fra SD")
#define MSG_NO_MOVE "Ingen bevægelse." #define MSG_NO_CARD _UxGT("Intet SD kort")
#define MSG_KILLED "DRÆBT. " #define MSG_DWELL _UxGT("Dvale...")
#define MSG_STOPPED "STOPPET. " #define MSG_USERWAIT _UxGT("Venter på bruger...")
#define MSG_CONTROL_RETRACT "Tilbagetræk mm" #define MSG_RESUMING _UxGT("Forsætter printet")
#define MSG_CONTROL_RETRACT_SWAP "Skift Re.mm" #define MSG_PRINT_ABORTED _UxGT("Print annulleret")
#define MSG_CONTROL_RETRACTF "Tilbagetræk V" #define MSG_NO_MOVE _UxGT("Ingen bevægelse.")
#define MSG_CONTROL_RETRACT_ZLIFT "Hop mm" #define MSG_KILLED _UxGT("DRÆBT. ")
#define MSG_CONTROL_RETRACT_RECOVER "UnRet +mm" #define MSG_STOPPED _UxGT("STOPPET. ")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "Skift UnRet+mm" #define MSG_CONTROL_RETRACT _UxGT("Tilbagetræk mm")
#define MSG_CONTROL_RETRACT_RECOVERF "UnRet V" #define MSG_CONTROL_RETRACT_SWAP _UxGT("Skift Re.mm")
#define MSG_AUTORETRACT "AutoRetr." #define MSG_CONTROL_RETRACTF _UxGT("Tilbagetræk V")
#define MSG_FILAMENTCHANGE "Skift filament" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Hop mm")
#define MSG_INIT_SDCARD "Init. SD card" #define MSG_CONTROL_RETRACT_RECOVER _UxGT("UnRet mm")
#define MSG_CNG_SDCARD "Skift SD kort" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("Skift UnRet mm")
#define MSG_ZPROBE_OUT "Probe udenfor plade" #define MSG_CONTROL_RETRACT_RECOVERF _UxGT("UnRet V")
#define MSG_BLTOUCH_SELFTEST "BLTouch Selv-Test" #define MSG_AUTORETRACT _UxGT("AutoRetr.")
#define MSG_BLTOUCH_RESET "Reset BLTouch" #define MSG_FILAMENTCHANGE _UxGT("Skift filament")
#define MSG_HOME "Home" // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST #define MSG_INIT_SDCARD _UxGT("Init. SD card")
#define MSG_FIRST "først" #define MSG_CNG_SDCARD _UxGT("Skift SD kort")
#define MSG_ZPROBE_ZOFFSET "Z Offset" #define MSG_ZPROBE_OUT _UxGT("Probe udenfor plade")
#define MSG_BABYSTEP_X "Babystep X" #define MSG_BLTOUCH_SELFTEST _UxGT("BLTouch Selv-Test")
#define MSG_BABYSTEP_Y "Babystep Y" #define MSG_BLTOUCH_RESET _UxGT("Reset BLTouch")
#define MSG_BABYSTEP_Z "Babystep Z" #define MSG_HOME _UxGT("Home") // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#define MSG_ENDSTOP_ABORT "Endstop abort" #define MSG_FIRST _UxGT("først")
#define MSG_HEATING_FAILED_LCD "Opvarmning fejlet" #define MSG_ZPROBE_ZOFFSET _UxGT("Z Offset")
#define MSG_ERR_REDUNDANT_TEMP "Fejl: reserve temp" #define MSG_BABYSTEP_X _UxGT("Babystep X")
#define MSG_THERMAL_RUNAWAY "Temp løber løbsk" #define MSG_BABYSTEP_Y _UxGT("Babystep Y")
#define MSG_ERR_MAXTEMP "Fejl: Maks temp" #define MSG_BABYSTEP_Z _UxGT("Babystep Z")
#define MSG_ERR_MINTEMP "Fejl: Min temp" #define MSG_ENDSTOP_ABORT _UxGT("Endstop abort")
#define MSG_ERR_MAXTEMP_BED "Fejl: Maks Plade temp" #define MSG_HEATING_FAILED_LCD _UxGT("Opvarmning fejlet")
#define MSG_ERR_MINTEMP_BED "Fejl: Min Plade temp" #define MSG_ERR_REDUNDANT_TEMP _UxGT("Fejl: reserve temp")
#define MSG_ERR_Z_HOMING "G28 Z Forbudt" #define MSG_THERMAL_RUNAWAY _UxGT("Temp løber løbsk")
#define MSG_HALTED "PRINTER STOPPET" #define MSG_ERR_MAXTEMP _UxGT("Fejl: Maks temp")
#define MSG_PLEASE_RESET "Reset Venligst" #define MSG_ERR_MINTEMP _UxGT("Fejl: Min temp")
#define MSG_SHORT_DAY "d" // Kun et bogstav #define MSG_ERR_MAXTEMP_BED _UxGT("Fejl: Maks Plade temp")
#define MSG_SHORT_HOUR "h" // Kun et bogstav #define MSG_ERR_MINTEMP_BED _UxGT("Fejl: Min Plade temp")
#define MSG_SHORT_MINUTE "m" // Kun et bogstav #define MSG_ERR_Z_HOMING _UxGT("G28 Z Forbudt")
#define MSG_HEATING "Opvarmer..." #define MSG_HALTED _UxGT("PRINTER STOPPET")
#define MSG_HEATING_COMPLETE "Opvarmet" #define MSG_PLEASE_RESET _UxGT("Reset Venligst")
#define MSG_BED_HEATING "Opvarmer plade" #define MSG_SHORT_DAY _UxGT("d") // Kun et bogstav
#define MSG_BED_DONE "Plade opvarmet" #define MSG_SHORT_HOUR _UxGT("h") // Kun et bogstav
#define MSG_DELTA_CALIBRATE "Delta Kalibrering" #define MSG_SHORT_MINUTE _UxGT("m") // Kun et bogstav
#define MSG_DELTA_CALIBRATE_X "Kalibrer X" #define MSG_HEATING _UxGT("Opvarmer...")
#define MSG_DELTA_CALIBRATE_Y "Kalibrer Y" #define MSG_HEATING_COMPLETE _UxGT("Opvarmet")
#define MSG_DELTA_CALIBRATE_Z "Kalibrer Z" #define MSG_BED_HEATING _UxGT("Opvarmer plade")
#define MSG_DELTA_CALIBRATE_CENTER "Kalibrerings Center" #define MSG_BED_DONE _UxGT("Plade opvarmet")
#define MSG_DELTA_CALIBRATE _UxGT("Delta Kalibrering")
#define MSG_DELTA_CALIBRATE_X _UxGT("Kalibrer X")
#define MSG_DELTA_CALIBRATE_Y _UxGT("Kalibrer Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Kalibrer Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Kalibrerings Center")
#define MSG_INFO_MENU "Om Printer" #define MSG_INFO_MENU _UxGT("Om Printer")
#define MSG_INFO_PRINTER_MENU "Printer Info" #define MSG_INFO_PRINTER_MENU _UxGT("Printer Info")
#define MSG_INFO_STATS_MENU "Printer Stats" #define MSG_INFO_STATS_MENU _UxGT("Printer Stats")
#define MSG_INFO_BOARD_MENU "Kort Info" #define MSG_INFO_BOARD_MENU _UxGT("Kort Info")
#define MSG_INFO_THERMISTOR_MENU "Thermistors" #define MSG_INFO_THERMISTOR_MENU _UxGT("Thermistors")
#define MSG_INFO_EXTRUDERS "Extruders" #define MSG_INFO_EXTRUDERS _UxGT("Extruders")
#define MSG_INFO_BAUDRATE "Baud" #define MSG_INFO_BAUDRATE _UxGT("Baud")
#define MSG_INFO_PROTOCOL "Protocol" #define MSG_INFO_PROTOCOL _UxGT("Protocol")
#if LCD_WIDTH >= 20 #if LCD_WIDTH >= 20
#define MSG_INFO_PRINT_COUNT "Ant. Prints" #define MSG_INFO_PRINT_COUNT _UxGT("Ant. Prints")
#define MSG_INFO_COMPLETED_PRINTS "Færdige" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Færdige")
#define MSG_INFO_PRINT_TIME "Total print tid" #define MSG_INFO_PRINT_TIME _UxGT("Total print tid")
#define MSG_INFO_PRINT_LONGEST "Længste print" #define MSG_INFO_PRINT_LONGEST _UxGT("Længste print")
#define MSG_INFO_PRINT_FILAMENT "Total Extruderet" #define MSG_INFO_PRINT_FILAMENT _UxGT("Total Extruderet")
#else #else
#define MSG_INFO_PRINT_COUNT "Prints" #define MSG_INFO_PRINT_COUNT _UxGT("Prints")
#define MSG_INFO_COMPLETED_PRINTS "Færdige" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Færdige")
#define MSG_INFO_PRINT_TIME "Total" #define MSG_INFO_PRINT_TIME _UxGT("Total")
#define MSG_INFO_PRINT_LONGEST "Længste" #define MSG_INFO_PRINT_LONGEST _UxGT("Længste")
#define MSG_INFO_PRINT_FILAMENT "Extruderet" #define MSG_INFO_PRINT_FILAMENT _UxGT("Extruderet")
#endif #endif
#define MSG_INFO_MIN_TEMP "Min Temp" #define MSG_INFO_MIN_TEMP _UxGT("Min Temp")
#define MSG_INFO_MAX_TEMP "Max Temp" #define MSG_INFO_MAX_TEMP _UxGT("Max Temp")
#define MSG_INFO_PSU "Strømfors." #define MSG_INFO_PSU _UxGT("Strømfors.")
#define MSG_DRIVE_STRENGTH "Driv Styrke" #define MSG_DRIVE_STRENGTH _UxGT("Driv Styrke")
#define MSG_DAC_PERCENT "Driv %" #define MSG_DAC_PERCENT _UxGT("Driv %")
#define MSG_DAC_EEPROM_WRITE "DAC EEPROM Skriv" #define MSG_DAC_EEPROM_WRITE _UxGT("DAC EEPROM Skriv")
#define MSG_FILAMENT_CHANGE_HEADER "SKIFT FILAMENT" #define MSG_FILAMENT_CHANGE_HEADER _UxGT("SKIFT FILAMENT")
#define MSG_FILAMENT_CHANGE_OPTION_HEADER "Skift muligheder:" #define MSG_FILAMENT_CHANGE_OPTION_HEADER _UxGT("Skift muligheder:")
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE "Extruder mere" #define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Extruder mere")
#define MSG_FILAMENT_CHANGE_OPTION_RESUME "Forsæt print" #define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Forsæt print")
#if LCD_HEIGHT >= 4 #if LCD_HEIGHT >= 4
#define MSG_FILAMENT_CHANGE_INIT_1 "Vent på start" #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Vent på start")
#define MSG_FILAMENT_CHANGE_INIT_2 "af filament" #define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("af filament")
#define MSG_FILAMENT_CHANGE_INIT_3 "skift" #define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("skift")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Vent på" #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Vent på")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 "filament udskyd." #define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("filament udskyd.")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Indsæt filament" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Indsæt filament")
#define MSG_FILAMENT_CHANGE_INSERT_2 "og tryk på knap" #define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("og tryk på knap")
#define MSG_FILAMENT_CHANGE_INSERT_3 "for at fortsætte..." #define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("for at fortsætte...")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Vent på" #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Vent på")
#define MSG_FILAMENT_CHANGE_LOAD_2 "filament indtag" #define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("filament indtag")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Vent på" #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Vent på")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 "filament extrudering" #define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("filament extrudering")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Vent på at print" #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Vent på at print")
#define MSG_FILAMENT_CHANGE_RESUME_2 "fortsætter" #define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("fortsætter")
#else // LCD_HEIGHT < 4 #else // LCD_HEIGHT < 4
#define MSG_FILAMENT_CHANGE_INIT_1 "Vent venligst..." #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Vent venligst...")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Udskyder..." #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Udskyder...")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Indsæt og klik" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Indsæt og klik")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Indtager..." #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Indtager...")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Extrudere..." #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Extrudere...")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Fortsætter..." #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Fortsætter...")
#endif // LCD_HEIGHT < 4 #endif // LCD_HEIGHT < 4
#endif // LANGUAGE_DA_H #endif // LANGUAGE_DA_H

View File

@@ -33,216 +33,240 @@
#define MAPPER_C2C3 #define MAPPER_C2C3
#define DISPLAY_CHARSET_ISO10646_1 #define DISPLAY_CHARSET_ISO10646_1
#define WELCOME_MSG MACHINE_NAME " bereit" #define THIS_LANGUAGES_SPECIAL_SYMBOLS _UxGT("ÄäÖöÜüß²³")
#define MSG_SD_INSERTED "SD-Karte erkannt"
#define MSG_SD_REMOVED "SD-Karte entfernt"
#define MSG_LCD_ENDSTOPS "Endstopp" // Max length 8 characters
#define MSG_MAIN "Hauptmenü"
#define MSG_AUTOSTART "Autostart"
#define MSG_DISABLE_STEPPERS "Motoren deaktivieren" // M84
#define MSG_AUTO_HOME "Home" // G28
#define MSG_AUTO_HOME_X "Home X"
#define MSG_AUTO_HOME_Y "Home Y"
#define MSG_AUTO_HOME_Z "Home Z"
#define MSG_LEVEL_BED_HOMING "Homing XYZ"
#define MSG_LEVEL_BED_WAITING "Klick für Start"
#define MSG_LEVEL_BED_NEXT_POINT "Nächste Koordinate"
#define MSG_LEVEL_BED_DONE "Fertig"
#define MSG_LEVEL_BED_CANCEL "Abbruch"
#define MSG_SET_HOME_OFFSETS "Setze Homeversatz"
#define MSG_HOME_OFFSETS_APPLIED "Homeversatz aktiv"
#define MSG_SET_ORIGIN "Setze Nullpunkt" //"G92 X0 Y0 Z0" commented out in ultralcd.cpp
#define MSG_PREHEAT_1 "Vorwärmen PLA"
#define MSG_PREHEAT_1_N "Vorwärmen PLA "
#define MSG_PREHEAT_1_ALL "Vorw. PLA Alle"
#define MSG_PREHEAT_1_BEDONLY "Vorw. PLA Bett"
#define MSG_PREHEAT_1_SETTINGS "Vorw. PLA Einst."
#define MSG_PREHEAT_2 "Vorwärmen ABS"
#define MSG_PREHEAT_2_N "Vorwärmen ABS "
#define MSG_PREHEAT_2_ALL "Vorw. ABS Alle"
#define MSG_PREHEAT_2_BEDONLY "Vorw. ABS Bett"
#define MSG_PREHEAT_2_SETTINGS "Vorw. ABS Einst."
#define MSG_COOLDOWN "Abkühlen"
#define MSG_SWITCH_PS_ON "Netzteil ein"
#define MSG_SWITCH_PS_OFF "Netzteil aus"
#define MSG_EXTRUDE "Extrudieren"
#define MSG_RETRACT "Retract"
#define MSG_MOVE_AXIS "Bewegen"
#define MSG_LEVEL_BED "Bett nivellieren"
#define MSG_MOVE_X "X"
#define MSG_MOVE_Y "Y"
#define MSG_MOVE_Z "Z"
#define MSG_MOVE_E "Extruder "
#define MSG_MOVE_01MM " 0,1 mm"
#define MSG_MOVE_1MM " 1,0 mm"
#define MSG_MOVE_10MM "10,0 mm"
#define MSG_SPEED "Geschw."
#define MSG_BED_Z "Bett Z"
#define MSG_NOZZLE "Düse"
#define MSG_BED "Bett"
#define MSG_FAN_SPEED "Lüfter"
#define MSG_FLOW "Durchfluss"
#define MSG_CONTROL "Einstellungen"
#define MSG_MIN LCD_STR_THERMOMETER " min"
#define MSG_MAX LCD_STR_THERMOMETER " max"
#define MSG_FACTOR LCD_STR_THERMOMETER " Faktor"
#define MSG_AUTOTEMP "AutoTemp"
#define MSG_ON "Ein"
#define MSG_OFF "Aus"
#define MSG_PID_P "PID P"
#define MSG_PID_I "PID I"
#define MSG_PID_D "PID D"
#define MSG_PID_C "PID C"
#define MSG_SELECT "Auswählen"
#define MSG_ACC "A"
#define MSG_VX_JERK "V X Jerk"
#define MSG_VY_JERK "V Y Jerk"
#define MSG_VZ_JERK "V Z Jerk"
#define MSG_VE_JERK "V E Jerk"
#define MSG_VMAX "V max " // space by purpose
#define MSG_VMIN "V min"
#define MSG_VTRAV_MIN "V min Leerfahrt"
#define MSG_AMAX "A max " // space by purpose
#define MSG_A_RETRACT "A Retract"
#define MSG_A_TRAVEL "A Leerfahrt"
#define MSG_XSTEPS "X Steps/mm"
#define MSG_YSTEPS "Y Steps/mm"
#define MSG_ZSTEPS "Z Steps/mm"
#define MSG_ESTEPS "E Steps/mm"
#define MSG_TEMPERATURE "Temperatur"
#define MSG_MOTION "Bewegung"
#define MSG_VOLUMETRIC "Filament"
#define MSG_VOLUMETRIC_ENABLED "E in mm³"
#define MSG_FILAMENT_DIAM "D Fil."
#define MSG_CONTRAST "LCD Kontrast"
#define MSG_STORE_EPROM "EPROM speichern"
#define MSG_LOAD_EPROM "EPROM laden"
#define MSG_RESTORE_FAILSAFE "Standardkonfiguration"
#define MSG_REFRESH "Aktualisieren"
#define MSG_WATCH "Info"
#define MSG_PREPARE "Vorbereitung"
#define MSG_TUNE "Justierung"
#define MSG_PAUSE_PRINT "SD-Druck Pause"
#define MSG_RESUME_PRINT "SD-Druck Fortsetzung"
#define MSG_STOP_PRINT "SD-Druck Abbruch"
#define MSG_CARD_MENU "SD-Karte"
#define MSG_NO_CARD "Keine SD-Karte"
#define MSG_DWELL "Warten..."
#define MSG_USERWAIT "Warte auf Nutzer"
#define MSG_RESUMING "Druckfortsetzung"
#define MSG_PRINT_ABORTED "Druck abgebrochen"
#define MSG_NO_MOVE "Motoren eingeschaltet"
#define MSG_KILLED "ABGEBROCHEN"
#define MSG_STOPPED "ANGEHALTEN"
#define MSG_CONTROL_RETRACT "Retract mm"
#define MSG_CONTROL_RETRACT_SWAP "Wechs. Retract mm"
#define MSG_CONTROL_RETRACTF "Retract V"
#define MSG_CONTROL_RETRACT_ZLIFT "Z-Hop mm"
#define MSG_CONTROL_RETRACT_RECOVER "UnRet +mm"
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "Wechs. UnRet +mm"
#define MSG_CONTROL_RETRACT_RECOVERF "UnRet V"
#define MSG_AUTORETRACT "AutoRetract"
#define MSG_FILAMENTCHANGE "Filament wechseln"
#define MSG_INIT_SDCARD "SD-Karte erkennen" // Manually initialize the SD-card via user interface
#define MSG_CNG_SDCARD "SD-Karte getauscht" // SD-card changed by user. For machines with no autocarddetect. Both send "M21"
#define MSG_ZPROBE_OUT "Sensor ausserhalb"
#define MSG_BLTOUCH_SELFTEST "BLTouch Test"
#define MSG_BLTOUCH_RESET "BLTouch Reset"
#define MSG_HOME "Vorher" // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#define MSG_FIRST "homen"
#define MSG_ZPROBE_ZOFFSET "Z Versatz"
#define MSG_BABYSTEP_X "Babystep X"
#define MSG_BABYSTEP_Y "Babystep Y"
#define MSG_BABYSTEP_Z "Babystep Z"
#define MSG_ENDSTOP_ABORT "Endstopp-Abbr. ein"
#define MSG_HEATING_FAILED_LCD "HEIZEN FEHLGESCHLAGEN"
#define MSG_ERR_REDUNDANT_TEMP "REDUND. TEMPERATURABWEICHUNG"
#define MSG_THERMAL_RUNAWAY LCD_STR_THERMOMETER " NICHT ERREICHT"
#define MSG_ERR_MAXTEMP LCD_STR_THERMOMETER " ÜBERSCHRITTEN"
#define MSG_ERR_MINTEMP LCD_STR_THERMOMETER " UNTERSCHRITTEN"
#define MSG_ERR_MAXTEMP_BED "BETT " LCD_STR_THERMOMETER " ÜBERSCHRITTEN"
#define MSG_ERR_MINTEMP_BED "BETT " LCD_STR_THERMOMETER " UNTERSCHRITTEN"
#define MSG_ERR_Z_HOMING "G28 Z verboten"
#define MSG_HALTED "DRUCKER STOPP"
#define MSG_PLEASE_RESET "Bitte Resetten"
#define MSG_SHORT_DAY "t" // One character only
#define MSG_SHORT_HOUR "h" // One character only
#define MSG_SHORT_MINUTE "m" // One character only
#define MSG_HEATING "Extr. heizt..."
#define MSG_HEATING_COMPLETE "Extr. aufgeheizt"
#define MSG_BED_HEATING "Bett heizt..."
#define MSG_BED_DONE "Bett aufgeheizt"
#define MSG_DELTA_CALIBRATE "Delta kalibrieren"
#define MSG_DELTA_CALIBRATE_X "Kalibriere X"
#define MSG_DELTA_CALIBRATE_Y "Kalibriere Y"
#define MSG_DELTA_CALIBRATE_Z "Kalibriere Z"
#define MSG_DELTA_CALIBRATE_CENTER "Kalibriere Mitte"
#define MSG_INFO_MENU "Über den Drucker" #define WELCOME_MSG MACHINE_NAME _UxGT(" bereit")
#define MSG_INFO_PRINTER_MENU "Drucker Info" #define MSG_BACK _UxGT("Zurück")
#define MSG_INFO_STATS_MENU "Drucker Stat." #define MSG_SD_INSERTED _UxGT("SD-Karte erkannt")
#define MSG_INFO_BOARD_MENU "Board Info" #define MSG_SD_REMOVED _UxGT("SD-Karte entfernt")
#define MSG_INFO_THERMISTOR_MENU "Thermistors" #define MSG_LCD_ENDSTOPS _UxGT("Endstopp") // Max length 8 characters
#define MSG_INFO_EXTRUDERS "Extruders" #define MSG_MAIN _UxGT("Hauptmenü")
#define MSG_INFO_BAUDRATE "Baud" #define MSG_AUTOSTART _UxGT("Autostart")
#define MSG_INFO_PROTOCOL "Protokoll" #define MSG_DISABLE_STEPPERS _UxGT("Motoren deaktivieren") // M84
#define MSG_LIGHTS_ON "Gehäuse Licht an" #define MSG_AUTO_HOME _UxGT("Home") // G28
#define MSG_LIGHTS_OFF "Gehäuse Licht aus" #define MSG_AUTO_HOME_X _UxGT("Home X")
#define MSG_AUTO_HOME_Y _UxGT("Home Y")
#define MSG_AUTO_HOME_Z _UxGT("Home Z")
#define MSG_LEVEL_BED_HOMING _UxGT("Homing XYZ")
#define MSG_LEVEL_BED_WAITING _UxGT("Klick für Start")
#define MSG_LEVEL_BED_NEXT_POINT _UxGT("Nächste Koordinate")
#define MSG_LEVEL_BED_DONE _UxGT("Fertig")
#define MSG_LEVEL_BED_CANCEL _UxGT("Abbruch")
#define MSG_SET_HOME_OFFSETS _UxGT("Setze Homeversatz")
#define MSG_HOME_OFFSETS_APPLIED _UxGT("Homeversatz aktiv")
#define MSG_SET_ORIGIN _UxGT("Setze Nullpunkt") //"G92 X0 Y0 Z0" commented out in ultralcd.cpp
#define MSG_PREHEAT_1 _UxGT("Vorwärmen PLA")
#define MSG_PREHEAT_1_N _UxGT("Vorwärmen PLA ")
#define MSG_PREHEAT_1_ALL _UxGT("Vorw. PLA Alle")
#define MSG_PREHEAT_1_END _UxGT("Vorw. PLA Extr.")
#define MSG_PREHEAT_1_BEDONLY _UxGT("Vorw. PLA Bett")
#define MSG_PREHEAT_1_SETTINGS _UxGT("Vorw. PLA Einst.")
#define MSG_PREHEAT_2 _UxGT("Vorwärmen ABS")
#define MSG_PREHEAT_2_N _UxGT("Vorwärmen ABS ")
#define MSG_PREHEAT_2_ALL _UxGT("Vorw. ABS Alle")
#define MSG_PREHEAT_2_END _UxGT("Vorw. ABS Extr.")
#define MSG_PREHEAT_2_BEDONLY _UxGT("Vorw. ABS Bett")
#define MSG_PREHEAT_2_SETTINGS _UxGT("Vorw. ABS Einst.")
#define MSG_COOLDOWN _UxGT("Abkühlen")
#define MSG_SWITCH_PS_ON _UxGT("Netzteil ein")
#define MSG_SWITCH_PS_OFF _UxGT("Netzteil aus")
#define MSG_EXTRUDE _UxGT("Extrudieren")
#define MSG_RETRACT _UxGT("Retract")
#define MSG_MOVE_AXIS _UxGT("Bewegen")
#define MSG_LEVEL_BED _UxGT("Bett nivellieren")
#define MSG_MOVING _UxGT("In Bewegung...")
#define MSG_FREE_XY _UxGT("Abstand XY")
#define MSG_MOVE_X _UxGT("X")
#define MSG_MOVE_Y _UxGT("Y")
#define MSG_MOVE_Z _UxGT("Z")
#define MSG_MOVE_E _UxGT("Extruder ")
#define MSG_MOVE_01MM _UxGT(" 0,1 mm")
#define MSG_MOVE_1MM _UxGT(" 1,0 mm")
#define MSG_MOVE_10MM _UxGT("10,0 mm")
#define MSG_SPEED _UxGT("Geschw.")
#define MSG_BED_Z _UxGT("Bett Z")
#define MSG_NOZZLE _UxGT("Düse")
#define MSG_BED _UxGT("Bett")
#define MSG_FAN_SPEED _UxGT("Lüfter")
#define MSG_FLOW _UxGT("Durchfluss")
#define MSG_CONTROL _UxGT("Einstellungen")
#define MSG_MIN LCD_STR_THERMOMETER _UxGT(" min")
#define MSG_MAX LCD_STR_THERMOMETER _UxGT(" max")
#define MSG_FACTOR LCD_STR_THERMOMETER _UxGT(" Faktor")
#define MSG_AUTOTEMP _UxGT("AutoTemp")
#define MSG_ON _UxGT("Ein")
#define MSG_OFF _UxGT("Aus")
#define MSG_PID_P _UxGT("PID P")
#define MSG_PID_I _UxGT("PID I")
#define MSG_PID_D _UxGT("PID D")
#define MSG_PID_C _UxGT("PID C")
#define MSG_SELECT _UxGT("Auswählen")
#define MSG_ACC _UxGT("A")
#define MSG_VX_JERK _UxGT("V X Jerk")
#define MSG_VY_JERK _UxGT("V Y Jerk")
#define MSG_VZ_JERK _UxGT("V Z Jerk")
#define MSG_VE_JERK _UxGT("V E Jerk")
#define MSG_VMAX _UxGT("V max ") // space by purpose
#define MSG_VMIN _UxGT("V min")
#define MSG_VTRAV_MIN _UxGT("V min Leerfahrt")
#define MSG_AMAX _UxGT("A max ") // space by purpose
#define MSG_A_RETRACT _UxGT("A Retract")
#define MSG_A_TRAVEL _UxGT("A Leerfahrt")
#define MSG_XSTEPS _UxGT("X Steps/mm")
#define MSG_YSTEPS _UxGT("Y Steps/mm")
#define MSG_ZSTEPS _UxGT("Z Steps/mm")
#define MSG_ESTEPS _UxGT("E Steps/mm")
#define MSG_E1STEPS _UxGT("E1 Steps/mm")
#define MSG_E2STEPS _UxGT("E2 Steps/mm")
#define MSG_E3STEPS _UxGT("E3 Steps/mm")
#define MSG_E4STEPS _UxGT("E4 Steps/mm")
#define MSG_E5STEPS _UxGT("E5 Steps/mm")
#define MSG_TEMPERATURE _UxGT("Temperatur")
#define MSG_MOTION _UxGT("Bewegung")
#define MSG_FILAMENT _UxGT("Filament")
#define MSG_VOLUMETRIC_ENABLED _UxGT("E in mm³")
#define MSG_FILAMENT_DIAM _UxGT("D Fil.")
#define MSG_ADVANCE_K _UxGT("Advance Faktor")
#define MSG_CONTRAST _UxGT("LCD Kontrast")
#define MSG_STORE_EEPROM _UxGT("EPROM speichern")
#define MSG_LOAD_EEPROM _UxGT("EPROM laden")
#define MSG_RESTORE_FAILSAFE _UxGT("Standardkonfiguration")
#define MSG_REFRESH _UxGT("Aktualisieren")
#define MSG_WATCH _UxGT("Info")
#define MSG_PREPARE _UxGT("Vorbereitung")
#define MSG_TUNE _UxGT("Justierung")
#define MSG_PAUSE_PRINT _UxGT("SD-Druck Pause")
#define MSG_RESUME_PRINT _UxGT("SD-Druck Fortsetzung")
#define MSG_STOP_PRINT _UxGT("SD-Druck Abbruch")
#define MSG_CARD_MENU _UxGT("SD-Karte")
#define MSG_NO_CARD _UxGT("Keine SD-Karte")
#define MSG_DWELL _UxGT("Warten...")
#define MSG_USERWAIT _UxGT("Warte auf Nutzer")
#define MSG_RESUMING _UxGT("Druckfortsetzung")
#define MSG_PRINT_ABORTED _UxGT("Druck abgebrochen")
#define MSG_NO_MOVE _UxGT("Motoren eingeschaltet")
#define MSG_KILLED _UxGT("ABGEBROCHEN")
#define MSG_STOPPED _UxGT("ANGEHALTEN")
#define MSG_CONTROL_RETRACT _UxGT("Retract mm")
#define MSG_CONTROL_RETRACT_SWAP _UxGT("Wechs. Retract mm")
#define MSG_CONTROL_RETRACTF _UxGT("Retract V")
#define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Z-Hop mm")
#define MSG_CONTROL_RETRACT_RECOVER _UxGT("UnRet mm")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("Wechs. UnRet mm")
#define MSG_CONTROL_RETRACT_RECOVERF _UxGT("UnRet V")
#define MSG_AUTORETRACT _UxGT("Autom. Retract")
#define MSG_FILAMENTCHANGE _UxGT("Filament wechseln")
#define MSG_INIT_SDCARD _UxGT("SD-Karte erkennen") // Manually initialize the SD-card via user interface
#define MSG_CNG_SDCARD _UxGT("SD-Karte getauscht") // SD-card changed by user. For machines with no autocarddetect. Both send "M21"
#define MSG_ZPROBE_OUT _UxGT("Sensor ausserhalb")
#define MSG_BLTOUCH_SELFTEST _UxGT("BLTouch Test")
#define MSG_BLTOUCH_RESET _UxGT("BLTouch Reset")
#define MSG_HOME _UxGT("Vorher") // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#define MSG_FIRST _UxGT("homen")
#define MSG_ZPROBE_ZOFFSET _UxGT("Z Versatz")
#define MSG_BABYSTEP_X _UxGT("Babystep X")
#define MSG_BABYSTEP_Y _UxGT("Babystep Y")
#define MSG_BABYSTEP_Z _UxGT("Babystep Z")
#define MSG_ENDSTOP_ABORT _UxGT("Endstopp-Abbr.")
#define MSG_HEATING_FAILED_LCD _UxGT("HEIZEN FEHLGESCHLAGEN")
#define MSG_ERR_REDUNDANT_TEMP _UxGT("REDUND. TEMPERATURABWEICHUNG")
#define MSG_THERMAL_RUNAWAY LCD_STR_THERMOMETER _UxGT(" NICHT ERREICHT")
#define MSG_ERR_MAXTEMP LCD_STR_THERMOMETER _UxGT(" ÜBERSCHRITTEN")
#define MSG_ERR_MINTEMP LCD_STR_THERMOMETER _UxGT(" UNTERSCHRITTEN")
#define MSG_ERR_MAXTEMP_BED _UxGT("BETT ") LCD_STR_THERMOMETER _UxGT(" ÜBERSCHRITTEN")
#define MSG_ERR_MINTEMP_BED _UxGT("BETT ") LCD_STR_THERMOMETER _UxGT(" UNTERSCHRITTEN")
#define MSG_ERR_Z_HOMING _UxGT("G28 Z verboten")
#define MSG_HALTED _UxGT("DRUCKER STOPP")
#define MSG_PLEASE_RESET _UxGT("Bitte Resetten")
#define MSG_SHORT_DAY _UxGT("t") // One character only
#define MSG_SHORT_HOUR _UxGT("h") // One character only
#define MSG_SHORT_MINUTE _UxGT("m") // One character only
#define MSG_HEATING _UxGT("Extr. heizt...")
#define MSG_HEATING_COMPLETE _UxGT("Extr. aufgeheizt")
#define MSG_BED_HEATING _UxGT("Bett heizt...")
#define MSG_BED_DONE _UxGT("Bett aufgeheizt")
#define MSG_DELTA_CALIBRATE _UxGT("Delta kalibrieren")
#define MSG_DELTA_CALIBRATE_X _UxGT("Kalibriere X")
#define MSG_DELTA_CALIBRATE_Y _UxGT("Kalibriere Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Kalibriere Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Kalibriere Mitte")
#define MSG_DELTA_AUTO_CALIBRATE _UxGT("Autom. Kalibrierung")
#define MSG_DELTA_HEIGHT_CALIBRATE _UxGT("Delta Höhe setzen")
#define MSG_DEBUG_MENU _UxGT("Debug Menu")
#define MSG_PROGRESS_BAR_TEST _UxGT("Fortschrittb. Test")
#define MSG_INFO_MENU _UxGT("Über den Drucker")
#define MSG_INFO_PRINTER_MENU _UxGT("Drucker Info")
#define MSG_INFO_STATS_MENU _UxGT("Drucker Stat.")
#define MSG_INFO_BOARD_MENU _UxGT("Board Info")
#define MSG_INFO_THERMISTOR_MENU _UxGT("Thermistoren")
#define MSG_INFO_EXTRUDERS _UxGT("Extruder")
#define MSG_INFO_BAUDRATE _UxGT("Baud")
#define MSG_INFO_PROTOCOL _UxGT("Protokoll")
#define MSG_LIGHTS_ON _UxGT("Gehäuse Licht an")
#define MSG_LIGHTS_OFF _UxGT("Gehäuse Licht aus")
#if LCD_WIDTH >= 20 #if LCD_WIDTH >= 20
#define MSG_INFO_PRINT_COUNT "Gesamte Drucke" #define MSG_INFO_PRINT_COUNT _UxGT("Gesamte Drucke")
#define MSG_INFO_COMPLETED_PRINTS "Beendete Drucke" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Beendete Drucke")
#define MSG_INFO_PRINT_TIME "Gesamte Druckzeit" #define MSG_INFO_PRINT_TIME _UxGT("Gesamte Druckzeit")
#define MSG_INFO_PRINT_LONGEST "Längster Druckjob" #define MSG_INFO_PRINT_LONGEST _UxGT("Längster Druckjob")
#define MSG_INFO_PRINT_FILAMENT "Gesamt Extrudiert" #define MSG_INFO_PRINT_FILAMENT _UxGT("Gesamt Extrudiert")
#else #else
#define MSG_INFO_PRINT_COUNT "Drucke" #define MSG_INFO_PRINT_COUNT _UxGT("Drucke")
#define MSG_INFO_COMPLETED_PRINTS "Komplett" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Komplett")
#define MSG_INFO_PRINT_TIME "Gesamt " #define MSG_INFO_PRINT_TIME _UxGT("Gesamt ")
#define MSG_INFO_PRINT_LONGEST "Längster" #define MSG_INFO_PRINT_LONGEST _UxGT("Längster")
#define MSG_INFO_PRINT_FILAMENT "Extrud." #define MSG_INFO_PRINT_FILAMENT _UxGT("Extrud.")
#endif #endif
#define MSG_INFO_MIN_TEMP "Min Temp" #define MSG_INFO_MIN_TEMP _UxGT("Min Temp")
#define MSG_INFO_MAX_TEMP "Max Temp" #define MSG_INFO_MAX_TEMP _UxGT("Max Temp")
#define MSG_INFO_PSU "Stromversorgung" #define MSG_INFO_PSU _UxGT("Stromversorgung")
#define MSG_DRIVE_STRENGTH "Motorströme" #define MSG_DRIVE_STRENGTH _UxGT("Motorströme")
#define MSG_DAC_PERCENT "Treiber %" #define MSG_DAC_PERCENT _UxGT("Treiber %")
#define MSG_DAC_EEPROM_WRITE "Werte speichern" #define MSG_DAC_EEPROM_WRITE _UxGT("Werte speichern")
#define MSG_FILAMENT_CHANGE_HEADER "ÄNDERE FILAMENT" #define MSG_FILAMENT_CHANGE_HEADER _UxGT("ÄNDERE FILAMENT")
#define MSG_FILAMENT_CHANGE_OPTION_HEADER "ÄNDERE OPTIONEN:" #define MSG_FILAMENT_CHANGE_OPTION_HEADER _UxGT("ÄNDERE OPTIONEN:")
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE "Extrude mehr" #define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Extrude mehr")
#define MSG_FILAMENT_CHANGE_OPTION_RESUME "Drucke weiter" #define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Drucke weiter")
#define MSG_FILAMENT_CHANGE_MINTEMP _UxGT("Min. Temperatur ist ")
#define MSG_FILAMENT_CHANGE_NOZZLE _UxGT(" Düse: ")
#if LCD_HEIGHT >= 4 #if LCD_HEIGHT >= 4
// Up to 3 lines allowed // Up to 3 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_1 "Warte auf den" #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Warte auf den")
#define MSG_FILAMENT_CHANGE_INIT_2 "Start des " #define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("Start des")
#define MSG_FILAMENT_CHANGE_INIT_3 "Filamentwechsels" #define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("Filamentwechsels")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Warte auf" #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Warte auf")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 "Herausnahme" #define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("Herausnahme")
#define MSG_FILAMENT_CHANGE_UNLOAD_3 "des Filaments" #define MSG_FILAMENT_CHANGE_UNLOAD_3 _UxGT("des Filaments")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Filament einlegen" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Filament einlegen")
#define MSG_FILAMENT_CHANGE_INSERT_2 "und Knopf" #define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("und Knopf")
#define MSG_FILAMENT_CHANGE_INSERT_3 "drücken..." #define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("drücken...")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Warte auf" #define MSG_FILAMENT_CHANGE_HEAT_1 _UxGT("Knopf drücken um")
#define MSG_FILAMENT_CHANGE_LOAD_2 "Laden des" #define MSG_FILAMENT_CHANGE_HEAT_2 _UxGT("Düse aufzuheizen.")
#define MSG_FILAMENT_CHANGE_LOAD_3 "Filaments" #define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Düse heizt auf.")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Warte auf" #define MSG_FILAMENT_CHANGE_HEATING_2 _UxGT("Bitte warten...")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 "Extrusion des" #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Warte auf")
#define MSG_FILAMENT_CHANGE_EXTRUDE_3 "Filaments" #define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("Laden des")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Warte auf" #define MSG_FILAMENT_CHANGE_LOAD_3 _UxGT("Filaments")
#define MSG_FILAMENT_CHANGE_RESUME_2 "Fortsetzung des" #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Warte auf")
#define MSG_FILAMENT_CHANGE_RESUME_3 "Druckes" #define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("Extrusion des")
#define MSG_FILAMENT_CHANGE_EXTRUDE_3 _UxGT("Filaments")
#define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Warte auf")
#define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("Fortsetzung des")
#define MSG_FILAMENT_CHANGE_RESUME_3 _UxGT("Druckes")
#else // LCD_HEIGHT < 4 #else // LCD_HEIGHT < 4
// Up to 2 lines allowed // Up to 2 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_1 "Bitte warten..." #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Bitte warten...")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Auswerfen..." #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Auswerfen...")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Laden und Klick" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Laden und Klick")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Laden..." #define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Heizen...")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Extrudieren..." #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Laden...")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Weitermachen..." #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Extrudieren...")
#define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Fortsetzen...")
#endif // LCD_HEIGHT < 4 #endif // LCD_HEIGHT < 4
#endif // LANGUAGE_DE_H #endif // LANGUAGE_DE_H

View File

@@ -33,140 +33,145 @@
#define MAPPER_CECF #define MAPPER_CECF
#define DISPLAY_CHARSET_ISO10646_GREEK #define DISPLAY_CHARSET_ISO10646_GREEK
#define WELCOME_MSG MACHINE_NAME " έτοιμο." #define WELCOME_MSG MACHINE_NAME _UxGT(" έτοιμο.")
#define MSG_SD_INSERTED "Εισαγωγή κάρτας" #define MSG_SD_INSERTED _UxGT("Εισαγωγή κάρτας")
#define MSG_SD_REMOVED "Αφαίρεση κάρτας" #define MSG_SD_REMOVED _UxGT("Αφαίρεση κάρτας")
#define MSG_LCD_ENDSTOPS "Endstops" // Max length 8 characters #define MSG_LCD_ENDSTOPS _UxGT("Endstops") // Max length 8 characters
#define MSG_MAIN "Βασική Οθόνη" #define MSG_MAIN _UxGT("Βασική Οθόνη")
#define MSG_AUTOSTART "Αυτόματη εκκίνηση" #define MSG_AUTOSTART _UxGT("Αυτόματη εκκίνηση")
#define MSG_DISABLE_STEPPERS "Απενεργοποίηση βηματιστή" #define MSG_DISABLE_STEPPERS _UxGT("Απενεργοποίηση βηματιστή")
#define MSG_AUTO_HOME "Αυτομ. επαναφορά στο αρχικό σημείο" #define MSG_AUTO_HOME _UxGT("Αυτομ. επαναφορά στο αρχικό σημείο")
#define MSG_AUTO_HOME_X "Αρχικό σημείο X" #define MSG_AUTO_HOME_X _UxGT("Αρχικό σημείο X")
#define MSG_AUTO_HOME_Y "Αρχικό σημείο Y" #define MSG_AUTO_HOME_Y _UxGT("Αρχικό σημείο Y")
#define MSG_AUTO_HOME_Z "Αρχικό σημείο Z" #define MSG_AUTO_HOME_Z _UxGT("Αρχικό σημείο Z")
#define MSG_LEVEL_BED_HOMING "Επαναφορά στο αρχικό σημείο ΧΥΖ" #define MSG_LEVEL_BED_HOMING _UxGT("Επαναφορά στο αρχικό σημείο ΧΥΖ")
#define MSG_LEVEL_BED_WAITING "Κάντε κλικ για να ξεκινήσετε" #define MSG_LEVEL_BED_WAITING _UxGT("Κάντε κλικ για να ξεκινήσετε")
#define MSG_LEVEL_BED_NEXT_POINT "Επόμενο σημείο" #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Επόμενο σημείο")
#define MSG_LEVEL_BED_DONE "Ολοκλήρωση επιπεδοποίησης!" #define MSG_LEVEL_BED_DONE _UxGT("Ολοκλήρωση επιπεδοποίησης!")
#define MSG_LEVEL_BED_CANCEL "Ακύρωση" #define MSG_LEVEL_BED_CANCEL _UxGT("Ακύρωση")
#define MSG_SET_HOME_OFFSETS "Ορισμός βασικών μετατοπίσεων" #define MSG_SET_HOME_OFFSETS _UxGT("Ορισμός βασικών μετατοπίσεων")
#define MSG_HOME_OFFSETS_APPLIED "Εφαρμόστηκαν οι μετατοπίσεις" #define MSG_HOME_OFFSETS_APPLIED _UxGT("Εφαρμόστηκαν οι μετατοπίσεις")
#define MSG_SET_ORIGIN "Ορισμός προέλευσης" #define MSG_SET_ORIGIN _UxGT("Ορισμός προέλευσης")
#define MSG_PREHEAT_1 "Προθέρμανση PLA" #define MSG_PREHEAT_1 _UxGT("Προθέρμανση PLA")
#define MSG_PREHEAT_1_N MSG_PREHEAT_1 " " #define MSG_PREHEAT_1_N MSG_PREHEAT_1 _UxGT(" ")
#define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 " όλα" #define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 _UxGT(" όλα")
#define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 " κλίνη" #define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 _UxGT(" κλίνη")
#define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 " επιβεβαίωση" #define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 _UxGT(" επιβεβαίωση")
#define MSG_PREHEAT_2 "Προθέρμανση ABS" #define MSG_PREHEAT_2 _UxGT("Προθέρμανση ABS")
#define MSG_PREHEAT_2_N MSG_PREHEAT_2 " " #define MSG_PREHEAT_2_N MSG_PREHEAT_2 _UxGT(" ")
#define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 " όλα" #define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 _UxGT(" όλα")
#define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 " Bed" #define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 _UxGT(" Bed")
#define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 " επιβεβαίωση" #define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 _UxGT(" επιβεβαίωση")
#define MSG_COOLDOWN "Μειωση θερμοκρασιας" #define MSG_COOLDOWN _UxGT("Μειωση θερμοκρασιας")
#define MSG_SWITCH_PS_ON "Ενεργοποίηση" #define MSG_SWITCH_PS_ON _UxGT("Ενεργοποίηση")
#define MSG_SWITCH_PS_OFF "Απενεργοποίηση" #define MSG_SWITCH_PS_OFF _UxGT("Απενεργοποίηση")
#define MSG_EXTRUDE "Εξώθηση" #define MSG_EXTRUDE _UxGT("Εξώθηση")
#define MSG_RETRACT "Ανάσυρση" #define MSG_RETRACT _UxGT("Ανάσυρση")
#define MSG_MOVE_AXIS "Μετακίνηση άξονα" #define MSG_MOVE_AXIS _UxGT("Μετακίνηση άξονα")
#define MSG_LEVEL_BED "Επιπεδοποίηση κλίνης" #define MSG_LEVEL_BED _UxGT("Επιπεδοποίηση κλίνης")
#define MSG_MOVE_X "Μετακίνηση X" #define MSG_MOVE_X _UxGT("Μετακίνηση X")
#define MSG_MOVE_Y "Μετακίνηση Y" #define MSG_MOVE_Y _UxGT("Μετακίνηση Y")
#define MSG_MOVE_Z "Μετακίνηση Z" #define MSG_MOVE_Z _UxGT("Μετακίνηση Z")
#define MSG_MOVE_E "Εξωθητήρας" #define MSG_MOVE_E _UxGT("Εξωθητήρας")
#define MSG_MOVE_01MM "Μετακίνηση 0,1 μμ" #define MSG_MOVE_01MM _UxGT("Μετακίνηση 0,1 μμ")
#define MSG_MOVE_1MM "Μετακίνηση 1 μμ" #define MSG_MOVE_1MM _UxGT("Μετακίνηση 1 μμ")
#define MSG_MOVE_10MM "Μετακίνηση 10 μμ" #define MSG_MOVE_10MM _UxGT("Μετακίνηση 10 μμ")
#define MSG_SPEED "Ταχύτητα" #define MSG_SPEED _UxGT("Ταχύτητα")
#define MSG_BED_Z "Κλίνη Z" #define MSG_BED_Z _UxGT("Κλίνη Z")
#define MSG_NOZZLE "Ακροφύσιο" #define MSG_NOZZLE _UxGT("Ακροφύσιο")
#define MSG_BED "Κλίνη" #define MSG_BED _UxGT("Κλίνη")
#define MSG_FAN_SPEED "Ταχύτητα ανεμιστήρα" #define MSG_FAN_SPEED _UxGT("Ταχύτητα ανεμιστήρα")
#define MSG_FLOW "Ροή" #define MSG_FLOW _UxGT("Ροή")
#define MSG_CONTROL "Έλεγχος" #define MSG_CONTROL _UxGT("Έλεγχος")
#define MSG_MIN " " LCD_STR_THERMOMETER " Min" #define MSG_MIN _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Min")
#define MSG_MAX " " LCD_STR_THERMOMETER " Max" #define MSG_MAX _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Max")
#define MSG_FACTOR " " LCD_STR_THERMOMETER " Fact" #define MSG_FACTOR _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Fact")
#define MSG_AUTOTEMP "Αυτομ. ρύθμιση θερμοκρασίας" #define MSG_AUTOTEMP _UxGT("Αυτομ. ρύθμιση θερμοκρασίας")
#define MSG_ON "Ενεργοποιημένο" #define MSG_ON _UxGT("Ενεργοποιημένο")
#define MSG_OFF "Απενεργοποιημένο" #define MSG_OFF _UxGT("Απενεργοποιημένο")
#define MSG_PID_P "PID-P" #define MSG_PID_P _UxGT("PID-P")
#define MSG_PID_I "PID-I" #define MSG_PID_I _UxGT("PID-I")
#define MSG_PID_D "PID-D" #define MSG_PID_D _UxGT("PID-D")
#define MSG_PID_C "PID-C" #define MSG_PID_C _UxGT("PID-C")
#define MSG_ACC "Επιτάχυνση" #define MSG_ACC _UxGT("Επιτάχυνση")
#define MSG_VX_JERK "Vαντίδραση x" #define MSG_VX_JERK _UxGT("Vαντίδραση x")
#define MSG_VY_JERK "Vαντίδραση y" #define MSG_VY_JERK _UxGT("Vαντίδραση y")
#define MSG_VZ_JERK "Vαντίδραση z" #define MSG_VZ_JERK _UxGT("Vαντίδραση z")
#define MSG_VE_JERK "Vαντίδραση e" #define MSG_VE_JERK _UxGT("Vαντίδραση e")
#define MSG_VMAX "Vμεγ " #define MSG_VMAX _UxGT("Vμεγ ")
#define MSG_VMIN "Vελαχ" #define MSG_VMIN _UxGT("Vελαχ")
#define MSG_VTRAV_MIN "Vελάχ. μετατόπιση" #define MSG_VTRAV_MIN _UxGT("Vελάχ. μετατόπιση")
#define MSG_AMAX "Aμεγ " #define MSG_AMAX _UxGT("Aμεγ ")
#define MSG_A_RETRACT "Α-ανάσυρση" #define MSG_A_RETRACT _UxGT("Α-ανάσυρση")
#define MSG_A_TRAVEL "Α-μετατόπιση" #define MSG_A_TRAVEL _UxGT("Α-μετατόπιση")
#define MSG_XSTEPS "Bήματα X ανά μμ" #define MSG_XSTEPS _UxGT("Bήματα X ανά μμ")
#define MSG_YSTEPS "Bήματα Υ ανά μμ" #define MSG_YSTEPS _UxGT("Bήματα Υ ανά μμ")
#define MSG_ZSTEPS "Bήματα Ζ ανά μμ" #define MSG_ZSTEPS _UxGT("Bήματα Ζ ανά μμ")
#define MSG_ESTEPS "Bήματα Ε ανά μμ" #define MSG_ESTEPS _UxGT("Bήματα Ε ανά μμ")
#define MSG_TEMPERATURE "Θερμοκρασία" #define MSG_E1STEPS _UxGT("Bήματα Ε1 ανά μμ")
#define MSG_MOTION "Κίνηση" #define MSG_E2STEPS _UxGT("Bήματα Ε2 ανά μμ")
#define MSG_VOLUMETRIC "Νήμα" #define MSG_E3STEPS _UxGT("Bήματα Ε3 ανά μμ")
#define MSG_VOLUMETRIC_ENABLED "Ε σε μμ3" #define MSG_E4STEPS _UxGT("Bήματα Ε4 ανά μμ")
#define MSG_FILAMENT_DIAM "Διάμετρος νήματος" #define MSG_E5STEPS _UxGT("Bήματα Ε5 ανά μμ")
#define MSG_CONTRAST "Κοντράστ LCD" #define MSG_TEMPERATURE _UxGT("Θερμοκρασία")
#define MSG_STORE_EPROM "Αποθήκευση" #define MSG_MOTION _UxGT("Κίνηση")
#define MSG_LOAD_EPROM "Φόρτωση" #define MSG_FILAMENT _UxGT("Νήμα")
#define MSG_RESTORE_FAILSAFE "Επαναφορά ασφαλούς αντιγράφου" #define MSG_VOLUMETRIC_ENABLED _UxGT("Ε σε μμ3")
#define MSG_REFRESH "Ανανέωση" #define MSG_FILAMENT_DIAM _UxGT("Διάμετρος νήματος")
#define MSG_WATCH "Οθόνη πληροφόρησης" #define MSG_CONTRAST _UxGT("Κοντράστ LCD")
#define MSG_PREPARE "Προετοιμασία" #define MSG_STORE_EEPROM _UxGT("Αποθήκευση")
#define MSG_TUNE "Συντονισμός" #define MSG_LOAD_EEPROM _UxGT("Φόρτωση")
#define MSG_PAUSE_PRINT "Παύση εκτύπωσης" #define MSG_RESTORE_FAILSAFE _UxGT("Επαναφορά ασφαλούς αντιγράφου")
#define MSG_RESUME_PRINT "Συνέχιση εκτύπωσης" #define MSG_REFRESH _UxGT("Ανανέωση")
#define MSG_STOP_PRINT "Διακοπή εκτύπωσης" #define MSG_WATCH _UxGT("Οθόνη πληροφόρησης")
#define MSG_CARD_MENU "Εκτύπωση από SD" #define MSG_PREPARE _UxGT("Προετοιμασία")
#define MSG_NO_CARD "Δεν βρέθηκε SD" #define MSG_TUNE _UxGT("Συντονισμός")
#define MSG_DWELL "Αναστολή λειτουργίας..." #define MSG_PAUSE_PRINT _UxGT("Παύση εκτύπωσης")
#define MSG_USERWAIT "Αναμονή για χρήστη…" #define MSG_RESUME_PRINT _UxGT("Συνέχιση εκτύπωσης")
#define MSG_RESUMING "Συνεχίζεται η εκτύπωση" #define MSG_STOP_PRINT _UxGT("Διακοπή εκτύπωσης")
#define MSG_PRINT_ABORTED "Διακόπτεται η εκτύπωση" #define MSG_CARD_MENU _UxGT("Εκτύπωση από SD")
#define MSG_NO_MOVE "Καμία κίνηση." #define MSG_NO_CARD _UxGT("Δεν βρέθηκε SD")
#define MSG_KILLED "ΤΕΡΜΑΤΙΣΜΟΣ. " #define MSG_DWELL _UxGT("Αναστολή λειτουργίας...")
#define MSG_STOPPED "ΔΙΑΚΟΠΗ. " #define MSG_USERWAIT _UxGT("Αναμονή για χρήστη…")
#define MSG_CONTROL_RETRACT "Ανάσυρση μμ" #define MSG_RESUMING _UxGT("Συνεχίζεται η εκτύπωση")
#define MSG_CONTROL_RETRACT_SWAP "Εναλλαγή ανάσυρσης μμ" #define MSG_PRINT_ABORTED _UxGT("Διακόπτεται η εκτύπωση")
#define MSG_CONTROL_RETRACTF "Ανάσυρση V" #define MSG_NO_MOVE _UxGT("Καμία κίνηση.")
#define MSG_CONTROL_RETRACT_ZLIFT "Μεταπήδηση μμ" #define MSG_KILLED _UxGT("ΤΕΡΜΑΤΙΣΜΟΣ. ")
#define MSG_CONTROL_RETRACT_RECOVER "UnRet +mm" #define MSG_STOPPED _UxGT("ΔΙΑΚΟΠΗ. ")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "S UnRet+mm" #define MSG_CONTROL_RETRACT _UxGT("Ανάσυρση μμ")
#define MSG_CONTROL_RETRACT_RECOVERF "UnRet V" #define MSG_CONTROL_RETRACT_SWAP _UxGT("Εναλλαγή ανάσυρσης μμ")
#define MSG_AUTORETRACT "Αυτόματη ανάσυρση" #define MSG_CONTROL_RETRACTF _UxGT("Ανάσυρση V")
#define MSG_FILAMENTCHANGE "Αλλαγή νήματος" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Μεταπήδηση μμ")
#define MSG_INIT_SDCARD "Προετοιμασία κάρτας SD" #define MSG_CONTROL_RETRACT_RECOVER _UxGT("UnRet mm")
#define MSG_CNG_SDCARD "Αλλαγή κάρτας SD" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("S UnRet mm")
#define MSG_ZPROBE_OUT "Διερεύνηση Z εκτός κλίνης" #define MSG_CONTROL_RETRACT_RECOVERF _UxGT("UnRet V")
#define MSG_YX_UNHOMED "Επαναφορά Χ/Υ πριν από Ζ" #define MSG_AUTORETRACT _UxGT("Αυτόματη ανάσυρση")
#define MSG_XYZ_UNHOMED "Επαναφορά ΧΥΖ πρώτα" #define MSG_FILAMENTCHANGE _UxGT("Αλλαγή νήματος")
#define MSG_ZPROBE_ZOFFSET "Μετατόπιση Ζ" #define MSG_INIT_SDCARD _UxGT("Προετοιμασία κάρτας SD")
#define MSG_BABYSTEP_X "Μικρό βήμα Χ" #define MSG_CNG_SDCARD _UxGT("Αλλαγή κάρτας SD")
#define MSG_BABYSTEP_Y "Μικρό βήμα Υ" #define MSG_ZPROBE_OUT _UxGT("Διερεύνηση Z εκτός κλίνης")
#define MSG_BABYSTEP_Z "Μικρό βήμα Ζ" #define MSG_YX_UNHOMED _UxGT("Επαναφορά Χ/Υ πριν από Ζ")
#define MSG_ENDSTOP_ABORT "Ματαίωση endstop " #define MSG_XYZ_UNHOMED _UxGT("Επαναφορά ΧΥΖ πρώτα")
#define MSG_HEATING_FAILED_LCD "Ανεπιτυχής θέρμανση" #define MSG_ZPROBE_ZOFFSET _UxGT("Μετατόπιση Ζ")
#define MSG_ERR_REDUNDANT_TEMP "Λάθος: ΠΛΕΟΝΑΖΟΥΣΑ ΘΕΡΜΟΤΗΤΑ" #define MSG_BABYSTEP_X _UxGT("Μικρό βήμα Χ")
#define MSG_THERMAL_RUNAWAY "ΔΙΑΦΥΓΗ ΘΕΡΜΟΤΗΤΑΣ" #define MSG_BABYSTEP_Y _UxGT("Μικρό βήμα Υ")
#define MSG_ERR_MAXTEMP "Λάθος: ΜΕΓΙΣΤΗ ΘΕΡΜΟΤΗΤΑ" #define MSG_BABYSTEP_Z _UxGT("Μικρό βήμα Ζ")
#define MSG_ERR_MINTEMP "Λάθος: ΕΛΑΧΙΣΤΗ ΘΕΡΜΟΤΗΤΑ" #define MSG_ENDSTOP_ABORT _UxGT("Ματαίωση endstop ")
#define MSG_ERR_MAXTEMP_BED "Λάθος: ΜΕΓΙΣΤΗ ΘΕΡΜΟΤΗΤΑ ΚΛΙΝΗΣ" #define MSG_HEATING_FAILED_LCD _UxGT("Ανεπιτυχής θέρμανση")
#define MSG_ERR_MINTEMP_BED "Λάθος: ΕΛΑΧΙΣΤΗ ΘΕΡΜΟΤΗΤΑ ΚΛΙΝΗΣ" #define MSG_ERR_REDUNDANT_TEMP _UxGT("Λάθος: ΠΛΕΟΝΑΖΟΥΣΑ ΘΕΡΜΟΤΗΤΑ")
#define MSG_HEATING "Θερμαίνεται…" #define MSG_THERMAL_RUNAWAY _UxGT("ΔΙΑΦΥΓΗ ΘΕΡΜΟΤΗΤΑΣ")
#define MSG_HEATING_COMPLETE "Η θέρμανση ολοκληρώθηκε." #define MSG_ERR_MAXTEMP _UxGT("Λάθος: ΜΕΓΙΣΤΗ ΘΕΡΜΟΤΗΤΑ")
#define MSG_BED_HEATING "Θέρμανση κλίνης." #define MSG_ERR_MINTEMP _UxGT("Λάθος: ΕΛΑΧΙΣΤΗ ΘΕΡΜΟΤΗΤΑ")
#define MSG_BED_DONE "Η κλίνη ολοκληρώθηκε." #define MSG_ERR_MAXTEMP_BED _UxGT("Λάθος: ΜΕΓΙΣΤΗ ΘΕΡΜΟΤΗΤΑ ΚΛΙΝΗΣ")
#define MSG_DELTA_CALIBRATE "Βαθμονόμηση Delta" #define MSG_ERR_MINTEMP_BED _UxGT("Λάθος: ΕΛΑΧΙΣΤΗ ΘΕΡΜΟΤΗΤΑ ΚΛΙΝΗΣ")
#define MSG_DELTA_CALIBRATE_X "Βαθμονόμηση X" #define MSG_HEATING _UxGT("Θερμαίνεται…")
#define MSG_DELTA_CALIBRATE_Y "Βαθμονόμηση Y" #define MSG_HEATING_COMPLETE _UxGT("Η θέρμανση ολοκληρώθηκε.")
#define MSG_DELTA_CALIBRATE_Z "Βαθμονόμηση Z" #define MSG_BED_HEATING _UxGT("Θέρμανση κλίνης.")
#define MSG_DELTA_CALIBRATE_CENTER "Βαθμονόμηση κέντρου" #define MSG_BED_DONE _UxGT("Η κλίνη ολοκληρώθηκε.")
#define MSG_DELTA_CALIBRATE _UxGT("Βαθμονόμηση Delta")
#define MSG_DELTA_CALIBRATE_X _UxGT("Βαθμονόμηση X")
#define MSG_DELTA_CALIBRATE_Y _UxGT("Βαθμονόμηση Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Βαθμονόμηση Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Βαθμονόμηση κέντρου")
#endif // LANGUAGE_EL_GR_H #endif // LANGUAGE_EL_GR_H

View File

@@ -33,194 +33,199 @@
#define MAPPER_CECF #define MAPPER_CECF
#define DISPLAY_CHARSET_ISO10646_GREEK #define DISPLAY_CHARSET_ISO10646_GREEK
#define WELCOME_MSG MACHINE_NAME " έτοιμο." #define WELCOME_MSG MACHINE_NAME _UxGT(" έτοιμο.")
#define MSG_SD_INSERTED "Εισαγωγή κάρτας" #define MSG_SD_INSERTED _UxGT("Εισαγωγή κάρτας")
#define MSG_SD_REMOVED "Αφαίρεση κάρτας" #define MSG_SD_REMOVED _UxGT("Αφαίρεση κάρτας")
#define MSG_LCD_ENDSTOPS "Endstops" // Max length 8 characters #define MSG_LCD_ENDSTOPS _UxGT("Endstops") // Max length 8 characters
#define MSG_MAIN "Βασική Οθόνη" #define MSG_MAIN _UxGT("Βασική Οθόνη")
#define MSG_AUTOSTART "Αυτόματη εκκίνηση" #define MSG_AUTOSTART _UxGT("Αυτόματη εκκίνηση")
#define MSG_DISABLE_STEPPERS "Απενεργοποίηση Μοτέρ" #define MSG_DISABLE_STEPPERS _UxGT("Απενεργοποίηση Μοτέρ")
#define MSG_AUTO_HOME "Αυτομ. επαναφορά στο αρχικό σημείο" //SHORTEN #define MSG_AUTO_HOME _UxGT("Αυτομ. επαναφορά στο αρχικό σημείο") //SHORTEN
#define MSG_AUTO_HOME_X "Αρχικό σημείο X" #define MSG_AUTO_HOME_X _UxGT("Αρχικό σημείο X")
#define MSG_AUTO_HOME_Y "Αρχικό σημείο Y" #define MSG_AUTO_HOME_Y _UxGT("Αρχικό σημείο Y")
#define MSG_AUTO_HOME_Z "Αρχικό σημείο Z" #define MSG_AUTO_HOME_Z _UxGT("Αρχικό σημείο Z")
#define MSG_LEVEL_BED_HOMING "Επαναφορά Επ. Εκτύπωσης" //SHORTEN #define MSG_LEVEL_BED_HOMING _UxGT("Επαναφορά Επ. Εκτύπωσης") //SHORTEN
#define MSG_LEVEL_BED_WAITING "Επιπεδοποίηση επ. Εκτύπωσης περιμενει" //SHORTEN #define MSG_LEVEL_BED_WAITING _UxGT("Επιπεδοποίηση επ. Εκτύπωσης περιμενει") //SHORTEN
#define MSG_LEVEL_BED_NEXT_POINT "Επόμενο σημείο" #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Επόμενο σημείο")
#define MSG_LEVEL_BED_DONE "Ολοκλήρωση επιπεδοποίησης!" //SHORTEN #define MSG_LEVEL_BED_DONE _UxGT("Ολοκλήρωση επιπεδοποίησης!") //SHORTEN
#define MSG_LEVEL_BED_CANCEL "Ακύρωση" #define MSG_LEVEL_BED_CANCEL _UxGT("Ακύρωση")
#define MSG_SET_HOME_OFFSETS "Ορισμός βασικών μετατοπίσεων" //SHORTEN #define MSG_SET_HOME_OFFSETS _UxGT("Ορισμός βασικών μετατοπίσεων") //SHORTEN
#define MSG_HOME_OFFSETS_APPLIED "Εφαρμόστηκαν οι μετατοπίσεις" //SHORTEN #define MSG_HOME_OFFSETS_APPLIED _UxGT("Εφαρμόστηκαν οι μετατοπίσεις") //SHORTEN
#define MSG_SET_ORIGIN "Ορισμός προέλευσης" #define MSG_SET_ORIGIN _UxGT("Ορισμός προέλευσης")
#define MSG_PREHEAT_1 "Προθέρμανση PLA" #define MSG_PREHEAT_1 _UxGT("Προθέρμανση PLA")
#define MSG_PREHEAT_1_N MSG_PREHEAT_1 " " #define MSG_PREHEAT_1_N MSG_PREHEAT_1 _UxGT(" ")
#define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 " όλα" #define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 _UxGT(" όλα")
#define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 " bed" //SHORTEN #define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 _UxGT(" bed") //SHORTEN
#define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 " επιβεβαίωση" //SHORTEN #define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 _UxGT(" επιβεβαίωση") //SHORTEN
#define MSG_PREHEAT_2 "Προθέρμανση ABS" #define MSG_PREHEAT_2 _UxGT("Προθέρμανση ABS")
#define MSG_PREHEAT_2_N MSG_PREHEAT_2 " " #define MSG_PREHEAT_2_N MSG_PREHEAT_2 _UxGT(" ")
#define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 " όλα" #define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 _UxGT(" όλα")
#define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 " bed" //SHORTEN #define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 _UxGT(" bed") //SHORTEN
#define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 " επιβεβαίωση" //SHORTEN #define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 _UxGT(" επιβεβαίωση") //SHORTEN
#define MSG_COOLDOWN "Μειωση θερμοκρασιας" #define MSG_COOLDOWN _UxGT("Μειωση θερμοκρασιας")
#define MSG_SWITCH_PS_ON "Ενεργοποίηση" #define MSG_SWITCH_PS_ON _UxGT("Ενεργοποίηση")
#define MSG_SWITCH_PS_OFF "Απενεργοποίηση" #define MSG_SWITCH_PS_OFF _UxGT("Απενεργοποίηση")
#define MSG_EXTRUDE "Εξώθηση" #define MSG_EXTRUDE _UxGT("Εξώθηση")
#define MSG_RETRACT "Ανάσυρση" #define MSG_RETRACT _UxGT("Ανάσυρση")
#define MSG_MOVE_AXIS "Μετακίνηση άξονα" #define MSG_MOVE_AXIS _UxGT("Μετακίνηση άξονα")
#define MSG_LEVEL_BED "Επιπεδοποίηση Επ. Εκτύπωσης" //SHORTEN #define MSG_LEVEL_BED _UxGT("Επιπεδοποίηση Επ. Εκτύπωσης") //SHORTEN
#define MSG_MOVE_X "Μετακίνηση X" #define MSG_MOVE_X _UxGT("Μετακίνηση X")
#define MSG_MOVE_Y "Μετακίνηση Y" #define MSG_MOVE_Y _UxGT("Μετακίνηση Y")
#define MSG_MOVE_Z "Μετακίνηση Z" #define MSG_MOVE_Z _UxGT("Μετακίνηση Z")
#define MSG_MOVE_E "Εξωθητήρας" #define MSG_MOVE_E _UxGT("Εξωθητήρας")
#define MSG_MOVE_01MM "Μετακίνηση 0,1μμ" #define MSG_MOVE_01MM _UxGT("Μετακίνηση 0,1μμ")
#define MSG_MOVE_1MM "Μετακίνηση 1μμ" #define MSG_MOVE_1MM _UxGT("Μετακίνηση 1μμ")
#define MSG_MOVE_10MM "Μετακίνηση 10μμ" #define MSG_MOVE_10MM _UxGT("Μετακίνηση 10μμ")
#define MSG_SPEED "Ταχύτητα" #define MSG_SPEED _UxGT("Ταχύτητα")
#define MSG_BED_Z "Επ. Εκτύπωσης Z" #define MSG_BED_Z _UxGT("Επ. Εκτύπωσης Z")
#define MSG_NOZZLE "Ακροφύσιο" #define MSG_NOZZLE _UxGT("Ακροφύσιο")
#define MSG_BED "Κλίνη" #define MSG_BED _UxGT("Κλίνη")
#define MSG_FAN_SPEED "Ταχύτητα ανεμιστήρα" #define MSG_FAN_SPEED _UxGT("Ταχύτητα ανεμιστήρα")
#define MSG_FLOW "Ροή" #define MSG_FLOW _UxGT("Ροή")
#define MSG_CONTROL "Έλεγχος" #define MSG_CONTROL _UxGT("Έλεγχος")
#define MSG_MIN " " LCD_STR_THERMOMETER " Min" #define MSG_MIN _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Min")
#define MSG_MAX " " LCD_STR_THERMOMETER " Max" #define MSG_MAX _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Max")
#define MSG_FACTOR " " LCD_STR_THERMOMETER " Fact" #define MSG_FACTOR _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Fact")
#define MSG_AUTOTEMP "Αυτομ ρύθμιση θερ/σίας" //SHORTEN #define MSG_AUTOTEMP _UxGT("Αυτομ ρύθμιση θερ/σίας") //SHORTEN
#define MSG_ON "Ενεργοποιημένο" #define MSG_ON _UxGT("Ενεργοποιημένο")
#define MSG_OFF "Απενεργοποιημένο" #define MSG_OFF _UxGT("Απενεργοποιημένο")
#define MSG_PID_P "PID-P" #define MSG_PID_P _UxGT("PID-P")
#define MSG_PID_I "PID-I" #define MSG_PID_I _UxGT("PID-I")
#define MSG_PID_D "PID-D" #define MSG_PID_D _UxGT("PID-D")
#define MSG_PID_C "PID-C" #define MSG_PID_C _UxGT("PID-C")
#define MSG_ACC "Επιτάχυνση" #define MSG_ACC _UxGT("Επιτάχυνση")
#define MSG_VX_JERK "Vαντίδραση x" #define MSG_VX_JERK _UxGT("Vαντίδραση x")
#define MSG_VY_JERK "Vαντίδραση y" #define MSG_VY_JERK _UxGT("Vαντίδραση y")
#define MSG_VZ_JERK "Vαντίδραση z" #define MSG_VZ_JERK _UxGT("Vαντίδραση z")
#define MSG_VE_JERK "Vαντίδραση e" #define MSG_VE_JERK _UxGT("Vαντίδραση e")
#define MSG_VMAX "V Μέγιστο" #define MSG_VMAX _UxGT("V Μέγιστο")
#define MSG_VMIN "V Ελάχιστο" #define MSG_VMIN _UxGT("V Ελάχιστο")
#define MSG_VTRAV_MIN "Vελάχ. μετατόπιση" #define MSG_VTRAV_MIN _UxGT("Vελάχ. μετατόπιση")
#define MSG_AMAX "Aμεγ " #define MSG_AMAX _UxGT("Aμεγ ")
#define MSG_A_RETRACT "Α-ανάσυρση" #define MSG_A_RETRACT _UxGT("Α-ανάσυρση")
#define MSG_A_TRAVEL "Α-μετατόπιση" #define MSG_A_TRAVEL _UxGT("Α-μετατόπιση")
#define MSG_XSTEPS "Bήματα X ανά μμ" #define MSG_XSTEPS _UxGT("Bήματα X ανά μμ")
#define MSG_YSTEPS "Bήματα Υ ανά μμ" #define MSG_YSTEPS _UxGT("Bήματα Υ ανά μμ")
#define MSG_ZSTEPS "Bήματα Ζ ανά μμ" #define MSG_ZSTEPS _UxGT("Bήματα Ζ ανά μμ")
#define MSG_ESTEPS "Bήματα Ε ανά μμ" #define MSG_ESTEPS _UxGT("Bήματα Ε ανά μμ")
#define MSG_TEMPERATURE "Θερμοκρασία" #define MSG_E1STEPS _UxGT("Bήματα Ε1 ανά μμ")
#define MSG_MOTION "Κίνηση" #define MSG_E2STEPS _UxGT("Bήματα Ε2 ανά μμ")
#define MSG_VOLUMETRIC "Νήμα" #define MSG_E3STEPS _UxGT("Bήματα Ε3 ανά μμ")
#define MSG_VOLUMETRIC_ENABLED "Ε σε μμ3" #define MSG_E4STEPS _UxGT("Bήματα Ε4 ανά μμ")
#define MSG_FILAMENT_DIAM "Διάμετρος νήματος" #define MSG_E5STEPS _UxGT("Bήματα Ε5 ανά μμ")
#define MSG_CONTRAST "Κοντράστ LCD" #define MSG_TEMPERATURE _UxGT("Θερμοκρασία")
#define MSG_STORE_EPROM "Αποθήκευση" #define MSG_MOTION _UxGT("Κίνηση")
#define MSG_LOAD_EPROM "Φόρτωση" #define MSG_FILAMENT _UxGT("Νήμα")
#define MSG_RESTORE_FAILSAFE "Επαναφορά ασφαλούς αντιγράφου" //SHORTEN #define MSG_VOLUMETRIC_ENABLED _UxGT("Ε σε μμ3")
#define MSG_REFRESH "Ανανέωση" #define MSG_FILAMENT_DIAM _UxGT("Διάμετρος νήματος")
#define MSG_WATCH "Οθόνη πληροφόρησης" #define MSG_CONTRAST _UxGT("Κοντράστ LCD")
#define MSG_PREPARE "Προετοιμασία" #define MSG_STORE_EEPROM _UxGT("Αποθήκευση")
#define MSG_TUNE "Συντονισμός" #define MSG_LOAD_EEPROM _UxGT("Φόρτωση")
#define MSG_PAUSE_PRINT "Παύση εκτύπωσης" #define MSG_RESTORE_FAILSAFE _UxGT("Επαναφορά ασφαλούς αντιγράφου") //SHORTEN
#define MSG_RESUME_PRINT "Συνέχιση εκτύπωσης" #define MSG_REFRESH _UxGT("Ανανέωση")
#define MSG_STOP_PRINT "Διακοπή εκτύπωσης" #define MSG_WATCH _UxGT("Οθόνη πληροφόρησης")
#define MSG_CARD_MENU "Εκτύπωση από SD" #define MSG_PREPARE _UxGT("Προετοιμασία")
#define MSG_NO_CARD "Δεν βρέθηκε SD" #define MSG_TUNE _UxGT("Συντονισμός")
#define MSG_DWELL "Αναστολή λειτουργίας" #define MSG_PAUSE_PRINT _UxGT("Παύση εκτύπωσης")
#define MSG_USERWAIT "Αναμονή για χρήστη" #define MSG_RESUME_PRINT _UxGT("Συνέχιση εκτύπωσης")
#define MSG_RESUMING "Συνεχίζεται η εκτύπωση" //SHORTEN #define MSG_STOP_PRINT _UxGT("Διακοπή εκτύπωσης")
#define MSG_PRINT_ABORTED "Διακόπτεται η εκτύπωση" //SHORTEN #define MSG_CARD_MENU _UxGT("Εκτύπωση από SD")
#define MSG_NO_MOVE "Καμία κίνηση." #define MSG_NO_CARD _UxGT("Δεν βρέθηκε SD")
#define MSG_KILLED "ΤΕΡΜΑΤΙΣΜΟΣ. " #define MSG_DWELL _UxGT("Αναστολή λειτουργίας")
#define MSG_STOPPED "ΔΙΑΚΟΠΗ. " #define MSG_USERWAIT _UxGT("Αναμονή για χρήστη")
#define MSG_CONTROL_RETRACT "Ανάσυρση μμ" #define MSG_RESUMING _UxGT("Συνεχίζεται η εκτύπωση") //SHORTEN
#define MSG_CONTROL_RETRACT_SWAP "Εναλλαγή ανάσυρσης μμ" //SHORTEN #define MSG_PRINT_ABORTED _UxGT("Διακόπτεται η εκτύπωση") //SHORTEN
#define MSG_CONTROL_RETRACTF "Ανάσυρση V" #define MSG_NO_MOVE _UxGT("Καμία κίνηση.")
#define MSG_CONTROL_RETRACT_ZLIFT "Μεταπήδηση μμ" #define MSG_KILLED _UxGT("ΤΕΡΜΑΤΙΣΜΟΣ. ")
#define MSG_CONTROL_RETRACT_RECOVER "UnRet +mm" #define MSG_STOPPED _UxGT("ΔΙΑΚΟΠΗ. ")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "S UnRet+mm" #define MSG_CONTROL_RETRACT _UxGT("Ανάσυρση μμ")
#define MSG_CONTROL_RETRACT_RECOVERF "UnRet V" #define MSG_CONTROL_RETRACT_SWAP _UxGT("Εναλλαγή ανάσυρσης μμ") //SHORTEN
#define MSG_AUTORETRACT "Αυτόματη ανάσυρση" #define MSG_CONTROL_RETRACTF _UxGT("Ανάσυρση V")
#define MSG_FILAMENTCHANGE "Αλλαγή νήματος" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Μεταπήδηση μμ")
#define MSG_INIT_SDCARD "Προετοιμασία κάρτας SD" //SHORTEN #define MSG_CONTROL_RETRACT_RECOVER _UxGT("UnRet mm")
#define MSG_CNG_SDCARD "Αλλαγή κάρτας SD" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("S UnRet mm")
#define MSG_ZPROBE_OUT "Διερεύνηση Z εκτός Επ.Εκτύπωσης" //SHORTEN #define MSG_CONTROL_RETRACT_RECOVERF _UxGT("UnRet V")
#define MSG_YX_UNHOMED "Επαναφορά Χ/Υ πριν από Ζ" //SHORTEN #define MSG_AUTORETRACT _UxGT("Αυτόματη ανάσυρση")
#define MSG_XYZ_UNHOMED "Επαναφορά ΧΥΖ πρώτα" #define MSG_FILAMENTCHANGE _UxGT("Αλλαγή νήματος")
#define MSG_ZPROBE_ZOFFSET "Μετατόπιση Ζ" #define MSG_INIT_SDCARD _UxGT("Προετοιμασία κάρτας SD") //SHORTEN
#define MSG_BABYSTEP_X "Μικρό βήμα Χ" #define MSG_CNG_SDCARD _UxGT("Αλλαγή κάρτας SD")
#define MSG_BABYSTEP_Y "Μικρό βήμα Υ" #define MSG_ZPROBE_OUT _UxGT("Διερεύνηση Z εκτός Επ.Εκτύπωσης") //SHORTEN
#define MSG_BABYSTEP_Z "Μικρό βήμα Ζ" #define MSG_YX_UNHOMED _UxGT("Επαναφορά Χ/Υ πριν από Ζ") //SHORTEN
#define MSG_ENDSTOP_ABORT "Ακύρωση endstop " #define MSG_XYZ_UNHOMED _UxGT("Επαναφορά ΧΥΖ πρώτα")
#define MSG_HEATING_FAILED_LCD "Ανεπιτυχής θέρμανση" #define MSG_ZPROBE_ZOFFSET _UxGT("Μετατόπιση Ζ")
#define MSG_ERR_REDUNDANT_TEMP "ΠΛΕΟΝΑΖΟΥΣΑ ΘΕΡΜΟΤΗΤΑ" #define MSG_BABYSTEP_X _UxGT("Μικρό βήμα Χ")
#define MSG_THERMAL_RUNAWAY "ΔΙΑΦΥΓΗ ΘΕΡΜΟΚΡΑΣΙΑΣ" #define MSG_BABYSTEP_Y _UxGT("Μικρό βήμα Υ")
#define MSG_ERR_MAXTEMP "ΠΕΡΙΤΗ ΘΕΡΜΟΚΡΑΣΙΑ" #define MSG_BABYSTEP_Z _UxGT("Μικρό βήμα Ζ")
#define MSG_ERR_MINTEMP "ΜΗ ΕΠΑΡΚΗΣ ΘΕΡΜΟΚΡΑΣΙΑΣ" //SHORTEN #define MSG_ENDSTOP_ABORT _UxGT("Ακύρωση endstop ")
#define MSG_ERR_MAXTEMP_BED "ΜΕΓΙΣΤΗ ΘΕΡΜΟΚΡΑΣΙΑΣ ΕΠ. ΕΚΤΥΠΩΣΗΣ" //SHORTEN #define MSG_HEATING_FAILED_LCD _UxGT("Ανεπιτυχής θέρμανση")
#define MSG_ERR_MINTEMP_BED "ΕΛΑΧΙΣΤΗ ΘΕΡΜΟΚΡΑΣΙΑΣ ΕΠ. ΕΚΤΥΠΩΣΗΣ" //SHORTEN #define MSG_ERR_REDUNDANT_TEMP _UxGT("ΠΛΕΟΝΑΖΟΥΣΑ ΘΕΡΜΟΤΗΤΑ")
#define MSG_HALTED "H εκτύπωση διακόπηκε" #define MSG_THERMAL_RUNAWAY _UxGT("ΔΙΑΦΥΓΗ ΘΕΡΜΟΚΡΑΣΙΑΣ")
#define MSG_PLEASE_RESET "PLEASE RESET" //TRANSLATE #define MSG_ERR_MAXTEMP _UxGT("ΠΕΡΙΤΗ ΘΕΡΜΟΚΡΑΣΙΑ")
#define MSG_HEATING "Θερμαίνεται…" #define MSG_ERR_MINTEMP _UxGT("ΜΗ ΕΠΑΡΚΗΣ ΘΕΡΜΟΚΡΑΣΙΑΣ") //SHORTEN
#define MSG_HEATING_COMPLETE "Η θέρμανση ολοκληρώθηκε." //SHORTEN #define MSG_ERR_MAXTEMP_BED _UxGT("ΜΕΓΙΣΤΗ ΘΕΡΜΟΚΡΑΣΙΑΣ ΕΠ. ΕΚΤΥΠΩΣΗΣ") //SHORTEN
#define MSG_BED_HEATING "Θέρμανση ΕΠ. Εκτύπωσης" //SHORTEN #define MSG_ERR_MINTEMP_BED _UxGT("ΕΛΑΧΙΣΤΗ ΘΕΡΜΟΚΡΑΣΙΑΣ ΕΠ. ΕΚΤΥΠΩΣΗΣ") //SHORTEN
#define MSG_BED_DONE "Η Επ. Εκτύπωσης ολοκληρώθηκε" //SHORTEN #define MSG_HALTED _UxGT("H εκτύπωση διακόπηκε")
#define MSG_DELTA_CALIBRATE "Βαθμονόμηση Delta" #define MSG_PLEASE_RESET _UxGT("PLEASE RESET") //TRANSLATE
#define MSG_DELTA_CALIBRATE_X "Βαθμονόμηση X" #define MSG_HEATING _UxGT("Θερμαίνεται…")
#define MSG_DELTA_CALIBRATE_Y "Βαθμονόμηση Y" #define MSG_HEATING_COMPLETE _UxGT("Η θέρμανση ολοκληρώθηκε.") //SHORTEN
#define MSG_DELTA_CALIBRATE_Z "Βαθμονόμηση Z" #define MSG_BED_HEATING _UxGT("Θέρμανση ΕΠ. Εκτύπωσης") //SHORTEN
#define MSG_DELTA_CALIBRATE_CENTER "Βαθμονόμηση κέντρου" #define MSG_BED_DONE _UxGT("Η Επ. Εκτύπωσης ολοκληρώθηκε") //SHORTEN
#define MSG_DELTA_CALIBRATE _UxGT("Βαθμονόμηση Delta")
#define MSG_DELTA_CALIBRATE_X _UxGT("Βαθμονόμηση X")
#define MSG_DELTA_CALIBRATE_Y _UxGT("Βαθμονόμηση Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Βαθμονόμηση Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Βαθμονόμηση κέντρου")
#define MSG_INFO_MENU "About Printer" #define MSG_INFO_MENU _UxGT("About Printer")
#define MSG_INFO_PRINTER_MENU "Printer Info" #define MSG_INFO_PRINTER_MENU _UxGT("Printer Info")
#define MSG_INFO_STATS_MENU "Printer Stats" #define MSG_INFO_STATS_MENU _UxGT("Printer Stats")
#define MSG_INFO_BOARD_MENU "Board Info" #define MSG_INFO_BOARD_MENU _UxGT("Board Info")
#define MSG_INFO_THERMISTOR_MENU "Thermistors" #define MSG_INFO_THERMISTOR_MENU _UxGT("Thermistors")
#define MSG_INFO_EXTRUDERS "Extruders" #define MSG_INFO_EXTRUDERS _UxGT("Extruders")
#define MSG_INFO_BAUDRATE "Baud" #define MSG_INFO_BAUDRATE _UxGT("Baud")
#define MSG_INFO_PROTOCOL "Protocol" #define MSG_INFO_PROTOCOL _UxGT("Protocol")
#if LCD_WIDTH >= 20 #if LCD_WIDTH >= 20
#define MSG_INFO_PRINT_COUNT "Print Count" #define MSG_INFO_PRINT_COUNT _UxGT("Print Count")
#define MSG_INFO_COMPLETED_PRINTS "Completed " #define MSG_INFO_COMPLETED_PRINTS _UxGT("Completed ")
#define MSG_INFO_PRINT_TIME "Total Time " #define MSG_INFO_PRINT_TIME _UxGT("Total Time ")
#else #else
#define MSG_INFO_PRINT_COUNT "Prints " #define MSG_INFO_PRINT_COUNT _UxGT("Prints ")
#define MSG_INFO_COMPLETED_PRINTS "Completed" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Completed")
#define MSG_INFO_PRINT_TIME "Duration " #define MSG_INFO_PRINT_TIME _UxGT("Duration ")
#endif #endif
#define MSG_INFO_MIN_TEMP "Min Temp" #define MSG_INFO_MIN_TEMP _UxGT("Min Temp")
#define MSG_INFO_MAX_TEMP "Max Temp" #define MSG_INFO_MAX_TEMP _UxGT("Max Temp")
#define MSG_INFO_PSU "Power Supply" #define MSG_INFO_PSU _UxGT("Power Supply")
#define MSG_FILAMENT_CHANGE_HEADER "CHANGE FILAMENT" #define MSG_FILAMENT_CHANGE_HEADER _UxGT("CHANGE FILAMENT")
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE "Extrude more" #define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Extrude more")
#define MSG_FILAMENT_CHANGE_OPTION_RESUME "Resume print" #define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Resume print")
#if LCD_HEIGHT >= 4 #if LCD_HEIGHT >= 4
// Up to 3 lines allowed // Up to 3 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_1 "Wait for start" #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Wait for start")
#define MSG_FILAMENT_CHANGE_INIT_2 "of the filament" #define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("of the filament")
#define MSG_FILAMENT_CHANGE_INIT_3 "change" #define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("change")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Wait for" #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 "filament unload" #define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("filament unload")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Insert filament" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Insert filament")
#define MSG_FILAMENT_CHANGE_INSERT_2 "and press button" #define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("and press button")
#define MSG_FILAMENT_CHANGE_INSERT_3 "to continue..." #define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("to continue...")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Wait for" #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_LOAD_2 "filament load" #define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("filament load")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Wait for" #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 "filament extrude" #define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("filament extrude")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Wait for print" #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Wait for print")
#define MSG_FILAMENT_CHANGE_RESUME_2 "to resume" #define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("to resume")
#else // LCD_HEIGHT < 4 #else // LCD_HEIGHT < 4
// Up to 2 lines allowed // Up to 2 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_1 "Please wait..." #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Please wait...")
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Ejecting..." #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Ejecting...")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Insert and Click" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Insert and Click")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Loading..." #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Loading...")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Extruding..." #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Extruding...")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Resuming..." #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Resuming...")
#endif #endif
#endif // LANGUAGE_EL_H #endif // LANGUAGE_EL_H

View File

@@ -31,533 +31,592 @@
#define LANGUAGE_EN_H #define LANGUAGE_EN_H
#ifndef WELCOME_MSG #ifndef WELCOME_MSG
#define WELCOME_MSG MACHINE_NAME " ready." #define WELCOME_MSG MACHINE_NAME _UxGT(" ready.")
#endif
#ifndef MSG_BACK
#define MSG_BACK _UxGT("Back")
#endif #endif
#ifndef MSG_SD_INSERTED #ifndef MSG_SD_INSERTED
#define MSG_SD_INSERTED "Card inserted" #define MSG_SD_INSERTED _UxGT("Card inserted")
#endif #endif
#ifndef MSG_SD_REMOVED #ifndef MSG_SD_REMOVED
#define MSG_SD_REMOVED "Card removed" #define MSG_SD_REMOVED _UxGT("Card removed")
#endif #endif
#ifndef MSG_LCD_ENDSTOPS #ifndef MSG_LCD_ENDSTOPS
#define MSG_LCD_ENDSTOPS "Endstops" // Max length 8 characters #define MSG_LCD_ENDSTOPS _UxGT("Endstops") // Max length 8 characters
#endif #endif
#ifndef MSG_MAIN #ifndef MSG_MAIN
#define MSG_MAIN "Main" #define MSG_MAIN _UxGT("Main")
#endif #endif
#ifndef MSG_AUTOSTART #ifndef MSG_AUTOSTART
#define MSG_AUTOSTART "Autostart" #define MSG_AUTOSTART _UxGT("Autostart")
#endif #endif
#ifndef MSG_DISABLE_STEPPERS #ifndef MSG_DISABLE_STEPPERS
#define MSG_DISABLE_STEPPERS "Disable steppers" #define MSG_DISABLE_STEPPERS _UxGT("Disable steppers")
#endif
#ifndef MSG_DEBUG_MENU
#define MSG_DEBUG_MENU _UxGT("Debug Menu")
#endif
#ifndef MSG_PROGRESS_BAR_TEST
#define MSG_PROGRESS_BAR_TEST _UxGT("Progress Bar Test")
#endif #endif
#ifndef MSG_AUTO_HOME #ifndef MSG_AUTO_HOME
#define MSG_AUTO_HOME "Auto home" #define MSG_AUTO_HOME _UxGT("Auto home")
#endif #endif
#ifndef MSG_AUTO_HOME_X #ifndef MSG_AUTO_HOME_X
#define MSG_AUTO_HOME_X "Home X" #define MSG_AUTO_HOME_X _UxGT("Home X")
#endif #endif
#ifndef MSG_AUTO_HOME_Y #ifndef MSG_AUTO_HOME_Y
#define MSG_AUTO_HOME_Y "Home Y" #define MSG_AUTO_HOME_Y _UxGT("Home Y")
#endif #endif
#ifndef MSG_AUTO_HOME_Z #ifndef MSG_AUTO_HOME_Z
#define MSG_AUTO_HOME_Z "Home Z" #define MSG_AUTO_HOME_Z _UxGT("Home Z")
#endif #endif
#ifndef MSG_LEVEL_BED_HOMING #ifndef MSG_LEVEL_BED_HOMING
#define MSG_LEVEL_BED_HOMING "Homing XYZ" #define MSG_LEVEL_BED_HOMING _UxGT("Homing XYZ")
#endif #endif
#ifndef MSG_LEVEL_BED_WAITING #ifndef MSG_LEVEL_BED_WAITING
#define MSG_LEVEL_BED_WAITING "Click to Begin" #define MSG_LEVEL_BED_WAITING _UxGT("Click to Begin")
#endif #endif
#ifndef MSG_LEVEL_BED_NEXT_POINT #ifndef MSG_LEVEL_BED_NEXT_POINT
#define MSG_LEVEL_BED_NEXT_POINT "Next Point" #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Next Point")
#endif #endif
#ifndef MSG_LEVEL_BED_DONE #ifndef MSG_LEVEL_BED_DONE
#define MSG_LEVEL_BED_DONE "Leveling Done!" #define MSG_LEVEL_BED_DONE _UxGT("Leveling Done!")
#endif #endif
#ifndef MSG_LEVEL_BED_CANCEL #ifndef MSG_LEVEL_BED_CANCEL
#define MSG_LEVEL_BED_CANCEL "Cancel" #define MSG_LEVEL_BED_CANCEL _UxGT("Cancel")
#endif #endif
#ifndef MSG_SET_HOME_OFFSETS #ifndef MSG_SET_HOME_OFFSETS
#define MSG_SET_HOME_OFFSETS "Set home offsets" #define MSG_SET_HOME_OFFSETS _UxGT("Set home offsets")
#endif #endif
#ifndef MSG_HOME_OFFSETS_APPLIED #ifndef MSG_HOME_OFFSETS_APPLIED
#define MSG_HOME_OFFSETS_APPLIED "Offsets applied" #define MSG_HOME_OFFSETS_APPLIED _UxGT("Offsets applied")
#endif #endif
#ifndef MSG_SET_ORIGIN #ifndef MSG_SET_ORIGIN
#define MSG_SET_ORIGIN "Set origin" #define MSG_SET_ORIGIN _UxGT("Set origin")
#endif #endif
#ifndef MSG_PREHEAT_1 #ifndef MSG_PREHEAT_1
#define MSG_PREHEAT_1 "Preheat PLA" #define MSG_PREHEAT_1 _UxGT("Preheat PLA")
#endif #endif
#ifndef MSG_PREHEAT_1_N #ifndef MSG_PREHEAT_1_N
#define MSG_PREHEAT_1_N MSG_PREHEAT_1 " " #define MSG_PREHEAT_1_N MSG_PREHEAT_1 _UxGT(" ")
#endif #endif
#ifndef MSG_PREHEAT_1_ALL #ifndef MSG_PREHEAT_1_ALL
#define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 " All" #define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 _UxGT(" All")
#endif
#ifndef MSG_PREHEAT_1_END
#define MSG_PREHEAT_1_END MSG_PREHEAT_1 _UxGT(" End")
#endif #endif
#ifndef MSG_PREHEAT_1_BEDONLY #ifndef MSG_PREHEAT_1_BEDONLY
#define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 " Bed" #define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 _UxGT(" Bed")
#endif #endif
#ifndef MSG_PREHEAT_1_SETTINGS #ifndef MSG_PREHEAT_1_SETTINGS
#define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 " conf" #define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 _UxGT(" conf")
#endif #endif
#ifndef MSG_PREHEAT_2 #ifndef MSG_PREHEAT_2
#define MSG_PREHEAT_2 "Preheat ABS" #define MSG_PREHEAT_2 _UxGT("Preheat ABS")
#endif #endif
#ifndef MSG_PREHEAT_2_N #ifndef MSG_PREHEAT_2_N
#define MSG_PREHEAT_2_N MSG_PREHEAT_2 " " #define MSG_PREHEAT_2_N MSG_PREHEAT_2 _UxGT(" ")
#endif #endif
#ifndef MSG_PREHEAT_2_ALL #ifndef MSG_PREHEAT_2_ALL
#define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 " All" #define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 _UxGT(" All")
#endif
#ifndef MSG_PREHEAT_2_END
#define MSG_PREHEAT_2_END MSG_PREHEAT_2 _UxGT(" End")
#endif #endif
#ifndef MSG_PREHEAT_2_BEDONLY #ifndef MSG_PREHEAT_2_BEDONLY
#define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 " Bed" #define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 _UxGT(" Bed")
#endif #endif
#ifndef MSG_PREHEAT_2_SETTINGS #ifndef MSG_PREHEAT_2_SETTINGS
#define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 " conf" #define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 _UxGT(" conf")
#endif #endif
#ifndef MSG_COOLDOWN #ifndef MSG_COOLDOWN
#define MSG_COOLDOWN "Cooldown" #define MSG_COOLDOWN _UxGT("Cooldown")
#endif #endif
#ifndef MSG_SWITCH_PS_ON #ifndef MSG_SWITCH_PS_ON
#define MSG_SWITCH_PS_ON "Switch power on" #define MSG_SWITCH_PS_ON _UxGT("Switch power on")
#endif #endif
#ifndef MSG_SWITCH_PS_OFF #ifndef MSG_SWITCH_PS_OFF
#define MSG_SWITCH_PS_OFF "Switch power off" #define MSG_SWITCH_PS_OFF _UxGT("Switch power off")
#endif #endif
#ifndef MSG_EXTRUDE #ifndef MSG_EXTRUDE
#define MSG_EXTRUDE "Extrude" #define MSG_EXTRUDE _UxGT("Extrude")
#endif #endif
#ifndef MSG_RETRACT #ifndef MSG_RETRACT
#define MSG_RETRACT "Retract" #define MSG_RETRACT _UxGT("Retract")
#endif #endif
#ifndef MSG_MOVE_AXIS #ifndef MSG_MOVE_AXIS
#define MSG_MOVE_AXIS "Move axis" #define MSG_MOVE_AXIS _UxGT("Move axis")
#endif #endif
#ifndef MSG_LEVEL_BED #ifndef MSG_LEVEL_BED
#define MSG_LEVEL_BED "Level bed" #define MSG_LEVEL_BED _UxGT("Level bed")
#endif
#ifndef MSG_MOVING
#define MSG_MOVING _UxGT("Moving...")
#endif
#ifndef MSG_FREE_XY
#define MSG_FREE_XY _UxGT("Free XY")
#endif #endif
#ifndef MSG_MOVE_X #ifndef MSG_MOVE_X
#define MSG_MOVE_X "Move X" #define MSG_MOVE_X _UxGT("Move X")
#endif #endif
#ifndef MSG_MOVE_Y #ifndef MSG_MOVE_Y
#define MSG_MOVE_Y "Move Y" #define MSG_MOVE_Y _UxGT("Move Y")
#endif #endif
#ifndef MSG_MOVE_Z #ifndef MSG_MOVE_Z
#define MSG_MOVE_Z "Move Z" #define MSG_MOVE_Z _UxGT("Move Z")
#endif #endif
#ifndef MSG_MOVE_E #ifndef MSG_MOVE_E
#define MSG_MOVE_E "Extruder" #define MSG_MOVE_E _UxGT("Extruder")
#endif #endif
#ifndef MSG_MOVE_01MM #ifndef MSG_MOVE_01MM
#define MSG_MOVE_01MM "Move 0.1mm" #define MSG_MOVE_01MM _UxGT("Move 0.1mm")
#endif #endif
#ifndef MSG_MOVE_1MM #ifndef MSG_MOVE_1MM
#define MSG_MOVE_1MM "Move 1mm" #define MSG_MOVE_1MM _UxGT("Move 1mm")
#endif #endif
#ifndef MSG_MOVE_10MM #ifndef MSG_MOVE_10MM
#define MSG_MOVE_10MM "Move 10mm" #define MSG_MOVE_10MM _UxGT("Move 10mm")
#endif #endif
#ifndef MSG_SPEED #ifndef MSG_SPEED
#define MSG_SPEED "Speed" #define MSG_SPEED _UxGT("Speed")
#endif #endif
#ifndef MSG_BED_Z #ifndef MSG_BED_Z
#define MSG_BED_Z "Bed Z" #define MSG_BED_Z _UxGT("Bed Z")
#endif #endif
#ifndef MSG_NOZZLE #ifndef MSG_NOZZLE
#define MSG_NOZZLE "Nozzle" #define MSG_NOZZLE _UxGT("Nozzle")
#endif #endif
#ifndef MSG_BED #ifndef MSG_BED
#define MSG_BED "Bed" #define MSG_BED _UxGT("Bed")
#endif #endif
#ifndef MSG_FAN_SPEED #ifndef MSG_FAN_SPEED
#define MSG_FAN_SPEED "Fan speed" #define MSG_FAN_SPEED _UxGT("Fan speed")
#endif #endif
#ifndef MSG_FLOW #ifndef MSG_FLOW
#define MSG_FLOW "Flow" #define MSG_FLOW _UxGT("Flow")
#endif #endif
#ifndef MSG_CONTROL #ifndef MSG_CONTROL
#define MSG_CONTROL "Control" #define MSG_CONTROL _UxGT("Control")
#endif #endif
#ifndef MSG_MIN #ifndef MSG_MIN
#define MSG_MIN " " LCD_STR_THERMOMETER " Min" #define MSG_MIN _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Min")
#endif #endif
#ifndef MSG_MAX #ifndef MSG_MAX
#define MSG_MAX " " LCD_STR_THERMOMETER " Max" #define MSG_MAX _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Max")
#endif #endif
#ifndef MSG_FACTOR #ifndef MSG_FACTOR
#define MSG_FACTOR " " LCD_STR_THERMOMETER " Fact" #define MSG_FACTOR _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Fact")
#endif #endif
#ifndef MSG_AUTOTEMP #ifndef MSG_AUTOTEMP
#define MSG_AUTOTEMP "Autotemp" #define MSG_AUTOTEMP _UxGT("Autotemp")
#endif #endif
#ifndef MSG_ON #ifndef MSG_ON
#define MSG_ON "On " #define MSG_ON _UxGT("On ")
#endif #endif
#ifndef MSG_OFF #ifndef MSG_OFF
#define MSG_OFF "Off" #define MSG_OFF _UxGT("Off")
#endif #endif
#ifndef MSG_PID_P #ifndef MSG_PID_P
#define MSG_PID_P "PID-P" #define MSG_PID_P _UxGT("PID-P")
#endif #endif
#ifndef MSG_PID_I #ifndef MSG_PID_I
#define MSG_PID_I "PID-I" #define MSG_PID_I _UxGT("PID-I")
#endif #endif
#ifndef MSG_PID_D #ifndef MSG_PID_D
#define MSG_PID_D "PID-D" #define MSG_PID_D _UxGT("PID-D")
#endif #endif
#ifndef MSG_PID_C #ifndef MSG_PID_C
#define MSG_PID_C "PID-C" #define MSG_PID_C _UxGT("PID-C")
#endif #endif
#ifndef MSG_SELECT #ifndef MSG_SELECT
#define MSG_SELECT "Select" #define MSG_SELECT _UxGT("Select")
#endif #endif
#ifndef MSG_ACC #ifndef MSG_ACC
#define MSG_ACC "Accel" #define MSG_ACC _UxGT("Accel")
#endif #endif
#ifndef MSG_VX_JERK #ifndef MSG_VX_JERK
#define MSG_VX_JERK "Vx-jerk" #define MSG_VX_JERK _UxGT("Vx-jerk")
#endif #endif
#ifndef MSG_VY_JERK #ifndef MSG_VY_JERK
#define MSG_VY_JERK "Vy-jerk" #define MSG_VY_JERK _UxGT("Vy-jerk")
#endif #endif
#ifndef MSG_VZ_JERK #ifndef MSG_VZ_JERK
#define MSG_VZ_JERK "Vz-jerk" #define MSG_VZ_JERK _UxGT("Vz-jerk")
#endif #endif
#ifndef MSG_VE_JERK #ifndef MSG_VE_JERK
#define MSG_VE_JERK "Ve-jerk" #define MSG_VE_JERK _UxGT("Ve-jerk")
#endif #endif
#ifndef MSG_VMAX #ifndef MSG_VMAX
#define MSG_VMAX "Vmax " #define MSG_VMAX _UxGT("Vmax ")
#endif #endif
#ifndef MSG_VMIN #ifndef MSG_VMIN
#define MSG_VMIN "Vmin" #define MSG_VMIN _UxGT("Vmin")
#endif #endif
#ifndef MSG_VTRAV_MIN #ifndef MSG_VTRAV_MIN
#define MSG_VTRAV_MIN "VTrav min" #define MSG_VTRAV_MIN _UxGT("VTrav min")
#endif #endif
#ifndef MSG_AMAX #ifndef MSG_AMAX
#define MSG_AMAX "Amax " #define MSG_AMAX _UxGT("Amax ")
#endif #endif
#ifndef MSG_A_RETRACT #ifndef MSG_A_RETRACT
#define MSG_A_RETRACT "A-retract" #define MSG_A_RETRACT _UxGT("A-retract")
#endif #endif
#ifndef MSG_A_TRAVEL #ifndef MSG_A_TRAVEL
#define MSG_A_TRAVEL "A-travel" #define MSG_A_TRAVEL _UxGT("A-travel")
#endif #endif
#ifndef MSG_XSTEPS #ifndef MSG_XSTEPS
#define MSG_XSTEPS "Xsteps/mm" #define MSG_XSTEPS _UxGT("Xsteps/mm")
#endif #endif
#ifndef MSG_YSTEPS #ifndef MSG_YSTEPS
#define MSG_YSTEPS "Ysteps/mm" #define MSG_YSTEPS _UxGT("Ysteps/mm")
#endif #endif
#ifndef MSG_ZSTEPS #ifndef MSG_ZSTEPS
#define MSG_ZSTEPS "Zsteps/mm" #define MSG_ZSTEPS _UxGT("Zsteps/mm")
#endif #endif
#ifndef MSG_ESTEPS #ifndef MSG_ESTEPS
#define MSG_ESTEPS "Esteps/mm" #define MSG_ESTEPS _UxGT("Esteps/mm")
#endif
#ifndef MSG_E1STEPS
#define MSG_E1STEPS _UxGT("E1steps/mm")
#endif
#ifndef MSG_E2STEPS
#define MSG_E2STEPS _UxGT("E2steps/mm")
#endif
#ifndef MSG_E3STEPS
#define MSG_E3STEPS _UxGT("E3steps/mm")
#endif
#ifndef MSG_E4STEPS
#define MSG_E4STEPS _UxGT("E4steps/mm")
#endif
#ifndef MSG_E5STEPS
#define MSG_E5STEPS _UxGT("E5steps/mm")
#endif #endif
#ifndef MSG_TEMPERATURE #ifndef MSG_TEMPERATURE
#define MSG_TEMPERATURE "Temperature" #define MSG_TEMPERATURE _UxGT("Temperature")
#endif #endif
#ifndef MSG_MOTION #ifndef MSG_MOTION
#define MSG_MOTION "Motion" #define MSG_MOTION _UxGT("Motion")
#endif #endif
#ifndef MSG_VOLUMETRIC #ifndef MSG_FILAMENT
#define MSG_VOLUMETRIC "Filament" #define MSG_FILAMENT _UxGT("Filament")
#endif #endif
#ifndef MSG_VOLUMETRIC_ENABLED #ifndef MSG_VOLUMETRIC_ENABLED
#define MSG_VOLUMETRIC_ENABLED "E in mm3" #define MSG_VOLUMETRIC_ENABLED _UxGT("E in mm3")
#endif #endif
#ifndef MSG_FILAMENT_DIAM #ifndef MSG_FILAMENT_DIAM
#define MSG_FILAMENT_DIAM "Fil. Dia." #define MSG_FILAMENT_DIAM _UxGT("Fil. Dia.")
#endif
#ifndef MSG_ADVANCE_K
#define MSG_ADVANCE_K _UxGT("Advance K")
#endif #endif
#ifndef MSG_CONTRAST #ifndef MSG_CONTRAST
#define MSG_CONTRAST "LCD contrast" #define MSG_CONTRAST _UxGT("LCD contrast")
#endif #endif
#ifndef MSG_STORE_EPROM #ifndef MSG_STORE_EEPROM
#define MSG_STORE_EPROM "Store memory" #define MSG_STORE_EEPROM _UxGT("Store memory")
#endif #endif
#ifndef MSG_LOAD_EPROM #ifndef MSG_LOAD_EEPROM
#define MSG_LOAD_EPROM "Load memory" #define MSG_LOAD_EEPROM _UxGT("Load memory")
#endif #endif
#ifndef MSG_RESTORE_FAILSAFE #ifndef MSG_RESTORE_FAILSAFE
#define MSG_RESTORE_FAILSAFE "Restore failsafe" #define MSG_RESTORE_FAILSAFE _UxGT("Restore failsafe")
#endif #endif
#ifndef MSG_REFRESH #ifndef MSG_REFRESH
#define MSG_REFRESH "Refresh" #define MSG_REFRESH _UxGT("Refresh")
#endif #endif
#ifndef MSG_WATCH #ifndef MSG_WATCH
#define MSG_WATCH "Info screen" #define MSG_WATCH _UxGT("Info screen")
#endif #endif
#ifndef MSG_PREPARE #ifndef MSG_PREPARE
#define MSG_PREPARE "Prepare" #define MSG_PREPARE _UxGT("Prepare")
#endif #endif
#ifndef MSG_TUNE #ifndef MSG_TUNE
#define MSG_TUNE "Tune" #define MSG_TUNE _UxGT("Tune")
#endif #endif
#ifndef MSG_PAUSE_PRINT #ifndef MSG_PAUSE_PRINT
#define MSG_PAUSE_PRINT "Pause print" #define MSG_PAUSE_PRINT _UxGT("Pause print")
#endif #endif
#ifndef MSG_RESUME_PRINT #ifndef MSG_RESUME_PRINT
#define MSG_RESUME_PRINT "Resume print" #define MSG_RESUME_PRINT _UxGT("Resume print")
#endif #endif
#ifndef MSG_STOP_PRINT #ifndef MSG_STOP_PRINT
#define MSG_STOP_PRINT "Stop print" #define MSG_STOP_PRINT _UxGT("Stop print")
#endif #endif
#ifndef MSG_CARD_MENU #ifndef MSG_CARD_MENU
#define MSG_CARD_MENU "Print from SD" #define MSG_CARD_MENU _UxGT("Print from SD")
#endif #endif
#ifndef MSG_NO_CARD #ifndef MSG_NO_CARD
#define MSG_NO_CARD "No SD card" #define MSG_NO_CARD _UxGT("No SD card")
#endif #endif
#ifndef MSG_DWELL #ifndef MSG_DWELL
#define MSG_DWELL "Sleep..." #define MSG_DWELL _UxGT("Sleep...")
#endif #endif
#ifndef MSG_USERWAIT #ifndef MSG_USERWAIT
#define MSG_USERWAIT "Wait for user..." #define MSG_USERWAIT _UxGT("Click to resume...")
#endif #endif
#ifndef MSG_RESUMING #ifndef MSG_RESUMING
#define MSG_RESUMING "Resuming print" #define MSG_RESUMING _UxGT("Resuming print")
#endif #endif
#ifndef MSG_PRINT_ABORTED #ifndef MSG_PRINT_ABORTED
#define MSG_PRINT_ABORTED "Print aborted" #define MSG_PRINT_ABORTED _UxGT("Print aborted")
#endif #endif
#ifndef MSG_NO_MOVE #ifndef MSG_NO_MOVE
#define MSG_NO_MOVE "No move." #define MSG_NO_MOVE _UxGT("No move.")
#endif #endif
#ifndef MSG_KILLED #ifndef MSG_KILLED
#define MSG_KILLED "KILLED. " #define MSG_KILLED _UxGT("KILLED. ")
#endif #endif
#ifndef MSG_STOPPED #ifndef MSG_STOPPED
#define MSG_STOPPED "STOPPED. " #define MSG_STOPPED _UxGT("STOPPED. ")
#endif #endif
#ifndef MSG_CONTROL_RETRACT #ifndef MSG_CONTROL_RETRACT
#define MSG_CONTROL_RETRACT "Retract mm" #define MSG_CONTROL_RETRACT _UxGT("Retract mm")
#endif #endif
#ifndef MSG_CONTROL_RETRACT_SWAP #ifndef MSG_CONTROL_RETRACT_SWAP
#define MSG_CONTROL_RETRACT_SWAP "Swap Re.mm" #define MSG_CONTROL_RETRACT_SWAP _UxGT("Swap Re.mm")
#endif #endif
#ifndef MSG_CONTROL_RETRACTF #ifndef MSG_CONTROL_RETRACTF
#define MSG_CONTROL_RETRACTF "Retract V" #define MSG_CONTROL_RETRACTF _UxGT("Retract V")
#endif #endif
#ifndef MSG_CONTROL_RETRACT_ZLIFT #ifndef MSG_CONTROL_RETRACT_ZLIFT
#define MSG_CONTROL_RETRACT_ZLIFT "Hop mm" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Hop mm")
#endif #endif
#ifndef MSG_CONTROL_RETRACT_RECOVER #ifndef MSG_CONTROL_RETRACT_RECOVER
#define MSG_CONTROL_RETRACT_RECOVER "UnRet +mm" #define MSG_CONTROL_RETRACT_RECOVER _UxGT("UnRet mm")
#endif #endif
#ifndef MSG_CONTROL_RETRACT_RECOVER_SWAP #ifndef MSG_CONTROL_RETRACT_RECOVER_SWAP
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "S UnRet+mm" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("S UnRet mm")
#endif #endif
#ifndef MSG_CONTROL_RETRACT_RECOVERF #ifndef MSG_CONTROL_RETRACT_RECOVERF
#define MSG_CONTROL_RETRACT_RECOVERF "UnRet V" #define MSG_CONTROL_RETRACT_RECOVERF _UxGT("UnRet V")
#endif #endif
#ifndef MSG_AUTORETRACT #ifndef MSG_AUTORETRACT
#define MSG_AUTORETRACT "AutoRetr." #define MSG_AUTORETRACT _UxGT("AutoRetr.")
#endif #endif
#ifndef MSG_FILAMENTCHANGE #ifndef MSG_FILAMENTCHANGE
#define MSG_FILAMENTCHANGE "Change filament" #define MSG_FILAMENTCHANGE _UxGT("Change filament")
#endif #endif
#ifndef MSG_INIT_SDCARD #ifndef MSG_INIT_SDCARD
#define MSG_INIT_SDCARD "Init. SD card" #define MSG_INIT_SDCARD _UxGT("Init. SD card")
#endif #endif
#ifndef MSG_CNG_SDCARD #ifndef MSG_CNG_SDCARD
#define MSG_CNG_SDCARD "Change SD card" #define MSG_CNG_SDCARD _UxGT("Change SD card")
#endif #endif
#ifndef MSG_ZPROBE_OUT #ifndef MSG_ZPROBE_OUT
#define MSG_ZPROBE_OUT "Z probe out. bed" #define MSG_ZPROBE_OUT _UxGT("Z probe out. bed")
#endif
#ifndef MSG_BLTOUCH
#define MSG_BLTOUCH _UxGT("BLTouch")
#endif #endif
#ifndef MSG_BLTOUCH_SELFTEST #ifndef MSG_BLTOUCH_SELFTEST
#define MSG_BLTOUCH_SELFTEST "BLTouch Self-Test" #define MSG_BLTOUCH_SELFTEST _UxGT("BLTouch Self-Test")
#endif #endif
#ifndef MSG_BLTOUCH_RESET #ifndef MSG_BLTOUCH_RESET
#define MSG_BLTOUCH_RESET "Reset BLTouch" #define MSG_BLTOUCH_RESET _UxGT("Reset BLTouch")
#endif
#ifndef MSG_BLTOUCH_DEPLOY
#define MSG_BLTOUCH_DEPLOY _UxGT("Deploy BLTouch")
#endif
#ifndef MSG_BLTOUCH_STOW
#define MSG_BLTOUCH_STOW _UxGT("Stow BLTouch")
#endif #endif
#ifndef MSG_HOME #ifndef MSG_HOME
#define MSG_HOME "Home" // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST #define MSG_HOME _UxGT("Home") // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#endif #endif
#ifndef MSG_FIRST #ifndef MSG_FIRST
#define MSG_FIRST "first" #define MSG_FIRST _UxGT("first")
#endif #endif
#ifndef MSG_ZPROBE_ZOFFSET #ifndef MSG_ZPROBE_ZOFFSET
#define MSG_ZPROBE_ZOFFSET "Z Offset" #define MSG_ZPROBE_ZOFFSET _UxGT("Z Offset")
#endif #endif
#ifndef MSG_BABYSTEP_X #ifndef MSG_BABYSTEP_X
#define MSG_BABYSTEP_X "Babystep X" #define MSG_BABYSTEP_X _UxGT("Babystep X")
#endif #endif
#ifndef MSG_BABYSTEP_Y #ifndef MSG_BABYSTEP_Y
#define MSG_BABYSTEP_Y "Babystep Y" #define MSG_BABYSTEP_Y _UxGT("Babystep Y")
#endif #endif
#ifndef MSG_BABYSTEP_Z #ifndef MSG_BABYSTEP_Z
#define MSG_BABYSTEP_Z "Babystep Z" #define MSG_BABYSTEP_Z _UxGT("Babystep Z")
#endif #endif
#ifndef MSG_ENDSTOP_ABORT #ifndef MSG_ENDSTOP_ABORT
#define MSG_ENDSTOP_ABORT "Endstop abort" #define MSG_ENDSTOP_ABORT _UxGT("Endstop abort")
#endif #endif
#ifndef MSG_HEATING_FAILED_LCD #ifndef MSG_HEATING_FAILED_LCD
#define MSG_HEATING_FAILED_LCD "Heating failed" #define MSG_HEATING_FAILED_LCD _UxGT("Heating failed")
#endif #endif
#ifndef MSG_ERR_REDUNDANT_TEMP #ifndef MSG_ERR_REDUNDANT_TEMP
#define MSG_ERR_REDUNDANT_TEMP "Err: REDUNDANT TEMP" #define MSG_ERR_REDUNDANT_TEMP _UxGT("Err: REDUNDANT TEMP")
#endif #endif
#ifndef MSG_THERMAL_RUNAWAY #ifndef MSG_THERMAL_RUNAWAY
#define MSG_THERMAL_RUNAWAY "THERMAL RUNAWAY" #define MSG_THERMAL_RUNAWAY _UxGT("THERMAL RUNAWAY")
#endif #endif
#ifndef MSG_ERR_MAXTEMP #ifndef MSG_ERR_MAXTEMP
#define MSG_ERR_MAXTEMP "Err: MAXTEMP" #define MSG_ERR_MAXTEMP _UxGT("Err: MAXTEMP")
#endif #endif
#ifndef MSG_ERR_MINTEMP #ifndef MSG_ERR_MINTEMP
#define MSG_ERR_MINTEMP "Err: MINTEMP" #define MSG_ERR_MINTEMP _UxGT("Err: MINTEMP")
#endif #endif
#ifndef MSG_ERR_MAXTEMP_BED #ifndef MSG_ERR_MAXTEMP_BED
#define MSG_ERR_MAXTEMP_BED "Err: MAXTEMP BED" #define MSG_ERR_MAXTEMP_BED _UxGT("Err: MAXTEMP BED")
#endif #endif
#ifndef MSG_ERR_MINTEMP_BED #ifndef MSG_ERR_MINTEMP_BED
#define MSG_ERR_MINTEMP_BED "Err: MINTEMP BED" #define MSG_ERR_MINTEMP_BED _UxGT("Err: MINTEMP BED")
#endif #endif
#ifndef MSG_ERR_Z_HOMING #ifndef MSG_ERR_Z_HOMING
#define MSG_ERR_Z_HOMING "G28 Z Forbidden" #define MSG_ERR_Z_HOMING _UxGT("G28 Z Forbidden")
#endif #endif
#ifndef MSG_HALTED #ifndef MSG_HALTED
#define MSG_HALTED "PRINTER HALTED" #define MSG_HALTED _UxGT("PRINTER HALTED")
#endif #endif
#ifndef MSG_PLEASE_RESET #ifndef MSG_PLEASE_RESET
#define MSG_PLEASE_RESET "Please reset" #define MSG_PLEASE_RESET _UxGT("Please reset")
#endif #endif
#ifndef MSG_SHORT_DAY #ifndef MSG_SHORT_DAY
#define MSG_SHORT_DAY "d" // One character only #define MSG_SHORT_DAY _UxGT("d") // One character only
#endif #endif
#ifndef MSG_SHORT_HOUR #ifndef MSG_SHORT_HOUR
#define MSG_SHORT_HOUR "h" // One character only #define MSG_SHORT_HOUR _UxGT("h") // One character only
#endif #endif
#ifndef MSG_SHORT_MINUTE #ifndef MSG_SHORT_MINUTE
#define MSG_SHORT_MINUTE "m" // One character only #define MSG_SHORT_MINUTE _UxGT("m") // One character only
#endif #endif
#ifndef MSG_HEATING #ifndef MSG_HEATING
#define MSG_HEATING "Heating..." #define MSG_HEATING _UxGT("Heating...")
#endif #endif
#ifndef MSG_HEATING_COMPLETE #ifndef MSG_HEATING_COMPLETE
#define MSG_HEATING_COMPLETE "Heating done." #define MSG_HEATING_COMPLETE _UxGT("Heating done.")
#endif #endif
#ifndef MSG_BED_HEATING #ifndef MSG_BED_HEATING
#define MSG_BED_HEATING "Bed Heating." #define MSG_BED_HEATING _UxGT("Bed Heating.")
#endif #endif
#ifndef MSG_BED_DONE #ifndef MSG_BED_DONE
#define MSG_BED_DONE "Bed done." #define MSG_BED_DONE _UxGT("Bed done.")
#endif #endif
#ifndef MSG_DELTA_CALIBRATE #ifndef MSG_DELTA_CALIBRATE
#define MSG_DELTA_CALIBRATE "Delta Calibration" #define MSG_DELTA_CALIBRATE _UxGT("Delta Calibration")
#endif #endif
#ifndef MSG_DELTA_CALIBRATE_X #ifndef MSG_DELTA_CALIBRATE_X
#define MSG_DELTA_CALIBRATE_X "Calibrate X" #define MSG_DELTA_CALIBRATE_X _UxGT("Calibrate X")
#endif #endif
#ifndef MSG_DELTA_CALIBRATE_Y #ifndef MSG_DELTA_CALIBRATE_Y
#define MSG_DELTA_CALIBRATE_Y "Calibrate Y" #define MSG_DELTA_CALIBRATE_Y _UxGT("Calibrate Y")
#endif #endif
#ifndef MSG_DELTA_CALIBRATE_Z #ifndef MSG_DELTA_CALIBRATE_Z
#define MSG_DELTA_CALIBRATE_Z "Calibrate Z" #define MSG_DELTA_CALIBRATE_Z _UxGT("Calibrate Z")
#endif #endif
#ifndef MSG_DELTA_CALIBRATE_CENTER #ifndef MSG_DELTA_CALIBRATE_CENTER
#define MSG_DELTA_CALIBRATE_CENTER "Calibrate Center" #define MSG_DELTA_CALIBRATE_CENTER _UxGT("Calibrate Center")
#endif
#ifndef MSG_DELTA_AUTO_CALIBRATE
#define MSG_DELTA_AUTO_CALIBRATE _UxGT("Auto Calibration")
#endif
#ifndef MSG_DELTA_HEIGHT_CALIBRATE
#define MSG_DELTA_HEIGHT_CALIBRATE _UxGT("Set Delta Height")
#endif #endif
#ifndef MSG_INFO_MENU #ifndef MSG_INFO_MENU
#define MSG_INFO_MENU "About Printer" #define MSG_INFO_MENU _UxGT("About Printer")
#endif #endif
#ifndef MSG_INFO_PRINTER_MENU #ifndef MSG_INFO_PRINTER_MENU
#define MSG_INFO_PRINTER_MENU "Printer Info" #define MSG_INFO_PRINTER_MENU _UxGT("Printer Info")
#endif #endif
#ifndef MSG_INFO_STATS_MENU #ifndef MSG_INFO_STATS_MENU
#define MSG_INFO_STATS_MENU "Printer Stats" #define MSG_INFO_STATS_MENU _UxGT("Printer Stats")
#endif #endif
#ifndef MSG_INFO_BOARD_MENU #ifndef MSG_INFO_BOARD_MENU
#define MSG_INFO_BOARD_MENU "Board Info" #define MSG_INFO_BOARD_MENU _UxGT("Board Info")
#endif #endif
#ifndef MSG_INFO_THERMISTOR_MENU #ifndef MSG_INFO_THERMISTOR_MENU
#define MSG_INFO_THERMISTOR_MENU "Thermistors" #define MSG_INFO_THERMISTOR_MENU _UxGT("Thermistors")
#endif #endif
#ifndef MSG_INFO_EXTRUDERS #ifndef MSG_INFO_EXTRUDERS
#define MSG_INFO_EXTRUDERS "Extruders" #define MSG_INFO_EXTRUDERS _UxGT("Extruders")
#endif #endif
#ifndef MSG_INFO_BAUDRATE #ifndef MSG_INFO_BAUDRATE
#define MSG_INFO_BAUDRATE "Baud" #define MSG_INFO_BAUDRATE _UxGT("Baud")
#endif #endif
#ifndef MSG_INFO_PROTOCOL #ifndef MSG_INFO_PROTOCOL
#define MSG_INFO_PROTOCOL "Protocol" #define MSG_INFO_PROTOCOL _UxGT("Protocol")
#endif #endif
#ifndef MSG_LIGHTS_ON #ifndef MSG_LIGHTS_ON
#define MSG_LIGHTS_ON "Case light on" #define MSG_LIGHTS_ON _UxGT("Case light on")
#endif #endif
#ifndef MSG_LIGHTS_OFF #ifndef MSG_LIGHTS_OFF
#define MSG_LIGHTS_OFF "Case light off" #define MSG_LIGHTS_OFF _UxGT("Case light off")
#endif #endif
#if LCD_WIDTH >= 20 #if LCD_WIDTH >= 20
#ifndef MSG_INFO_PRINT_COUNT #ifndef MSG_INFO_PRINT_COUNT
#define MSG_INFO_PRINT_COUNT "Print Count" #define MSG_INFO_PRINT_COUNT _UxGT("Print Count")
#endif #endif
#ifndef MSG_INFO_COMPLETED_PRINTS #ifndef MSG_INFO_COMPLETED_PRINTS
#define MSG_INFO_COMPLETED_PRINTS "Completed" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Completed")
#endif #endif
#ifndef MSG_INFO_PRINT_TIME #ifndef MSG_INFO_PRINT_TIME
#define MSG_INFO_PRINT_TIME "Total print time" #define MSG_INFO_PRINT_TIME _UxGT("Total print time")
#endif #endif
#ifndef MSG_INFO_PRINT_LONGEST #ifndef MSG_INFO_PRINT_LONGEST
#define MSG_INFO_PRINT_LONGEST "Longest job time" #define MSG_INFO_PRINT_LONGEST _UxGT("Longest job time")
#endif #endif
#ifndef MSG_INFO_PRINT_FILAMENT #ifndef MSG_INFO_PRINT_FILAMENT
#define MSG_INFO_PRINT_FILAMENT "Extruded total" #define MSG_INFO_PRINT_FILAMENT _UxGT("Extruded total")
#endif #endif
#else #else
#ifndef MSG_INFO_PRINT_COUNT #ifndef MSG_INFO_PRINT_COUNT
#define MSG_INFO_PRINT_COUNT "Prints" #define MSG_INFO_PRINT_COUNT _UxGT("Prints")
#endif #endif
#ifndef MSG_INFO_COMPLETED_PRINTS #ifndef MSG_INFO_COMPLETED_PRINTS
#define MSG_INFO_COMPLETED_PRINTS "Completed" #define MSG_INFO_COMPLETED_PRINTS _UxGT("Completed")
#endif #endif
#ifndef MSG_INFO_PRINT_TIME #ifndef MSG_INFO_PRINT_TIME
#define MSG_INFO_PRINT_TIME "Total" #define MSG_INFO_PRINT_TIME _UxGT("Total")
#endif #endif
#ifndef MSG_INFO_PRINT_LONGEST #ifndef MSG_INFO_PRINT_LONGEST
#define MSG_INFO_PRINT_LONGEST "Longest" #define MSG_INFO_PRINT_LONGEST _UxGT("Longest")
#endif #endif
#ifndef MSG_INFO_PRINT_FILAMENT #ifndef MSG_INFO_PRINT_FILAMENT
#define MSG_INFO_PRINT_FILAMENT "Extruded" #define MSG_INFO_PRINT_FILAMENT _UxGT("Extruded")
#endif #endif
#endif #endif
#ifndef MSG_INFO_MIN_TEMP #ifndef MSG_INFO_MIN_TEMP
#define MSG_INFO_MIN_TEMP "Min Temp" #define MSG_INFO_MIN_TEMP _UxGT("Min Temp")
#endif #endif
#ifndef MSG_INFO_MAX_TEMP #ifndef MSG_INFO_MAX_TEMP
#define MSG_INFO_MAX_TEMP "Max Temp" #define MSG_INFO_MAX_TEMP _UxGT("Max Temp")
#endif #endif
#ifndef MSG_INFO_PSU #ifndef MSG_INFO_PSU
#define MSG_INFO_PSU "Power Supply" #define MSG_INFO_PSU _UxGT("Power Supply")
#endif #endif
#ifndef MSG_DRIVE_STRENGTH #ifndef MSG_DRIVE_STRENGTH
#define MSG_DRIVE_STRENGTH "Drive Strength" #define MSG_DRIVE_STRENGTH _UxGT("Drive Strength")
#endif #endif
#ifndef MSG_DAC_PERCENT #ifndef MSG_DAC_PERCENT
#define MSG_DAC_PERCENT "Driver %" #define MSG_DAC_PERCENT _UxGT("Driver %")
#endif #endif
#ifndef MSG_DAC_EEPROM_WRITE #ifndef MSG_DAC_EEPROM_WRITE
#define MSG_DAC_EEPROM_WRITE "DAC EEPROM Write" #define MSG_DAC_EEPROM_WRITE _UxGT("DAC EEPROM Write")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_HEADER #ifndef MSG_FILAMENT_CHANGE_HEADER
#define MSG_FILAMENT_CHANGE_HEADER "CHANGE FILAMENT" #define MSG_FILAMENT_CHANGE_HEADER _UxGT("CHANGE FILAMENT")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_OPTION_HEADER #ifndef MSG_FILAMENT_CHANGE_OPTION_HEADER
#define MSG_FILAMENT_CHANGE_OPTION_HEADER "CHANGE OPTIONS:" #define MSG_FILAMENT_CHANGE_OPTION_HEADER _UxGT("CHANGE OPTIONS:")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_OPTION_EXTRUDE #ifndef MSG_FILAMENT_CHANGE_OPTION_EXTRUDE
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE "Extrude more" #define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Extrude more")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_OPTION_RESUME #ifndef MSG_FILAMENT_CHANGE_OPTION_RESUME
#define MSG_FILAMENT_CHANGE_OPTION_RESUME "Resume print" #define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Resume print")
#endif
#ifndef MSG_FILAMENT_CHANGE_MINTEMP
#define MSG_FILAMENT_CHANGE_MINTEMP _UxGT("Minimum Temp is ")
#endif
#ifndef MSG_FILAMENT_CHANGE_NOZZLE
#define MSG_FILAMENT_CHANGE_NOZZLE _UxGT(" Nozzle: ")
#endif #endif
// //
@@ -566,49 +625,60 @@
// //
#if LCD_HEIGHT >= 4 #if LCD_HEIGHT >= 4
#ifndef MSG_FILAMENT_CHANGE_INIT_1 #ifndef MSG_FILAMENT_CHANGE_INIT_1
#define MSG_FILAMENT_CHANGE_INIT_1 "Wait for start" #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Wait for start")
#define MSG_FILAMENT_CHANGE_INIT_2 "of the filament" #define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("of the filament")
#define MSG_FILAMENT_CHANGE_INIT_3 "change" #define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("change")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_UNLOAD_1 #ifndef MSG_FILAMENT_CHANGE_UNLOAD_1
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Wait for" #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 "filament unload" #define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("filament unload")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_INSERT_1 #ifndef MSG_FILAMENT_CHANGE_INSERT_1
#define MSG_FILAMENT_CHANGE_INSERT_1 "Insert filament" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Insert filament")
#define MSG_FILAMENT_CHANGE_INSERT_2 "and press button" #define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("and press button")
#define MSG_FILAMENT_CHANGE_INSERT_3 "to continue..." #define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("to continue...")
#endif
#ifndef MSG_FILAMENT_CHANGE_HEAT_1
#define MSG_FILAMENT_CHANGE_HEAT_1 _UxGT("Press button to")
#define MSG_FILAMENT_CHANGE_HEAT_2 _UxGT("heat nozzle.")
#endif
#ifndef MSG_FILAMENT_CHANGE_HEATING_1
#define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Heating nozzle")
#define MSG_FILAMENT_CHANGE_HEATING_2 _UxGT("Please wait...")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_LOAD_1 #ifndef MSG_FILAMENT_CHANGE_LOAD_1
#define MSG_FILAMENT_CHANGE_LOAD_1 "Wait for" #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_LOAD_2 "filament load" #define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("filament load")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_EXTRUDE_1 #ifndef MSG_FILAMENT_CHANGE_EXTRUDE_1
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Wait for" #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Wait for")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 "filament extrude" #define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("filament extrude")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_RESUME_1 #ifndef MSG_FILAMENT_CHANGE_RESUME_1
#define MSG_FILAMENT_CHANGE_RESUME_1 "Wait for print" #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Wait for print")
#define MSG_FILAMENT_CHANGE_RESUME_2 "to resume" #define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("to resume")
#endif #endif
#else // LCD_HEIGHT < 4 #else // LCD_HEIGHT < 4
#ifndef MSG_FILAMENT_CHANGE_INIT_1 #ifndef MSG_FILAMENT_CHANGE_INIT_1
#define MSG_FILAMENT_CHANGE_INIT_1 "Please wait..." #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Please wait...")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_UNLOAD_1 #ifndef MSG_FILAMENT_CHANGE_UNLOAD_1
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Ejecting..." #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Ejecting...")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_INSERT_1 #ifndef MSG_FILAMENT_CHANGE_INSERT_1
#define MSG_FILAMENT_CHANGE_INSERT_1 "Insert and Click" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Insert and Click")
#endif
#ifndef MSG_FILAMENT_CHANGE_HEATING_1
#define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Heating...")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_LOAD_1 #ifndef MSG_FILAMENT_CHANGE_LOAD_1
#define MSG_FILAMENT_CHANGE_LOAD_1 "Loading..." #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Loading...")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_EXTRUDE_1 #ifndef MSG_FILAMENT_CHANGE_EXTRUDE_1
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Extruding..." #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Extruding...")
#endif #endif
#ifndef MSG_FILAMENT_CHANGE_RESUME_1 #ifndef MSG_FILAMENT_CHANGE_RESUME_1
#define MSG_FILAMENT_CHANGE_RESUME_1 "Resuming..." #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Resuming...")
#endif #endif
#endif // LCD_HEIGHT < 4 #endif // LCD_HEIGHT < 4

View File

@@ -32,190 +32,228 @@
#define DISPLAY_CHARSET_ISO10646_1 #define DISPLAY_CHARSET_ISO10646_1
#define WELCOME_MSG MACHINE_NAME " lista." #define WELCOME_MSG MACHINE_NAME _UxGT(" lista.")
#define MSG_SD_INSERTED "Tarjeta colocada" #define MSG_BACK _UxGT("Atras")
#define MSG_SD_REMOVED "Tarjeta retirada" #define MSG_SD_INSERTED _UxGT("Tarjeta colocada")
#define MSG_LCD_ENDSTOPS "Endstops" // Max length 8 characters #define MSG_SD_REMOVED _UxGT("Tarjeta retirada")
#define MSG_MAIN "Menu principal" #define MSG_LCD_ENDSTOPS _UxGT("Endstops") // Max length 8 characters
#define MSG_AUTOSTART "Inicio automatico" #define MSG_MAIN _UxGT("Menu principal")
#define MSG_DISABLE_STEPPERS "Apagar motores" #define MSG_AUTOSTART _UxGT("Inicio automatico")
#define MSG_AUTO_HOME "Llevar al origen" #define MSG_DISABLE_STEPPERS _UxGT("Apagar motores")
#define MSG_AUTO_HOME_X "Origen X" #define MSG_DEBUG_MENU _UxGT("Menu depurar")
#define MSG_AUTO_HOME_Y "Origen Y" #define MSG_PROGRESS_BAR_TEST _UxGT("Prueba barra avance")
#define MSG_AUTO_HOME_Z "Origen Z" #define MSG_AUTO_HOME _UxGT("Llevar al origen")
#define MSG_LEVEL_BED_HOMING "Origen XYZ" #define MSG_AUTO_HOME_X _UxGT("Origen X")
#define MSG_LEVEL_BED_WAITING "Iniciar (Presione)" #define MSG_AUTO_HOME_Y _UxGT("Origen Y")
#define MSG_LEVEL_BED_DONE "Nivelacion lista!" #define MSG_AUTO_HOME_Z _UxGT("Origen Z")
#define MSG_LEVEL_BED_CANCEL "Cancelar" #define MSG_LEVEL_BED_HOMING _UxGT("Origen XYZ")
#define MSG_SET_HOME_OFFSETS "Ajustar desfases" #define MSG_LEVEL_BED_WAITING _UxGT("Iniciar (Presione)")
#define MSG_HOME_OFFSETS_APPLIED "Desfase aplicado" #define MSG_LEVEL_BED_NEXT_POINT _UxGT("Siguiente punto")
#define MSG_SET_ORIGIN "Establecer origen" #define MSG_LEVEL_BED_DONE _UxGT("Nivelacion lista!")
#define MSG_PREHEAT_1 "Precalentar PLA" #define MSG_LEVEL_BED_CANCEL _UxGT("Cancelar")
#define MSG_PREHEAT_1_N MSG_PREHEAT_1 " " #define MSG_SET_HOME_OFFSETS _UxGT("Ajustar desfases")
#define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 "Todo" #define MSG_HOME_OFFSETS_APPLIED _UxGT("Desfase aplicado")
#define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1"Plataforma" #define MSG_SET_ORIGIN _UxGT("Establecer origen")
#define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 "Config" #define MSG_PREHEAT_1 _UxGT("Precalentar PLA")
#define MSG_PREHEAT_2 "Precalentar ABS" #define MSG_PREHEAT_1_N MSG_PREHEAT_1 _UxGT(" ")
#define MSG_PREHEAT_2_N MSG_PREHEAT_2 " " #define MSG_PREHEAT_1_ALL MSG_PREHEAT_1 _UxGT("Todo")
#define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 "Todo" #define MSG_PREHEAT_1_END MSG_PREHEAT_1 _UxGT(" End")
#define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 "Plataforma" #define MSG_PREHEAT_1_BEDONLY MSG_PREHEAT_1 _UxGT("Plataforma")
#define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 "Config" #define MSG_PREHEAT_1_SETTINGS MSG_PREHEAT_1 _UxGT("Config")
#define MSG_COOLDOWN "Enfriar" #define MSG_PREHEAT_2 _UxGT("Precalentar ABS")
#define MSG_SWITCH_PS_ON "Encender" #define MSG_PREHEAT_2_N MSG_PREHEAT_2 _UxGT(" ")
#define MSG_SWITCH_PS_OFF "Apagar" #define MSG_PREHEAT_2_ALL MSG_PREHEAT_2 _UxGT("Todo")
#define MSG_EXTRUDE "Extruir" #define MSG_PREHEAT_2_END MSG_PREHEAT_2 _UxGT(" End")
#define MSG_RETRACT "Retraer" #define MSG_PREHEAT_2_BEDONLY MSG_PREHEAT_2 _UxGT("Plataforma")
#define MSG_MOVE_AXIS "Mover ejes" #define MSG_PREHEAT_2_SETTINGS MSG_PREHEAT_2 _UxGT("Config")
#define MSG_LEVEL_BED "Nivelar plataforma" #define MSG_COOLDOWN _UxGT("Enfriar")
#define MSG_MOVE_X "Mover X" #define MSG_SWITCH_PS_ON _UxGT("Encender")
#define MSG_MOVE_Y "Mover Y" #define MSG_SWITCH_PS_OFF _UxGT("Apagar")
#define MSG_MOVE_Z "Mover Z" #define MSG_EXTRUDE _UxGT("Extruir")
#define MSG_MOVE_E "Extrusor" #define MSG_RETRACT _UxGT("Retraer")
#define MSG_MOVE_01MM "Mover 0.1mm" #define MSG_MOVE_AXIS _UxGT("Mover ejes")
#define MSG_MOVE_1MM "Mover 1mm" #define MSG_LEVEL_BED _UxGT("Nivelar plataforma")
#define MSG_MOVE_10MM "Mover 10mm" #define MSG_MOVING _UxGT("Moviendo...")
#define MSG_SPEED "Velocidad" #define MSG_FREE_XY _UxGT("Libre XY")
#define MSG_BED_Z "Plataforma Z" #define MSG_MOVE_X _UxGT("Mover X")
#define MSG_NOZZLE "Boquilla" #define MSG_MOVE_Y _UxGT("Mover Y")
#define MSG_BED "Plataforma" #define MSG_MOVE_Z _UxGT("Mover Z")
#define MSG_FAN_SPEED "Ventilador" #define MSG_MOVE_E _UxGT("Extrusor")
#define MSG_FLOW "Flujo" #define MSG_MOVE_01MM _UxGT("Mover 0.1mm")
#define MSG_CONTROL "Control" #define MSG_MOVE_1MM _UxGT("Mover 1mm")
#define MSG_MIN LCD_STR_THERMOMETER " Min" #define MSG_MOVE_10MM _UxGT("Mover 10mm")
#define MSG_MAX LCD_STR_THERMOMETER " Max" #define MSG_SPEED _UxGT("Velocidad")
#define MSG_FACTOR LCD_STR_THERMOMETER " Fact" #define MSG_BED_Z _UxGT("Plataforma Z")
#define MSG_AUTOTEMP "Temperatura Auto." #define MSG_NOZZLE _UxGT("Boquilla")
#define MSG_ON "Encender" #define MSG_BED _UxGT("Plataforma")
#define MSG_OFF "Apagar" #define MSG_FAN_SPEED _UxGT("Ventilador")
#define MSG_PID_P "PID-P" #define MSG_FLOW _UxGT("Flujo")
#define MSG_PID_I "PID-I" #define MSG_CONTROL _UxGT("Control")
#define MSG_PID_D "PID-D" #define MSG_MIN _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Min")
#define MSG_PID_C "PID-C" #define MSG_MAX _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Max")
#define MSG_ACC "Aceleracion" #define MSG_FACTOR _UxGT(" ") LCD_STR_THERMOMETER _UxGT(" Fact")
#define MSG_VX_JERK "Vx-jerk" #define MSG_AUTOTEMP _UxGT("Temperatura Auto.")
#define MSG_VY_JERK "Vy-jerk" #define MSG_ON _UxGT("Encender")
#define MSG_VZ_JERK "Vz-jerk" #define MSG_OFF _UxGT("Apagar")
#define MSG_VE_JERK "Ve-jerk" #define MSG_PID_P _UxGT("PID-P")
#define MSG_VMAX "Vmax" #define MSG_PID_I _UxGT("PID-I")
#define MSG_VMIN "Vmin" #define MSG_PID_D _UxGT("PID-D")
#define MSG_VTRAV_MIN "Vel. viaje min" #define MSG_PID_C _UxGT("PID-C")
#define MSG_AMAX "Acel. max" #define MSG_SELECT _UxGT("Seleccionar")
#define MSG_A_RETRACT "Acel. retrac." #define MSG_ACC _UxGT("Aceleracion")
#define MSG_A_TRAVEL "Acel. Viaje" #define MSG_VX_JERK _UxGT("Vx-jerk")
#define MSG_XSTEPS "X pasos/mm" #define MSG_VY_JERK _UxGT("Vy-jerk")
#define MSG_YSTEPS "Y pasos/mm" #define MSG_VZ_JERK _UxGT("Vz-jerk")
#define MSG_ZSTEPS "Z pasos/mm" #define MSG_VE_JERK _UxGT("Ve-jerk")
#define MSG_ESTEPS "E pasos/mm" #define MSG_VMAX _UxGT("Vmax")
#define MSG_TEMPERATURE "Temperatura" #define MSG_VMIN _UxGT("Vmin")
#define MSG_MOTION "Movimiento" #define MSG_VTRAV_MIN _UxGT("Vel. viaje min")
#define MSG_VOLUMETRIC "Filamento" #define MSG_AMAX _UxGT("Acel. max")
#define MSG_VOLUMETRIC_ENABLED "E in mm3" #define MSG_A_RETRACT _UxGT("Acel. retrac.")
#define MSG_FILAMENT_DIAM "Fil. Dia." #define MSG_A_TRAVEL _UxGT("Acel. Viaje")
#define MSG_CONTRAST "Contraste" #define MSG_XSTEPS _UxGT("X pasos/mm")
#define MSG_STORE_EPROM "Guardar memoria" #define MSG_YSTEPS _UxGT("Y pasos/mm")
#define MSG_LOAD_EPROM "Cargar memoria" #define MSG_ZSTEPS _UxGT("Z pasos/mm")
#define MSG_RESTORE_FAILSAFE "Restaurar memoria" #define MSG_ESTEPS _UxGT("E pasos/mm")
#define MSG_REFRESH "Volver a cargar" #define MSG_E1STEPS _UxGT("E1 pasos/mm")
#define MSG_WATCH "Informacion" #define MSG_E2STEPS _UxGT("E2 pasos/mm")
#define MSG_PREPARE "Preparar" #define MSG_E3STEPS _UxGT("E3 pasos/mm")
#define MSG_TUNE "Ajustar" #define MSG_E4STEPS _UxGT("E4 pasos/mm")
#define MSG_PAUSE_PRINT "Pausar impresion" #define MSG_E5STEPS _UxGT("E5 pasos/mm")
#define MSG_RESUME_PRINT "Reanudar impresion" #define MSG_TEMPERATURE _UxGT("Temperatura")
#define MSG_STOP_PRINT "Detener impresion" #define MSG_MOTION _UxGT("Movimiento")
#define MSG_CARD_MENU "Menu de SD" #define MSG_FILAMENT _UxGT("Filamento")
#define MSG_NO_CARD "No hay tarjeta SD" #define MSG_VOLUMETRIC_ENABLED _UxGT("E in mm3")
#define MSG_DWELL "Reposo..." #define MSG_FILAMENT_DIAM _UxGT("Fil. Dia.")
#define MSG_USERWAIT "Esperando ordenes" #define MSG_ADVANCE_K _UxGT("Avance K")
#define MSG_RESUMING "Resumiendo impre." #define MSG_CONTRAST _UxGT("Contraste")
#define MSG_PRINT_ABORTED "Impresion cancelada" #define MSG_STORE_EEPROM _UxGT("Guardar memoria")
#define MSG_NO_MOVE "Sin movimiento" #define MSG_LOAD_EEPROM _UxGT("Cargar memoria")
#define MSG_KILLED "Parada de emergencia" #define MSG_RESTORE_FAILSAFE _UxGT("Restaurar memoria")
#define MSG_STOPPED "Detenida" #define MSG_REFRESH _UxGT("Volver a cargar")
#define MSG_CONTROL_RETRACT "Retraer mm" #define MSG_WATCH _UxGT("Informacion")
#define MSG_CONTROL_RETRACT_SWAP "Interc. Retraer mm" #define MSG_PREPARE _UxGT("Preparar")
#define MSG_CONTROL_RETRACTF "Retraer V" #define MSG_TUNE _UxGT("Ajustar")
#define MSG_CONTROL_RETRACT_ZLIFT "Levantar mm" #define MSG_PAUSE_PRINT _UxGT("Pausar impresion")
#define MSG_CONTROL_RETRACT_RECOVER "DesRet +mm" #define MSG_RESUME_PRINT _UxGT("Reanudar impresion")
#define MSG_CONTROL_RETRACT_RECOVER_SWAP "Interc. DesRet +mm" #define MSG_STOP_PRINT _UxGT("Detener impresion")
#define MSG_CONTROL_RETRACT_RECOVERF "DesRet V" #define MSG_CARD_MENU _UxGT("Menu de SD")
#define MSG_AUTORETRACT "Retraccion Auto." #define MSG_NO_CARD _UxGT("No hay tarjeta SD")
#define MSG_FILAMENTCHANGE "Cambiar filamento" #define MSG_DWELL _UxGT("Reposo...")
#define MSG_INIT_SDCARD "Iniciando tarjeta" #define MSG_USERWAIT _UxGT("Esperando ordenes")
#define MSG_CNG_SDCARD "Cambiar tarjeta" #define MSG_RESUMING _UxGT("Resumiendo impre.")
#define MSG_ZPROBE_OUT "Sonda Z fuera" #define MSG_PRINT_ABORTED _UxGT("Impresion cancelada")
#define MSG_HOME "Home" // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST #define MSG_NO_MOVE _UxGT("Sin movimiento")
#define MSG_FIRST "first" #define MSG_KILLED _UxGT("Parada de emergencia")
#define MSG_ZPROBE_ZOFFSET "Desfase Z" #define MSG_STOPPED _UxGT("Detenida")
#define MSG_BABYSTEP_X "Micropaso X" #define MSG_CONTROL_RETRACT _UxGT("Retraer mm")
#define MSG_BABYSTEP_Y "Micropaso Y" #define MSG_CONTROL_RETRACT_SWAP _UxGT("Interc. Retraer mm")
#define MSG_BABYSTEP_Z "Micropaso Z" #define MSG_CONTROL_RETRACTF _UxGT("Retraer V")
#define MSG_ENDSTOP_ABORT "Cancelado - Endstop" #define MSG_CONTROL_RETRACT_ZLIFT _UxGT("Levantar mm")
#define MSG_HEATING_FAILED_LCD "Error: al calentar" #define MSG_CONTROL_RETRACT_RECOVER _UxGT("DesRet mm")
#define MSG_ERR_REDUNDANT_TEMP "Error: temperatura" #define MSG_CONTROL_RETRACT_RECOVER_SWAP _UxGT("Interc. DesRet mm")
#define MSG_THERMAL_RUNAWAY "Error de temperatura" #define MSG_CONTROL_RETRACT_RECOVERF _UxGT("DesRet V")
#define MSG_ERR_MAXTEMP "Error: Temp Maxima" #define MSG_AUTORETRACT _UxGT("Retraccion Auto.")
#define MSG_ERR_MINTEMP "Error: Temp Minima" #define MSG_FILAMENTCHANGE _UxGT("Cambiar filamento")
#define MSG_ERR_MAXTEMP_BED "Error: Temp Max Plat" #define MSG_INIT_SDCARD _UxGT("Iniciando tarjeta")
#define MSG_ERR_MINTEMP_BED "Error: Temp Min Plat" #define MSG_CNG_SDCARD _UxGT("Cambiar tarjeta")
#define MSG_HEATING "Calentando..." #define MSG_ZPROBE_OUT _UxGT("Sonda Z fuera")
#define MSG_HEATING_COMPLETE "Calentamiento listo" #define MSG_BLTOUCH_SELFTEST _UxGT("BLTouch Auto-Prueba")
#define MSG_BED_HEATING "Calentando Plat..." #define MSG_BLTOUCH_RESET _UxGT("Reiniciar BLTouch")
#define MSG_BED_DONE "Plataforma Caliente" #define MSG_HOME _UxGT("Home") // Used as MSG_HOME " " MSG_X MSG_Y MSG_Z " " MSG_FIRST
#define MSG_DELTA_CALIBRATE "Calibracion Delta" #define MSG_FIRST _UxGT("first")
#define MSG_DELTA_CALIBRATE_X "Calibrar X" #define MSG_ZPROBE_ZOFFSET _UxGT("Desfase Z")
#define MSG_DELTA_CALIBRATE_Y "Calibrar Y" #define MSG_BABYSTEP_X _UxGT("Micropaso X")
#define MSG_DELTA_CALIBRATE_Z "Calibrar Z" #define MSG_BABYSTEP_Y _UxGT("Micropaso Y")
#define MSG_DELTA_CALIBRATE_CENTER "Calibrar Centro" #define MSG_BABYSTEP_Z _UxGT("Micropaso Z")
#define MSG_INFO_MENU "Inf. Impresora" #define MSG_ENDSTOP_ABORT _UxGT("Cancelado - Endstop")
#define MSG_INFO_PRINTER_MENU "Inf. Impresora" #define MSG_HEATING_FAILED_LCD _UxGT("Error: al calentar")
#define MSG_INFO_STATS_MENU "Estadisticas Imp." #define MSG_ERR_REDUNDANT_TEMP _UxGT("Error: temperatura")
#define MSG_INFO_BOARD_MENU "Inf. Controlador" #define MSG_THERMAL_RUNAWAY _UxGT("Error de temperatura")
#define MSG_INFO_THERMISTOR_MENU "Termistores" #define MSG_ERR_MAXTEMP _UxGT("Error: Temp Maxima")
#define MSG_INFO_EXTRUDERS "Extrusores" #define MSG_ERR_MINTEMP _UxGT("Error: Temp Minima")
#define MSG_INFO_BAUDRATE "Baudios" #define MSG_ERR_MAXTEMP_BED _UxGT("Error: Temp Max Plat")
#define MSG_INFO_PROTOCOL "Protocolo" #define MSG_ERR_MINTEMP_BED _UxGT("Error: Temp Min Plat")
#define MSG_INFO_PRINT_COUNT "Conteo de impresion" #define MSG_ERR_Z_HOMING _UxGT("G28 Z Prohibido")
#define MSG_INFO_COMPLETED_PRINTS "Completadas" #define MSG_HALTED _UxGT("IMPRESORA PARADA")
#define MSG_INFO_PRINT_TIME "Tiempo total de imp." #define MSG_PLEASE_RESET _UxGT("Por favor, reinicie")
#define MSG_INFO_PRINT_LONGEST "Impresion mas larga" #define MSG_SHORT_DAY _UxGT("d") // One character only
#define MSG_INFO_PRINT_FILAMENT "Total de Extrusion" #define MSG_SHORT_HOUR _UxGT("h") // One character only
#define MSG_INFO_PRINT_COUNT "Impresiones" #define MSG_SHORT_MINUTE _UxGT("m") // One character only
#define MSG_INFO_COMPLETED_PRINTS "Completadas" #define MSG_HEATING _UxGT("Calentando...")
#define MSG_INFO_PRINT_TIME "Total" #define MSG_HEATING_COMPLETE _UxGT("Calentamiento listo")
#define MSG_INFO_PRINT_LONGEST "Mas larga" #define MSG_BED_HEATING _UxGT("Calentando Plat...")
#define MSG_INFO_PRINT_FILAMENT "Extrusion" #define MSG_BED_DONE _UxGT("Plataforma Caliente")
#define MSG_INFO_MIN_TEMP "Temperatura minima" #define MSG_DELTA_CALIBRATE _UxGT("Calibracion Delta")
#define MSG_INFO_MAX_TEMP "Temperatura maxima" #define MSG_DELTA_CALIBRATE_X _UxGT("Calibrar X")
#define MSG_INFO_PSU "Fuente de poder" #define MSG_DELTA_CALIBRATE_Y _UxGT("Calibrar Y")
#define MSG_DELTA_CALIBRATE_Z _UxGT("Calibrar Z")
#define MSG_DELTA_CALIBRATE_CENTER _UxGT("Calibrar Centro")
#define MSG_DELTA_AUTO_CALIBRATE _UxGT("Auto Calibracion")
#define MSG_DELTA_HEIGHT_CALIBRATE _UxGT("Est. Altura Delta")
#define MSG_INFO_MENU _UxGT("Inf. Impresora")
#define MSG_INFO_PRINTER_MENU _UxGT("Inf. Impresora")
#define MSG_INFO_STATS_MENU _UxGT("Estadisticas Imp.")
#define MSG_INFO_BOARD_MENU _UxGT("Inf. Controlador")
#define MSG_INFO_THERMISTOR_MENU _UxGT("Termistores")
#define MSG_INFO_EXTRUDERS _UxGT("Extrusores")
#define MSG_INFO_BAUDRATE _UxGT("Baudios")
#define MSG_INFO_PROTOCOL _UxGT("Protocolo")
#define MSG_LIGHTS_ON _UxGT("Luz cabina ON")
#define MSG_LIGHTS_OFF _UxGT("Luz cabina OFF")
#if LCD_WIDTH > 19
#define MSG_INFO_PRINT_COUNT _UxGT("Conteo de impresion")
#define MSG_INFO_COMPLETED_PRINTS _UxGT("Completadas")
#define MSG_INFO_PRINT_TIME _UxGT("Tiempo total de imp.")
#define MSG_INFO_PRINT_LONGEST _UxGT("Impresion mas larga")
#define MSG_INFO_PRINT_FILAMENT _UxGT("Total de Extrusion")
#else
#define MSG_INFO_PRINT_COUNT _UxGT("Impresiones")
#define MSG_INFO_COMPLETED_PRINTS _UxGT("Completadas")
#define MSG_INFO_PRINT_TIME _UxGT("Total")
#define MSG_INFO_PRINT_LONGEST _UxGT("Mas larga")
#define MSG_INFO_PRINT_FILAMENT _UxGT("Extrusion")
#endif
#define MSG_INFO_MIN_TEMP _UxGT("Temperatura minima")
#define MSG_INFO_MAX_TEMP _UxGT("Temperatura maxima")
#define MSG_INFO_PSU _UxGT("Fuente de poder")
#define MSG_DRIVE_STRENGTH _UxGT("Potencia driver")
#define MSG_DAC_PERCENT _UxGT("Driver %")
#define MSG_DAC_EEPROM_WRITE _UxGT("Escribe DAC EEPROM")
#define MSG_FILAMENT_CHANGE_HEADER "Cambiar Filamento" #define MSG_FILAMENT_CHANGE_HEADER _UxGT("Cambiar Filamento")
#define MSG_FILAMENT_CHANGE_OPTION_HEADER "Opciones de cambio:" #define MSG_FILAMENT_CHANGE_OPTION_HEADER _UxGT("Opciones de cambio:")
#define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE "Extruir mas" #define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE _UxGT("Extruir mas")
#define MSG_FILAMENT_CHANGE_OPTION_RESUME "Resumir imp." #define MSG_FILAMENT_CHANGE_OPTION_RESUME _UxGT("Resumir imp.")
#define MSG_FILAMENT_CHANGE_INIT_1 "Esperando iniciar" #define MSG_FILAMENT_CHANGE_MINTEMP _UxGT("Temp Minima es ")
#define MSG_FILAMENT_CHANGE_NOZZLE _UxGT(" Boquilla: ")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Inserte filamento" #define MSG_FILAMENT_CHANGE_INIT_1 _UxGT("Esperando iniciar")
#define MSG_FILAMENT_CHANGE_INSERT_2 "y presione el boton"
#define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Inserte filamento")
#define MSG_FILAMENT_CHANGE_INSERT_2 _UxGT("y presione el boton")
#if LCD_HEIGHT >= 4 #if LCD_HEIGHT >= 4
// Up to 3 lines allowed // Up to 3 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_2 "del filamento" #define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("del filamento")
#define MSG_FILAMENT_CHANGE_INIT_3 "cambiar" #define MSG_FILAMENT_CHANGE_INIT_3 _UxGT("cambiar")
#define MSG_FILAMENT_CHANGE_INSERT_3 "para continuar..." #define MSG_FILAMENT_CHANGE_INSERT_3 _UxGT("para continuar...")
#else // LCD_HEIGHT < 4 #else // LCD_HEIGHT < 4
// Up to 2 lines allowed // Up to 2 lines allowed
#define MSG_FILAMENT_CHANGE_INIT_2 "del fil. cambiar" #define MSG_FILAMENT_CHANGE_INIT_2 _UxGT("del fil. cambiar")
#define MSG_FILAMENT_CHANGE_INSERT_1 "Inserte filamento" #define MSG_FILAMENT_CHANGE_INSERT_1 _UxGT("Inserte filamento")
#endif // LCD_HEIGHT < 4 #endif // LCD_HEIGHT < 4
#define MSG_FILAMENT_CHANGE_UNLOAD_1 "Esperado por" #define MSG_FILAMENT_CHANGE_UNLOAD_1 _UxGT("Esperado por")
#define MSG_FILAMENT_CHANGE_UNLOAD_2 "filamento expulsado" #define MSG_FILAMENT_CHANGE_UNLOAD_2 _UxGT("filamento expulsado")
#define MSG_FILAMENT_CHANGE_LOAD_1 "Esperado por" #define MSG_FILAMENT_CHANGE_LOAD_1 _UxGT("Esperado por")
#define MSG_FILAMENT_CHANGE_LOAD_2 "Cargar filamento" #define MSG_FILAMENT_CHANGE_LOAD_2 _UxGT("Cargar filamento")
#define MSG_FILAMENT_CHANGE_EXTRUDE_1 "Esperado por" #define MSG_FILAMENT_CHANGE_EXTRUDE_1 _UxGT("Esperado por")
#define MSG_FILAMENT_CHANGE_EXTRUDE_2 "Extruir filamento" #define MSG_FILAMENT_CHANGE_EXTRUDE_2 _UxGT("Extruir filamento")
#define MSG_FILAMENT_CHANGE_RESUME_1 "Esperando imp." #define MSG_FILAMENT_CHANGE_RESUME_1 _UxGT("Esperando imp.")
#define MSG_FILAMENT_CHANGE_RESUME_2 "para resumir" #define MSG_FILAMENT_CHANGE_RESUME_2 _UxGT("para resumir")
#define MSG_FILAMENT_CHANGE_HEAT_1 _UxGT("Oprima boton para")
#define MSG_FILAMENT_CHANGE_HEATING_1 _UxGT("Calentando boquilla")
#endif // LANGUAGE_ES_H #endif // LANGUAGE_ES_H

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