My Marlin configs for Fabrikator Mini and CTC i3 Pro B
選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。

temperature.cpp 59KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948
  1. /**
  2. * Marlin 3D Printer Firmware
  3. * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  4. *
  5. * Based on Sprinter and grbl.
  6. * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  7. *
  8. * This program is free software: you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation, either version 3 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  20. *
  21. */
  22. /**
  23. * temperature.cpp - temperature control
  24. */
  25. #include "Marlin.h"
  26. #include "ultralcd.h"
  27. #include "temperature.h"
  28. #include "thermistortables.h"
  29. #include "language.h"
  30. #if ENABLED(BABYSTEPPING)
  31. #include "stepper.h"
  32. #endif
  33. #if ENABLED(USE_WATCHDOG)
  34. #include "watchdog.h"
  35. #endif
  36. #ifdef K1 // Defined in Configuration.h in the PID settings
  37. #define K2 (1.0-K1)
  38. #endif
  39. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  40. static void* heater_ttbl_map[2] = {(void*)HEATER_0_TEMPTABLE, (void*)HEATER_1_TEMPTABLE };
  41. static uint8_t heater_ttbllen_map[2] = { HEATER_0_TEMPTABLE_LEN, HEATER_1_TEMPTABLE_LEN };
  42. #else
  43. static void* heater_ttbl_map[HOTENDS] = ARRAY_BY_HOTENDS((void*)HEATER_0_TEMPTABLE, (void*)HEATER_1_TEMPTABLE, (void*)HEATER_2_TEMPTABLE, (void*)HEATER_3_TEMPTABLE);
  44. static uint8_t heater_ttbllen_map[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_TEMPTABLE_LEN, HEATER_1_TEMPTABLE_LEN, HEATER_2_TEMPTABLE_LEN, HEATER_3_TEMPTABLE_LEN);
  45. #endif
  46. Temperature thermalManager;
  47. // public:
  48. float Temperature::current_temperature[HOTENDS] = { 0.0 },
  49. Temperature::current_temperature_bed = 0.0;
  50. int Temperature::current_temperature_raw[HOTENDS] = { 0 },
  51. Temperature::target_temperature[HOTENDS] = { 0 },
  52. Temperature::current_temperature_bed_raw = 0,
  53. Temperature::target_temperature_bed = 0;
  54. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  55. float Temperature::redundant_temperature = 0.0;
  56. #endif
  57. uint8_t Temperature::soft_pwm_bed;
  58. #if ENABLED(FAN_SOFT_PWM)
  59. uint8_t Temperature::fanSpeedSoftPwm[FAN_COUNT];
  60. #endif
  61. #if ENABLED(PIDTEMP)
  62. #if ENABLED(PID_PARAMS_PER_HOTEND) && HOTENDS > 1
  63. float Temperature::Kp[HOTENDS] = ARRAY_BY_HOTENDS1(DEFAULT_Kp),
  64. Temperature::Ki[HOTENDS] = ARRAY_BY_HOTENDS1((DEFAULT_Ki) * (PID_dT)),
  65. Temperature::Kd[HOTENDS] = ARRAY_BY_HOTENDS1((DEFAULT_Kd) / (PID_dT));
  66. #if ENABLED(PID_EXTRUSION_SCALING)
  67. float Temperature::Kc[HOTENDS] = ARRAY_BY_HOTENDS1(DEFAULT_Kc);
  68. #endif
  69. #else
  70. float Temperature::Kp = DEFAULT_Kp,
  71. Temperature::Ki = (DEFAULT_Ki) * (PID_dT),
  72. Temperature::Kd = (DEFAULT_Kd) / (PID_dT);
  73. #if ENABLED(PID_EXTRUSION_SCALING)
  74. float Temperature::Kc = DEFAULT_Kc;
  75. #endif
  76. #endif
  77. #endif
  78. #if ENABLED(PIDTEMPBED)
  79. float Temperature::bedKp = DEFAULT_bedKp,
  80. Temperature::bedKi = ((DEFAULT_bedKi) * PID_dT),
  81. Temperature::bedKd = ((DEFAULT_bedKd) / PID_dT);
  82. #endif
  83. #if ENABLED(BABYSTEPPING)
  84. volatile int Temperature::babystepsTodo[XYZ] = { 0 };
  85. #endif
  86. #if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
  87. int Temperature::watch_target_temp[HOTENDS] = { 0 };
  88. millis_t Temperature::watch_heater_next_ms[HOTENDS] = { 0 };
  89. #endif
  90. #if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
  91. int Temperature::watch_target_bed_temp = 0;
  92. millis_t Temperature::watch_bed_next_ms = 0;
  93. #endif
  94. #if ENABLED(PREVENT_COLD_EXTRUSION)
  95. bool Temperature::allow_cold_extrude = false;
  96. float Temperature::extrude_min_temp = EXTRUDE_MINTEMP;
  97. #endif
  98. // private:
  99. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  100. int Temperature::redundant_temperature_raw = 0;
  101. float Temperature::redundant_temperature = 0.0;
  102. #endif
  103. volatile bool Temperature::temp_meas_ready = false;
  104. #if ENABLED(PIDTEMP)
  105. float Temperature::temp_iState[HOTENDS] = { 0 },
  106. Temperature::temp_dState[HOTENDS] = { 0 },
  107. Temperature::pTerm[HOTENDS],
  108. Temperature::iTerm[HOTENDS],
  109. Temperature::dTerm[HOTENDS];
  110. #if ENABLED(PID_EXTRUSION_SCALING)
  111. float Temperature::cTerm[HOTENDS];
  112. long Temperature::last_e_position;
  113. long Temperature::lpq[LPQ_MAX_LEN];
  114. int Temperature::lpq_ptr = 0;
  115. #endif
  116. float Temperature::pid_error[HOTENDS];
  117. bool Temperature::pid_reset[HOTENDS];
  118. #endif
  119. #if ENABLED(PIDTEMPBED)
  120. float Temperature::temp_iState_bed = { 0 },
  121. Temperature::temp_dState_bed = { 0 },
  122. Temperature::pTerm_bed,
  123. Temperature::iTerm_bed,
  124. Temperature::dTerm_bed,
  125. Temperature::pid_error_bed;
  126. #else
  127. millis_t Temperature::next_bed_check_ms;
  128. #endif
  129. unsigned long Temperature::raw_temp_value[MAX_EXTRUDERS] = { 0 };
  130. unsigned long Temperature::raw_temp_bed_value = 0;
  131. // Init min and max temp with extreme values to prevent false errors during startup
  132. int Temperature::minttemp_raw[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_RAW_LO_TEMP , HEATER_1_RAW_LO_TEMP , HEATER_2_RAW_LO_TEMP, HEATER_3_RAW_LO_TEMP),
  133. Temperature::maxttemp_raw[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_RAW_HI_TEMP , HEATER_1_RAW_HI_TEMP , HEATER_2_RAW_HI_TEMP, HEATER_3_RAW_HI_TEMP),
  134. Temperature::minttemp[HOTENDS] = { 0 },
  135. Temperature::maxttemp[HOTENDS] = ARRAY_BY_HOTENDS1(16383);
  136. #ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
  137. int Temperature::consecutive_low_temperature_error[HOTENDS] = { 0 };
  138. #endif
  139. #ifdef MILLISECONDS_PREHEAT_TIME
  140. unsigned long Temperature::preheat_end_time[HOTENDS] = { 0 };
  141. #endif
  142. #ifdef BED_MINTEMP
  143. int Temperature::bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP;
  144. #endif
  145. #ifdef BED_MAXTEMP
  146. int Temperature::bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP;
  147. #endif
  148. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  149. int Temperature::meas_shift_index; // Index of a delayed sample in buffer
  150. #endif
  151. #if HAS_AUTO_FAN
  152. millis_t Temperature::next_auto_fan_check_ms = 0;
  153. #endif
  154. uint8_t Temperature::soft_pwm[HOTENDS];
  155. #if ENABLED(FAN_SOFT_PWM)
  156. uint8_t Temperature::soft_pwm_fan[FAN_COUNT];
  157. #endif
  158. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  159. int Temperature::current_raw_filwidth = 0; //Holds measured filament diameter - one extruder only
  160. #endif
  161. #if HAS_PID_HEATING
  162. void Temperature::PID_autotune(float temp, int hotend, int ncycles, bool set_result/*=false*/) {
  163. float input = 0.0;
  164. int cycles = 0;
  165. bool heating = true;
  166. millis_t temp_ms = millis(), t1 = temp_ms, t2 = temp_ms;
  167. long t_high = 0, t_low = 0;
  168. long bias, d;
  169. float Ku, Tu;
  170. float workKp = 0, workKi = 0, workKd = 0;
  171. float max = 0, min = 10000;
  172. #if HAS_AUTO_FAN
  173. next_auto_fan_check_ms = temp_ms + 2500UL;
  174. #endif
  175. if (hotend >=
  176. #if ENABLED(PIDTEMP)
  177. HOTENDS
  178. #else
  179. 0
  180. #endif
  181. || hotend <
  182. #if ENABLED(PIDTEMPBED)
  183. -1
  184. #else
  185. 0
  186. #endif
  187. ) {
  188. SERIAL_ECHOLN(MSG_PID_BAD_EXTRUDER_NUM);
  189. return;
  190. }
  191. SERIAL_ECHOLN(MSG_PID_AUTOTUNE_START);
  192. disable_all_heaters(); // switch off all heaters.
  193. #if HAS_PID_FOR_BOTH
  194. if (hotend < 0)
  195. soft_pwm_bed = bias = d = (MAX_BED_POWER) >> 1;
  196. else
  197. soft_pwm[hotend] = bias = d = (PID_MAX) >> 1;
  198. #elif ENABLED(PIDTEMP)
  199. soft_pwm[hotend] = bias = d = (PID_MAX) >> 1;
  200. #else
  201. soft_pwm_bed = bias = d = (MAX_BED_POWER) >> 1;
  202. #endif
  203. wait_for_heatup = true;
  204. // PID Tuning loop
  205. while (wait_for_heatup) {
  206. millis_t ms = millis();
  207. if (temp_meas_ready) { // temp sample ready
  208. updateTemperaturesFromRawValues();
  209. input =
  210. #if HAS_PID_FOR_BOTH
  211. hotend < 0 ? current_temperature_bed : current_temperature[hotend]
  212. #elif ENABLED(PIDTEMP)
  213. current_temperature[hotend]
  214. #else
  215. current_temperature_bed
  216. #endif
  217. ;
  218. NOLESS(max, input);
  219. NOMORE(min, input);
  220. #if HAS_AUTO_FAN
  221. if (ELAPSED(ms, next_auto_fan_check_ms)) {
  222. checkExtruderAutoFans();
  223. next_auto_fan_check_ms = ms + 2500UL;
  224. }
  225. #endif
  226. if (heating && input > temp) {
  227. if (ELAPSED(ms, t2 + 5000UL)) {
  228. heating = false;
  229. #if HAS_PID_FOR_BOTH
  230. if (hotend < 0)
  231. soft_pwm_bed = (bias - d) >> 1;
  232. else
  233. soft_pwm[hotend] = (bias - d) >> 1;
  234. #elif ENABLED(PIDTEMP)
  235. soft_pwm[hotend] = (bias - d) >> 1;
  236. #elif ENABLED(PIDTEMPBED)
  237. soft_pwm_bed = (bias - d) >> 1;
  238. #endif
  239. t1 = ms;
  240. t_high = t1 - t2;
  241. max = temp;
  242. }
  243. }
  244. if (!heating && input < temp) {
  245. if (ELAPSED(ms, t1 + 5000UL)) {
  246. heating = true;
  247. t2 = ms;
  248. t_low = t2 - t1;
  249. if (cycles > 0) {
  250. long max_pow =
  251. #if HAS_PID_FOR_BOTH
  252. hotend < 0 ? MAX_BED_POWER : PID_MAX
  253. #elif ENABLED(PIDTEMP)
  254. PID_MAX
  255. #else
  256. MAX_BED_POWER
  257. #endif
  258. ;
  259. bias += (d * (t_high - t_low)) / (t_low + t_high);
  260. bias = constrain(bias, 20, max_pow - 20);
  261. d = (bias > max_pow / 2) ? max_pow - 1 - bias : bias;
  262. SERIAL_PROTOCOLPAIR(MSG_BIAS, bias);
  263. SERIAL_PROTOCOLPAIR(MSG_D, d);
  264. SERIAL_PROTOCOLPAIR(MSG_T_MIN, min);
  265. SERIAL_PROTOCOLPAIR(MSG_T_MAX, max);
  266. if (cycles > 2) {
  267. Ku = (4.0 * d) / (M_PI * (max - min) * 0.5);
  268. Tu = ((float)(t_low + t_high) * 0.001);
  269. SERIAL_PROTOCOLPAIR(MSG_KU, Ku);
  270. SERIAL_PROTOCOLPAIR(MSG_TU, Tu);
  271. workKp = 0.6 * Ku;
  272. workKi = 2 * workKp / Tu;
  273. workKd = workKp * Tu * 0.125;
  274. SERIAL_PROTOCOLLNPGM("\n" MSG_CLASSIC_PID);
  275. SERIAL_PROTOCOLPAIR(MSG_KP, workKp);
  276. SERIAL_PROTOCOLPAIR(MSG_KI, workKi);
  277. SERIAL_PROTOCOLLNPAIR(MSG_KD, workKd);
  278. /**
  279. workKp = 0.33*Ku;
  280. workKi = workKp/Tu;
  281. workKd = workKp*Tu/3;
  282. SERIAL_PROTOCOLLNPGM(" Some overshoot");
  283. SERIAL_PROTOCOLPAIR(" Kp: ", workKp);
  284. SERIAL_PROTOCOLPAIR(" Ki: ", workKi);
  285. SERIAL_PROTOCOLPAIR(" Kd: ", workKd);
  286. workKp = 0.2*Ku;
  287. workKi = 2*workKp/Tu;
  288. workKd = workKp*Tu/3;
  289. SERIAL_PROTOCOLLNPGM(" No overshoot");
  290. SERIAL_PROTOCOLPAIR(" Kp: ", workKp);
  291. SERIAL_PROTOCOLPAIR(" Ki: ", workKi);
  292. SERIAL_PROTOCOLPAIR(" Kd: ", workKd);
  293. */
  294. }
  295. }
  296. #if HAS_PID_FOR_BOTH
  297. if (hotend < 0)
  298. soft_pwm_bed = (bias + d) >> 1;
  299. else
  300. soft_pwm[hotend] = (bias + d) >> 1;
  301. #elif ENABLED(PIDTEMP)
  302. soft_pwm[hotend] = (bias + d) >> 1;
  303. #else
  304. soft_pwm_bed = (bias + d) >> 1;
  305. #endif
  306. cycles++;
  307. min = temp;
  308. }
  309. }
  310. }
  311. #define MAX_OVERSHOOT_PID_AUTOTUNE 20
  312. if (input > temp + MAX_OVERSHOOT_PID_AUTOTUNE) {
  313. SERIAL_PROTOCOLLNPGM(MSG_PID_TEMP_TOO_HIGH);
  314. return;
  315. }
  316. // Every 2 seconds...
  317. if (ELAPSED(ms, temp_ms + 2000UL)) {
  318. #if HAS_TEMP_HOTEND || HAS_TEMP_BED
  319. print_heaterstates();
  320. SERIAL_EOL;
  321. #endif
  322. temp_ms = ms;
  323. } // every 2 seconds
  324. // Over 2 minutes?
  325. if (((ms - t1) + (ms - t2)) > (10L * 60L * 1000L * 2L)) {
  326. SERIAL_PROTOCOLLNPGM(MSG_PID_TIMEOUT);
  327. return;
  328. }
  329. if (cycles > ncycles) {
  330. SERIAL_PROTOCOLLNPGM(MSG_PID_AUTOTUNE_FINISHED);
  331. #if HAS_PID_FOR_BOTH
  332. const char* estring = hotend < 0 ? "bed" : "";
  333. SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Kp ", workKp); SERIAL_EOL;
  334. SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Ki ", workKi); SERIAL_EOL;
  335. SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Kd ", workKd); SERIAL_EOL;
  336. #elif ENABLED(PIDTEMP)
  337. SERIAL_PROTOCOLPAIR("#define DEFAULT_Kp ", workKp); SERIAL_EOL;
  338. SERIAL_PROTOCOLPAIR("#define DEFAULT_Ki ", workKi); SERIAL_EOL;
  339. SERIAL_PROTOCOLPAIR("#define DEFAULT_Kd ", workKd); SERIAL_EOL;
  340. #else
  341. SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKp ", workKp); SERIAL_EOL;
  342. SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKi ", workKi); SERIAL_EOL;
  343. SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKd ", workKd); SERIAL_EOL;
  344. #endif
  345. #define _SET_BED_PID() do { \
  346. bedKp = workKp; \
  347. bedKi = scalePID_i(workKi); \
  348. bedKd = scalePID_d(workKd); \
  349. updatePID(); } while(0)
  350. #define _SET_EXTRUDER_PID() do { \
  351. PID_PARAM(Kp, hotend) = workKp; \
  352. PID_PARAM(Ki, hotend) = scalePID_i(workKi); \
  353. PID_PARAM(Kd, hotend) = scalePID_d(workKd); \
  354. updatePID(); } while(0)
  355. // Use the result? (As with "M303 U1")
  356. if (set_result) {
  357. #if HAS_PID_FOR_BOTH
  358. if (hotend < 0)
  359. _SET_BED_PID();
  360. else
  361. _SET_EXTRUDER_PID();
  362. #elif ENABLED(PIDTEMP)
  363. _SET_EXTRUDER_PID();
  364. #else
  365. _SET_BED_PID();
  366. #endif
  367. }
  368. return;
  369. }
  370. lcd_update();
  371. }
  372. if (!wait_for_heatup) disable_all_heaters();
  373. }
  374. #endif // HAS_PID_HEATING
  375. /**
  376. * Class and Instance Methods
  377. */
  378. Temperature::Temperature() { }
  379. void Temperature::updatePID() {
  380. #if ENABLED(PIDTEMP)
  381. #if ENABLED(PID_EXTRUSION_SCALING)
  382. last_e_position = 0;
  383. #endif
  384. #endif
  385. }
  386. int Temperature::getHeaterPower(int heater) {
  387. return heater < 0 ? soft_pwm_bed : soft_pwm[heater];
  388. }
  389. #if HAS_AUTO_FAN
  390. void Temperature::checkExtruderAutoFans() {
  391. const int8_t fanPin[] = { E0_AUTO_FAN_PIN, E1_AUTO_FAN_PIN, E2_AUTO_FAN_PIN, E3_AUTO_FAN_PIN };
  392. const int fanBit[] = {
  393. 0,
  394. AUTO_1_IS_0 ? 0 : 1,
  395. AUTO_2_IS_0 ? 0 : AUTO_2_IS_1 ? 1 : 2,
  396. AUTO_3_IS_0 ? 0 : AUTO_3_IS_1 ? 1 : AUTO_3_IS_2 ? 2 : 3
  397. };
  398. uint8_t fanState = 0;
  399. HOTEND_LOOP() {
  400. if (current_temperature[e] > EXTRUDER_AUTO_FAN_TEMPERATURE)
  401. SBI(fanState, fanBit[e]);
  402. }
  403. uint8_t fanDone = 0;
  404. for (uint8_t f = 0; f < COUNT(fanPin); f++) {
  405. int8_t pin = fanPin[f];
  406. if (pin >= 0 && !TEST(fanDone, fanBit[f])) {
  407. uint8_t newFanSpeed = TEST(fanState, fanBit[f]) ? EXTRUDER_AUTO_FAN_SPEED : 0;
  408. // this idiom allows both digital and PWM fan outputs (see M42 handling).
  409. digitalWrite(pin, newFanSpeed);
  410. analogWrite(pin, newFanSpeed);
  411. SBI(fanDone, fanBit[f]);
  412. }
  413. }
  414. }
  415. #endif // HAS_AUTO_FAN
  416. //
  417. // Temperature Error Handlers
  418. //
  419. void Temperature::_temp_error(int e, const char* serial_msg, const char* lcd_msg) {
  420. static bool killed = false;
  421. if (IsRunning()) {
  422. SERIAL_ERROR_START;
  423. serialprintPGM(serial_msg);
  424. SERIAL_ERRORPGM(MSG_STOPPED_HEATER);
  425. if (e >= 0) SERIAL_ERRORLN((int)e); else SERIAL_ERRORLNPGM(MSG_HEATER_BED);
  426. }
  427. #if DISABLED(BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE)
  428. if (!killed) {
  429. Running = false;
  430. killed = true;
  431. kill(lcd_msg);
  432. }
  433. else
  434. disable_all_heaters(); // paranoia
  435. #endif
  436. }
  437. void Temperature::max_temp_error(int8_t e) {
  438. #if HAS_TEMP_BED
  439. _temp_error(e, PSTR(MSG_T_MAXTEMP), e >= 0 ? PSTR(MSG_ERR_MAXTEMP) : PSTR(MSG_ERR_MAXTEMP_BED));
  440. #else
  441. _temp_error(HOTEND_INDEX, PSTR(MSG_T_MAXTEMP), PSTR(MSG_ERR_MAXTEMP));
  442. #if HOTENDS == 1
  443. UNUSED(e);
  444. #endif
  445. #endif
  446. }
  447. void Temperature::min_temp_error(int8_t e) {
  448. #if HAS_TEMP_BED
  449. _temp_error(e, PSTR(MSG_T_MINTEMP), e >= 0 ? PSTR(MSG_ERR_MINTEMP) : PSTR(MSG_ERR_MINTEMP_BED));
  450. #else
  451. _temp_error(HOTEND_INDEX, PSTR(MSG_T_MINTEMP), PSTR(MSG_ERR_MINTEMP));
  452. #if HOTENDS == 1
  453. UNUSED(e);
  454. #endif
  455. #endif
  456. }
  457. float Temperature::get_pid_output(int e) {
  458. #if HOTENDS == 1
  459. UNUSED(e);
  460. #define _HOTEND_TEST true
  461. #else
  462. #define _HOTEND_TEST e == active_extruder
  463. #endif
  464. float pid_output;
  465. #if ENABLED(PIDTEMP)
  466. #if DISABLED(PID_OPENLOOP)
  467. pid_error[HOTEND_INDEX] = target_temperature[HOTEND_INDEX] - current_temperature[HOTEND_INDEX];
  468. dTerm[HOTEND_INDEX] = K2 * PID_PARAM(Kd, HOTEND_INDEX) * (current_temperature[HOTEND_INDEX] - temp_dState[HOTEND_INDEX]) + K1 * dTerm[HOTEND_INDEX];
  469. temp_dState[HOTEND_INDEX] = current_temperature[HOTEND_INDEX];
  470. if (pid_error[HOTEND_INDEX] > PID_FUNCTIONAL_RANGE) {
  471. pid_output = BANG_MAX;
  472. pid_reset[HOTEND_INDEX] = true;
  473. }
  474. else if (pid_error[HOTEND_INDEX] < -(PID_FUNCTIONAL_RANGE) || target_temperature[HOTEND_INDEX] == 0) {
  475. pid_output = 0;
  476. pid_reset[HOTEND_INDEX] = true;
  477. }
  478. else {
  479. if (pid_reset[HOTEND_INDEX]) {
  480. temp_iState[HOTEND_INDEX] = 0.0;
  481. pid_reset[HOTEND_INDEX] = false;
  482. }
  483. pTerm[HOTEND_INDEX] = PID_PARAM(Kp, HOTEND_INDEX) * pid_error[HOTEND_INDEX];
  484. temp_iState[HOTEND_INDEX] += pid_error[HOTEND_INDEX];
  485. iTerm[HOTEND_INDEX] = PID_PARAM(Ki, HOTEND_INDEX) * temp_iState[HOTEND_INDEX];
  486. pid_output = pTerm[HOTEND_INDEX] + iTerm[HOTEND_INDEX] - dTerm[HOTEND_INDEX];
  487. #if ENABLED(PID_EXTRUSION_SCALING)
  488. cTerm[HOTEND_INDEX] = 0;
  489. if (_HOTEND_TEST) {
  490. long e_position = stepper.position(E_AXIS);
  491. if (e_position > last_e_position) {
  492. lpq[lpq_ptr] = e_position - last_e_position;
  493. last_e_position = e_position;
  494. }
  495. else {
  496. lpq[lpq_ptr] = 0;
  497. }
  498. if (++lpq_ptr >= lpq_len) lpq_ptr = 0;
  499. cTerm[HOTEND_INDEX] = (lpq[lpq_ptr] * planner.steps_to_mm[E_AXIS]) * PID_PARAM(Kc, HOTEND_INDEX);
  500. pid_output += cTerm[HOTEND_INDEX];
  501. }
  502. #endif // PID_EXTRUSION_SCALING
  503. if (pid_output > PID_MAX) {
  504. if (pid_error[HOTEND_INDEX] > 0) temp_iState[HOTEND_INDEX] -= pid_error[HOTEND_INDEX]; // conditional un-integration
  505. pid_output = PID_MAX;
  506. }
  507. else if (pid_output < 0) {
  508. if (pid_error[HOTEND_INDEX] < 0) temp_iState[HOTEND_INDEX] -= pid_error[HOTEND_INDEX]; // conditional un-integration
  509. pid_output = 0;
  510. }
  511. }
  512. #else
  513. pid_output = constrain(target_temperature[HOTEND_INDEX], 0, PID_MAX);
  514. #endif //PID_OPENLOOP
  515. #if ENABLED(PID_DEBUG)
  516. SERIAL_ECHO_START;
  517. SERIAL_ECHOPAIR(MSG_PID_DEBUG, HOTEND_INDEX);
  518. SERIAL_ECHOPAIR(MSG_PID_DEBUG_INPUT, current_temperature[HOTEND_INDEX]);
  519. SERIAL_ECHOPAIR(MSG_PID_DEBUG_OUTPUT, pid_output);
  520. SERIAL_ECHOPAIR(MSG_PID_DEBUG_PTERM, pTerm[HOTEND_INDEX]);
  521. SERIAL_ECHOPAIR(MSG_PID_DEBUG_ITERM, iTerm[HOTEND_INDEX]);
  522. SERIAL_ECHOPAIR(MSG_PID_DEBUG_DTERM, dTerm[HOTEND_INDEX]);
  523. #if ENABLED(PID_EXTRUSION_SCALING)
  524. SERIAL_ECHOPAIR(MSG_PID_DEBUG_CTERM, cTerm[HOTEND_INDEX]);
  525. #endif
  526. SERIAL_EOL;
  527. #endif //PID_DEBUG
  528. #else /* PID off */
  529. pid_output = (current_temperature[HOTEND_INDEX] < target_temperature[HOTEND_INDEX]) ? PID_MAX : 0;
  530. #endif
  531. return pid_output;
  532. }
  533. #if ENABLED(PIDTEMPBED)
  534. float Temperature::get_pid_output_bed() {
  535. float pid_output;
  536. #if DISABLED(PID_OPENLOOP)
  537. pid_error_bed = target_temperature_bed - current_temperature_bed;
  538. pTerm_bed = bedKp * pid_error_bed;
  539. temp_iState_bed += pid_error_bed;
  540. iTerm_bed = bedKi * temp_iState_bed;
  541. dTerm_bed = K2 * bedKd * (current_temperature_bed - temp_dState_bed) + K1 * dTerm_bed;
  542. temp_dState_bed = current_temperature_bed;
  543. pid_output = pTerm_bed + iTerm_bed - dTerm_bed;
  544. if (pid_output > MAX_BED_POWER) {
  545. if (pid_error_bed > 0) temp_iState_bed -= pid_error_bed; // conditional un-integration
  546. pid_output = MAX_BED_POWER;
  547. }
  548. else if (pid_output < 0) {
  549. if (pid_error_bed < 0) temp_iState_bed -= pid_error_bed; // conditional un-integration
  550. pid_output = 0;
  551. }
  552. #else
  553. pid_output = constrain(target_temperature_bed, 0, MAX_BED_POWER);
  554. #endif // PID_OPENLOOP
  555. #if ENABLED(PID_BED_DEBUG)
  556. SERIAL_ECHO_START;
  557. SERIAL_ECHOPGM(" PID_BED_DEBUG ");
  558. SERIAL_ECHOPGM(": Input ");
  559. SERIAL_ECHO(current_temperature_bed);
  560. SERIAL_ECHOPGM(" Output ");
  561. SERIAL_ECHO(pid_output);
  562. SERIAL_ECHOPGM(" pTerm ");
  563. SERIAL_ECHO(pTerm_bed);
  564. SERIAL_ECHOPGM(" iTerm ");
  565. SERIAL_ECHO(iTerm_bed);
  566. SERIAL_ECHOPGM(" dTerm ");
  567. SERIAL_ECHOLN(dTerm_bed);
  568. #endif //PID_BED_DEBUG
  569. return pid_output;
  570. }
  571. #endif //PIDTEMPBED
  572. /**
  573. * Manage heating activities for extruder hot-ends and a heated bed
  574. * - Acquire updated temperature readings
  575. * - Also resets the watchdog timer
  576. * - Invoke thermal runaway protection
  577. * - Manage extruder auto-fan
  578. * - Apply filament width to the extrusion rate (may move)
  579. * - Update the heated bed PID output value
  580. */
  581. void Temperature::manage_heater() {
  582. if (!temp_meas_ready) return;
  583. updateTemperaturesFromRawValues(); // also resets the watchdog
  584. #if ENABLED(HEATER_0_USES_MAX6675)
  585. if (current_temperature[0] > min(HEATER_0_MAXTEMP, MAX6675_TMAX - 1)) max_temp_error(0);
  586. if (current_temperature[0] < max(HEATER_0_MINTEMP, MAX6675_TMIN + 0.01)) min_temp_error(0);
  587. #endif
  588. #if (ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0) || (ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0) || DISABLED(PIDTEMPBED) || HAS_AUTO_FAN
  589. millis_t ms = millis();
  590. #endif
  591. // Loop through all hotends
  592. HOTEND_LOOP() {
  593. #if ENABLED(THERMAL_PROTECTION_HOTENDS)
  594. thermal_runaway_protection(&thermal_runaway_state_machine[e], &thermal_runaway_timer[e], current_temperature[e], target_temperature[e], e, THERMAL_PROTECTION_PERIOD, THERMAL_PROTECTION_HYSTERESIS);
  595. #endif
  596. float pid_output = get_pid_output(e);
  597. // Check if temperature is within the correct range
  598. soft_pwm[e] = (current_temperature[e] > minttemp[e] || is_preheating(e)) && current_temperature[e] < maxttemp[e] ? (int)pid_output >> 1 : 0;
  599. // Check if the temperature is failing to increase
  600. #if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
  601. // Is it time to check this extruder's heater?
  602. if (watch_heater_next_ms[e] && ELAPSED(ms, watch_heater_next_ms[e])) {
  603. // Has it failed to increase enough?
  604. if (degHotend(e) < watch_target_temp[e]) {
  605. // Stop!
  606. _temp_error(e, PSTR(MSG_T_HEATING_FAILED), PSTR(MSG_HEATING_FAILED_LCD));
  607. }
  608. else {
  609. // Start again if the target is still far off
  610. start_watching_heater(e);
  611. }
  612. }
  613. #endif // THERMAL_PROTECTION_HOTENDS
  614. // Check if the temperature is failing to increase
  615. #if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
  616. // Is it time to check the bed?
  617. if (watch_bed_next_ms && ELAPSED(ms, watch_bed_next_ms)) {
  618. // Has it failed to increase enough?
  619. if (degBed() < watch_target_bed_temp) {
  620. // Stop!
  621. _temp_error(-1, PSTR(MSG_T_HEATING_FAILED), PSTR(MSG_HEATING_FAILED_LCD));
  622. }
  623. else {
  624. // Start again if the target is still far off
  625. start_watching_bed();
  626. }
  627. }
  628. #endif // THERMAL_PROTECTION_HOTENDS
  629. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  630. if (fabs(current_temperature[0] - redundant_temperature) > MAX_REDUNDANT_TEMP_SENSOR_DIFF) {
  631. _temp_error(0, PSTR(MSG_REDUNDANCY), PSTR(MSG_ERR_REDUNDANT_TEMP));
  632. }
  633. #endif
  634. } // Hotends Loop
  635. #if HAS_AUTO_FAN
  636. if (ELAPSED(ms, next_auto_fan_check_ms)) { // only need to check fan state very infrequently
  637. checkExtruderAutoFans();
  638. next_auto_fan_check_ms = ms + 2500UL;
  639. }
  640. #endif
  641. // Control the extruder rate based on the width sensor
  642. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  643. if (filament_sensor) {
  644. meas_shift_index = filwidth_delay_index[0] - meas_delay_cm;
  645. if (meas_shift_index < 0) meas_shift_index += MAX_MEASUREMENT_DELAY + 1; //loop around buffer if needed
  646. // Get the delayed info and add 100 to reconstitute to a percent of
  647. // the nominal filament diameter then square it to get an area
  648. meas_shift_index = constrain(meas_shift_index, 0, MAX_MEASUREMENT_DELAY);
  649. float vm = pow((measurement_delay[meas_shift_index] + 100.0) * 0.01, 2);
  650. NOLESS(vm, 0.01);
  651. volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM] = vm;
  652. }
  653. #endif //FILAMENT_WIDTH_SENSOR
  654. #if DISABLED(PIDTEMPBED)
  655. if (PENDING(ms, next_bed_check_ms)) return;
  656. next_bed_check_ms = ms + BED_CHECK_INTERVAL;
  657. #endif
  658. #if TEMP_SENSOR_BED != 0
  659. #if HAS_THERMALLY_PROTECTED_BED
  660. thermal_runaway_protection(&thermal_runaway_bed_state_machine, &thermal_runaway_bed_timer, current_temperature_bed, target_temperature_bed, -1, THERMAL_PROTECTION_BED_PERIOD, THERMAL_PROTECTION_BED_HYSTERESIS);
  661. #endif
  662. #if ENABLED(PIDTEMPBED)
  663. float pid_output = get_pid_output_bed();
  664. soft_pwm_bed = current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP ? (int)pid_output >> 1 : 0;
  665. #elif ENABLED(BED_LIMIT_SWITCHING)
  666. // Check if temperature is within the correct band
  667. if (current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP) {
  668. if (current_temperature_bed >= target_temperature_bed + BED_HYSTERESIS)
  669. soft_pwm_bed = 0;
  670. else if (current_temperature_bed <= target_temperature_bed - (BED_HYSTERESIS))
  671. soft_pwm_bed = MAX_BED_POWER >> 1;
  672. }
  673. else {
  674. soft_pwm_bed = 0;
  675. WRITE_HEATER_BED(LOW);
  676. }
  677. #else // !PIDTEMPBED && !BED_LIMIT_SWITCHING
  678. // Check if temperature is within the correct range
  679. if (current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP) {
  680. soft_pwm_bed = current_temperature_bed < target_temperature_bed ? MAX_BED_POWER >> 1 : 0;
  681. }
  682. else {
  683. soft_pwm_bed = 0;
  684. WRITE_HEATER_BED(LOW);
  685. }
  686. #endif
  687. #endif //TEMP_SENSOR_BED != 0
  688. }
  689. #define PGM_RD_W(x) (short)pgm_read_word(&x)
  690. // Derived from RepRap FiveD extruder::getTemperature()
  691. // For hot end temperature measurement.
  692. float Temperature::analog2temp(int raw, uint8_t e) {
  693. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  694. if (e > HOTENDS)
  695. #else
  696. if (e >= HOTENDS)
  697. #endif
  698. {
  699. SERIAL_ERROR_START;
  700. SERIAL_ERROR((int)e);
  701. SERIAL_ERRORLNPGM(MSG_INVALID_EXTRUDER_NUM);
  702. kill(PSTR(MSG_KILLED));
  703. return 0.0;
  704. }
  705. #if ENABLED(HEATER_0_USES_MAX6675)
  706. if (e == 0) return 0.25 * raw;
  707. #endif
  708. if (heater_ttbl_map[e] != NULL) {
  709. float celsius = 0;
  710. uint8_t i;
  711. short(*tt)[][2] = (short(*)[][2])(heater_ttbl_map[e]);
  712. for (i = 1; i < heater_ttbllen_map[e]; i++) {
  713. if (PGM_RD_W((*tt)[i][0]) > raw) {
  714. celsius = PGM_RD_W((*tt)[i - 1][1]) +
  715. (raw - PGM_RD_W((*tt)[i - 1][0])) *
  716. (float)(PGM_RD_W((*tt)[i][1]) - PGM_RD_W((*tt)[i - 1][1])) /
  717. (float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i - 1][0]));
  718. break;
  719. }
  720. }
  721. // Overflow: Set to last value in the table
  722. if (i == heater_ttbllen_map[e]) celsius = PGM_RD_W((*tt)[i - 1][1]);
  723. return celsius;
  724. }
  725. return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * (TEMP_SENSOR_AD595_GAIN)) + TEMP_SENSOR_AD595_OFFSET;
  726. }
  727. // Derived from RepRap FiveD extruder::getTemperature()
  728. // For bed temperature measurement.
  729. float Temperature::analog2tempBed(int raw) {
  730. #if ENABLED(BED_USES_THERMISTOR)
  731. float celsius = 0;
  732. byte i;
  733. for (i = 1; i < BEDTEMPTABLE_LEN; i++) {
  734. if (PGM_RD_W(BEDTEMPTABLE[i][0]) > raw) {
  735. celsius = PGM_RD_W(BEDTEMPTABLE[i - 1][1]) +
  736. (raw - PGM_RD_W(BEDTEMPTABLE[i - 1][0])) *
  737. (float)(PGM_RD_W(BEDTEMPTABLE[i][1]) - PGM_RD_W(BEDTEMPTABLE[i - 1][1])) /
  738. (float)(PGM_RD_W(BEDTEMPTABLE[i][0]) - PGM_RD_W(BEDTEMPTABLE[i - 1][0]));
  739. break;
  740. }
  741. }
  742. // Overflow: Set to last value in the table
  743. if (i == BEDTEMPTABLE_LEN) celsius = PGM_RD_W(BEDTEMPTABLE[i - 1][1]);
  744. return celsius;
  745. #elif defined(BED_USES_AD595)
  746. return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * (TEMP_SENSOR_AD595_GAIN)) + TEMP_SENSOR_AD595_OFFSET;
  747. #else
  748. UNUSED(raw);
  749. return 0;
  750. #endif
  751. }
  752. /**
  753. * Get the raw values into the actual temperatures.
  754. * The raw values are created in interrupt context,
  755. * and this function is called from normal context
  756. * as it would block the stepper routine.
  757. */
  758. void Temperature::updateTemperaturesFromRawValues() {
  759. #if ENABLED(HEATER_0_USES_MAX6675)
  760. current_temperature_raw[0] = read_max6675();
  761. #endif
  762. HOTEND_LOOP() {
  763. current_temperature[e] = Temperature::analog2temp(current_temperature_raw[e], e);
  764. }
  765. current_temperature_bed = Temperature::analog2tempBed(current_temperature_bed_raw);
  766. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  767. redundant_temperature = Temperature::analog2temp(redundant_temperature_raw, 1);
  768. #endif
  769. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  770. filament_width_meas = analog2widthFil();
  771. #endif
  772. #if ENABLED(USE_WATCHDOG)
  773. // Reset the watchdog after we know we have a temperature measurement.
  774. watchdog_reset();
  775. #endif
  776. CRITICAL_SECTION_START;
  777. temp_meas_ready = false;
  778. CRITICAL_SECTION_END;
  779. }
  780. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  781. // Convert raw Filament Width to millimeters
  782. float Temperature::analog2widthFil() {
  783. return current_raw_filwidth / 16383.0 * 5.0;
  784. //return current_raw_filwidth;
  785. }
  786. // Convert raw Filament Width to a ratio
  787. int Temperature::widthFil_to_size_ratio() {
  788. float temp = filament_width_meas;
  789. if (temp < MEASURED_LOWER_LIMIT) temp = filament_width_nominal; //assume sensor cut out
  790. else NOMORE(temp, MEASURED_UPPER_LIMIT);
  791. return filament_width_nominal / temp * 100;
  792. }
  793. #endif
  794. /**
  795. * Initialize the temperature manager
  796. * The manager is implemented by periodic calls to manage_heater()
  797. */
  798. void Temperature::init() {
  799. #if MB(RUMBA) && ((TEMP_SENSOR_0==-1)||(TEMP_SENSOR_1==-1)||(TEMP_SENSOR_2==-1)||(TEMP_SENSOR_BED==-1))
  800. //disable RUMBA JTAG in case the thermocouple extension is plugged on top of JTAG connector
  801. MCUCR = _BV(JTD);
  802. MCUCR = _BV(JTD);
  803. #endif
  804. // Finish init of mult hotend arrays
  805. HOTEND_LOOP() {
  806. // populate with the first value
  807. maxttemp[e] = maxttemp[0];
  808. #if ENABLED(PIDTEMP)
  809. #if ENABLED(PID_EXTRUSION_SCALING)
  810. last_e_position = 0;
  811. #endif
  812. #endif //PIDTEMP
  813. }
  814. #if ENABLED(PIDTEMP) && ENABLED(PID_EXTRUSION_SCALING)
  815. last_e_position = 0;
  816. #endif
  817. #if HAS_HEATER_0
  818. SET_OUTPUT(HEATER_0_PIN);
  819. #endif
  820. #if HAS_HEATER_1
  821. SET_OUTPUT(HEATER_1_PIN);
  822. #endif
  823. #if HAS_HEATER_2
  824. SET_OUTPUT(HEATER_2_PIN);
  825. #endif
  826. #if HAS_HEATER_3
  827. SET_OUTPUT(HEATER_3_PIN);
  828. #endif
  829. #if HAS_HEATER_BED
  830. SET_OUTPUT(HEATER_BED_PIN);
  831. #endif
  832. #if HAS_FAN0
  833. SET_OUTPUT(FAN_PIN);
  834. #if ENABLED(FAST_PWM_FAN)
  835. setPwmFrequency(FAN_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  836. #endif
  837. #if ENABLED(FAN_SOFT_PWM)
  838. soft_pwm_fan[0] = fanSpeedSoftPwm[0] >> 1;
  839. #endif
  840. #endif
  841. #if HAS_FAN1
  842. SET_OUTPUT(FAN1_PIN);
  843. #if ENABLED(FAST_PWM_FAN)
  844. setPwmFrequency(FAN1_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  845. #endif
  846. #if ENABLED(FAN_SOFT_PWM)
  847. soft_pwm_fan[1] = fanSpeedSoftPwm[1] >> 1;
  848. #endif
  849. #endif
  850. #if HAS_FAN2
  851. SET_OUTPUT(FAN2_PIN);
  852. #if ENABLED(FAST_PWM_FAN)
  853. setPwmFrequency(FAN2_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  854. #endif
  855. #if ENABLED(FAN_SOFT_PWM)
  856. soft_pwm_fan[2] = fanSpeedSoftPwm[2] >> 1;
  857. #endif
  858. #endif
  859. #if ENABLED(HEATER_0_USES_MAX6675)
  860. OUT_WRITE(SCK_PIN, LOW);
  861. OUT_WRITE(MOSI_PIN, HIGH);
  862. SET_INPUT(MISO_PIN);
  863. WRITE(MISO_PIN, HIGH);
  864. OUT_WRITE(SS_PIN, HIGH);
  865. OUT_WRITE(MAX6675_SS, HIGH);
  866. #endif //HEATER_0_USES_MAX6675
  867. #ifdef DIDR2
  868. #define ANALOG_SELECT(pin) do{ if (pin < 8) SBI(DIDR0, pin); else SBI(DIDR2, pin - 8); }while(0)
  869. #else
  870. #define ANALOG_SELECT(pin) do{ SBI(DIDR0, pin); }while(0)
  871. #endif
  872. // Set analog inputs
  873. ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
  874. DIDR0 = 0;
  875. #ifdef DIDR2
  876. DIDR2 = 0;
  877. #endif
  878. #if HAS_TEMP_0
  879. ANALOG_SELECT(TEMP_0_PIN);
  880. #endif
  881. #if HAS_TEMP_1
  882. ANALOG_SELECT(TEMP_1_PIN);
  883. #endif
  884. #if HAS_TEMP_2
  885. ANALOG_SELECT(TEMP_2_PIN);
  886. #endif
  887. #if HAS_TEMP_3
  888. ANALOG_SELECT(TEMP_3_PIN);
  889. #endif
  890. #if HAS_TEMP_BED
  891. ANALOG_SELECT(TEMP_BED_PIN);
  892. #endif
  893. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  894. ANALOG_SELECT(FILWIDTH_PIN);
  895. #endif
  896. #if HAS_AUTO_FAN_0
  897. #if E0_AUTO_FAN_PIN == FAN1_PIN
  898. SET_OUTPUT(E0_AUTO_FAN_PIN);
  899. #if ENABLED(FAST_PWM_FAN)
  900. setPwmFrequency(E0_AUTO_FAN_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  901. #endif
  902. #else
  903. SET_OUTPUT(E0_AUTO_FAN_PIN);
  904. #endif
  905. #endif
  906. #if HAS_AUTO_FAN_1 && !AUTO_1_IS_0
  907. #if E1_AUTO_FAN_PIN == FAN1_PIN
  908. SET_OUTPUT(E1_AUTO_FAN_PIN);
  909. #if ENABLED(FAST_PWM_FAN)
  910. setPwmFrequency(E1_AUTO_FAN_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  911. #endif
  912. #else
  913. SET_OUTPUT(E1_AUTO_FAN_PIN);
  914. #endif
  915. #endif
  916. #if HAS_AUTO_FAN_2 && !AUTO_2_IS_0 && !AUTO_2_IS_1
  917. #if E2_AUTO_FAN_PIN == FAN1_PIN
  918. SET_OUTPUT(E2_AUTO_FAN_PIN);
  919. #if ENABLED(FAST_PWM_FAN)
  920. setPwmFrequency(E2_AUTO_FAN_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  921. #endif
  922. #else
  923. SET_OUTPUT(E2_AUTO_FAN_PIN);
  924. #endif
  925. #endif
  926. #if HAS_AUTO_FAN_3 && !AUTO_3_IS_0 && !AUTO_3_IS_1 && !AUTO_3_IS_2
  927. #if E3_AUTO_FAN_PIN == FAN1_PIN
  928. SET_OUTPUT(E3_AUTO_FAN_PIN);
  929. #if ENABLED(FAST_PWM_FAN)
  930. setPwmFrequency(E3_AUTO_FAN_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  931. #endif
  932. #else
  933. SET_OUTPUT(E3_AUTO_FAN_PIN);
  934. #endif
  935. #endif
  936. // Use timer0 for temperature measurement
  937. // Interleave temperature interrupt with millies interrupt
  938. OCR0B = 128;
  939. SBI(TIMSK0, OCIE0B);
  940. // Wait for temperature measurement to settle
  941. delay(250);
  942. #define TEMP_MIN_ROUTINE(NR) \
  943. minttemp[NR] = HEATER_ ## NR ## _MINTEMP; \
  944. while(analog2temp(minttemp_raw[NR], NR) < HEATER_ ## NR ## _MINTEMP) { \
  945. if (HEATER_ ## NR ## _RAW_LO_TEMP < HEATER_ ## NR ## _RAW_HI_TEMP) \
  946. minttemp_raw[NR] += OVERSAMPLENR; \
  947. else \
  948. minttemp_raw[NR] -= OVERSAMPLENR; \
  949. }
  950. #define TEMP_MAX_ROUTINE(NR) \
  951. maxttemp[NR] = HEATER_ ## NR ## _MAXTEMP; \
  952. while(analog2temp(maxttemp_raw[NR], NR) > HEATER_ ## NR ## _MAXTEMP) { \
  953. if (HEATER_ ## NR ## _RAW_LO_TEMP < HEATER_ ## NR ## _RAW_HI_TEMP) \
  954. maxttemp_raw[NR] -= OVERSAMPLENR; \
  955. else \
  956. maxttemp_raw[NR] += OVERSAMPLENR; \
  957. }
  958. #ifdef HEATER_0_MINTEMP
  959. TEMP_MIN_ROUTINE(0);
  960. #endif
  961. #ifdef HEATER_0_MAXTEMP
  962. TEMP_MAX_ROUTINE(0);
  963. #endif
  964. #if HOTENDS > 1
  965. #ifdef HEATER_1_MINTEMP
  966. TEMP_MIN_ROUTINE(1);
  967. #endif
  968. #ifdef HEATER_1_MAXTEMP
  969. TEMP_MAX_ROUTINE(1);
  970. #endif
  971. #if HOTENDS > 2
  972. #ifdef HEATER_2_MINTEMP
  973. TEMP_MIN_ROUTINE(2);
  974. #endif
  975. #ifdef HEATER_2_MAXTEMP
  976. TEMP_MAX_ROUTINE(2);
  977. #endif
  978. #if HOTENDS > 3
  979. #ifdef HEATER_3_MINTEMP
  980. TEMP_MIN_ROUTINE(3);
  981. #endif
  982. #ifdef HEATER_3_MAXTEMP
  983. TEMP_MAX_ROUTINE(3);
  984. #endif
  985. #endif // HOTENDS > 3
  986. #endif // HOTENDS > 2
  987. #endif // HOTENDS > 1
  988. #ifdef BED_MINTEMP
  989. while(analog2tempBed(bed_minttemp_raw) < BED_MINTEMP) {
  990. #if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
  991. bed_minttemp_raw += OVERSAMPLENR;
  992. #else
  993. bed_minttemp_raw -= OVERSAMPLENR;
  994. #endif
  995. }
  996. #endif //BED_MINTEMP
  997. #ifdef BED_MAXTEMP
  998. while (analog2tempBed(bed_maxttemp_raw) > BED_MAXTEMP) {
  999. #if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
  1000. bed_maxttemp_raw -= OVERSAMPLENR;
  1001. #else
  1002. bed_maxttemp_raw += OVERSAMPLENR;
  1003. #endif
  1004. }
  1005. #endif //BED_MAXTEMP
  1006. }
  1007. #if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
  1008. /**
  1009. * Start Heating Sanity Check for hotends that are below
  1010. * their target temperature by a configurable margin.
  1011. * This is called when the temperature is set. (M104, M109)
  1012. */
  1013. void Temperature::start_watching_heater(uint8_t e) {
  1014. #if HOTENDS == 1
  1015. UNUSED(e);
  1016. #endif
  1017. if (degHotend(HOTEND_INDEX) < degTargetHotend(HOTEND_INDEX) - (WATCH_TEMP_INCREASE + TEMP_HYSTERESIS + 1)) {
  1018. watch_target_temp[HOTEND_INDEX] = degHotend(HOTEND_INDEX) + WATCH_TEMP_INCREASE;
  1019. watch_heater_next_ms[HOTEND_INDEX] = millis() + (WATCH_TEMP_PERIOD) * 1000UL;
  1020. }
  1021. else
  1022. watch_heater_next_ms[HOTEND_INDEX] = 0;
  1023. }
  1024. #endif
  1025. #if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
  1026. /**
  1027. * Start Heating Sanity Check for hotends that are below
  1028. * their target temperature by a configurable margin.
  1029. * This is called when the temperature is set. (M140, M190)
  1030. */
  1031. void Temperature::start_watching_bed() {
  1032. if (degBed() < degTargetBed() - (WATCH_BED_TEMP_INCREASE + TEMP_BED_HYSTERESIS + 1)) {
  1033. watch_target_bed_temp = degBed() + WATCH_BED_TEMP_INCREASE;
  1034. watch_bed_next_ms = millis() + (WATCH_BED_TEMP_PERIOD) * 1000UL;
  1035. }
  1036. else
  1037. watch_bed_next_ms = 0;
  1038. }
  1039. #endif
  1040. #if ENABLED(THERMAL_PROTECTION_HOTENDS) || HAS_THERMALLY_PROTECTED_BED
  1041. #if ENABLED(THERMAL_PROTECTION_HOTENDS)
  1042. Temperature::TRState Temperature::thermal_runaway_state_machine[HOTENDS] = { TRInactive };
  1043. millis_t Temperature::thermal_runaway_timer[HOTENDS] = { 0 };
  1044. #endif
  1045. #if HAS_THERMALLY_PROTECTED_BED
  1046. Temperature::TRState Temperature::thermal_runaway_bed_state_machine = TRInactive;
  1047. millis_t Temperature::thermal_runaway_bed_timer;
  1048. #endif
  1049. void Temperature::thermal_runaway_protection(Temperature::TRState* state, millis_t* timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc) {
  1050. static float tr_target_temperature[HOTENDS + 1] = { 0.0 };
  1051. /**
  1052. SERIAL_ECHO_START;
  1053. SERIAL_ECHOPGM("Thermal Thermal Runaway Running. Heater ID: ");
  1054. if (heater_id < 0) SERIAL_ECHOPGM("bed"); else SERIAL_ECHO(heater_id);
  1055. SERIAL_ECHOPAIR(" ; State:", *state);
  1056. SERIAL_ECHOPAIR(" ; Timer:", *timer);
  1057. SERIAL_ECHOPAIR(" ; Temperature:", temperature);
  1058. SERIAL_ECHOPAIR(" ; Target Temp:", target_temperature);
  1059. SERIAL_EOL;
  1060. */
  1061. int heater_index = heater_id >= 0 ? heater_id : HOTENDS;
  1062. // If the target temperature changes, restart
  1063. if (tr_target_temperature[heater_index] != target_temperature) {
  1064. tr_target_temperature[heater_index] = target_temperature;
  1065. *state = target_temperature > 0 ? TRFirstHeating : TRInactive;
  1066. }
  1067. switch (*state) {
  1068. // Inactive state waits for a target temperature to be set
  1069. case TRInactive: break;
  1070. // When first heating, wait for the temperature to be reached then go to Stable state
  1071. case TRFirstHeating:
  1072. if (temperature < tr_target_temperature[heater_index]) break;
  1073. *state = TRStable;
  1074. // While the temperature is stable watch for a bad temperature
  1075. case TRStable:
  1076. if (temperature >= tr_target_temperature[heater_index] - hysteresis_degc) {
  1077. *timer = millis() + period_seconds * 1000UL;
  1078. break;
  1079. }
  1080. else if (PENDING(millis(), *timer)) break;
  1081. *state = TRRunaway;
  1082. case TRRunaway:
  1083. _temp_error(heater_id, PSTR(MSG_T_THERMAL_RUNAWAY), PSTR(MSG_THERMAL_RUNAWAY));
  1084. }
  1085. }
  1086. #endif // THERMAL_PROTECTION_HOTENDS || THERMAL_PROTECTION_BED
  1087. void Temperature::disable_all_heaters() {
  1088. HOTEND_LOOP() setTargetHotend(0, e);
  1089. setTargetBed(0);
  1090. // If all heaters go down then for sure our print job has stopped
  1091. print_job_timer.stop();
  1092. #define DISABLE_HEATER(NR) { \
  1093. setTargetHotend(0, NR); \
  1094. soft_pwm[NR] = 0; \
  1095. WRITE_HEATER_ ## NR (LOW); \
  1096. }
  1097. #if HAS_TEMP_HOTEND
  1098. DISABLE_HEATER(0);
  1099. #endif
  1100. #if HOTENDS > 1 && HAS_TEMP_1
  1101. DISABLE_HEATER(1);
  1102. #endif
  1103. #if HOTENDS > 2 && HAS_TEMP_2
  1104. DISABLE_HEATER(2);
  1105. #endif
  1106. #if HOTENDS > 3 && HAS_TEMP_3
  1107. DISABLE_HEATER(3);
  1108. #endif
  1109. #if HAS_TEMP_BED
  1110. target_temperature_bed = 0;
  1111. soft_pwm_bed = 0;
  1112. #if HAS_HEATER_BED
  1113. WRITE_HEATER_BED(LOW);
  1114. #endif
  1115. #endif
  1116. }
  1117. #if ENABLED(HEATER_0_USES_MAX6675)
  1118. #define MAX6675_HEAT_INTERVAL 250u
  1119. #if ENABLED(MAX6675_IS_MAX31855)
  1120. uint32_t max6675_temp = 2000;
  1121. #define MAX6675_ERROR_MASK 7
  1122. #define MAX6675_DISCARD_BITS 18
  1123. #define MAX6675_SPEED_BITS (_BV(SPR1)) // clock ÷ 64
  1124. #else
  1125. uint16_t max6675_temp = 2000;
  1126. #define MAX6675_ERROR_MASK 4
  1127. #define MAX6675_DISCARD_BITS 3
  1128. #define MAX6675_SPEED_BITS (_BV(SPR0)) // clock ÷ 16
  1129. #endif
  1130. int Temperature::read_max6675() {
  1131. static millis_t next_max6675_ms = 0;
  1132. millis_t ms = millis();
  1133. if (PENDING(ms, next_max6675_ms)) return (int)max6675_temp;
  1134. next_max6675_ms = ms + MAX6675_HEAT_INTERVAL;
  1135. CBI(
  1136. #ifdef PRR
  1137. PRR
  1138. #elif defined(PRR0)
  1139. PRR0
  1140. #endif
  1141. , PRSPI);
  1142. SPCR = _BV(MSTR) | _BV(SPE) | MAX6675_SPEED_BITS;
  1143. WRITE(MAX6675_SS, 0); // enable TT_MAX6675
  1144. // ensure 100ns delay - a bit extra is fine
  1145. asm("nop");//50ns on 20Mhz, 62.5ns on 16Mhz
  1146. asm("nop");//50ns on 20Mhz, 62.5ns on 16Mhz
  1147. // Read a big-endian temperature value
  1148. max6675_temp = 0;
  1149. for (uint8_t i = sizeof(max6675_temp); i--;) {
  1150. SPDR = 0;
  1151. for (;!TEST(SPSR, SPIF););
  1152. max6675_temp |= SPDR;
  1153. if (i > 0) max6675_temp <<= 8; // shift left if not the last byte
  1154. }
  1155. WRITE(MAX6675_SS, 1); // disable TT_MAX6675
  1156. if (max6675_temp & MAX6675_ERROR_MASK) {
  1157. SERIAL_ERROR_START;
  1158. SERIAL_ERRORPGM("Temp measurement error! ");
  1159. #if MAX6675_ERROR_MASK == 7
  1160. SERIAL_ERRORPGM("MAX31855 ");
  1161. if (max6675_temp & 1)
  1162. SERIAL_ERRORLNPGM("Open Circuit");
  1163. else if (max6675_temp & 2)
  1164. SERIAL_ERRORLNPGM("Short to GND");
  1165. else if (max6675_temp & 4)
  1166. SERIAL_ERRORLNPGM("Short to VCC");
  1167. #else
  1168. SERIAL_ERRORLNPGM("MAX6675");
  1169. #endif
  1170. max6675_temp = MAX6675_TMAX * 4; // thermocouple open
  1171. }
  1172. else
  1173. max6675_temp >>= MAX6675_DISCARD_BITS;
  1174. #if ENABLED(MAX6675_IS_MAX31855)
  1175. // Support negative temperature
  1176. if (max6675_temp & 0x00002000) max6675_temp |= 0xffffc000;
  1177. #endif
  1178. return (int)max6675_temp;
  1179. }
  1180. #endif //HEATER_0_USES_MAX6675
  1181. /**
  1182. * Get raw temperatures
  1183. */
  1184. void Temperature::set_current_temp_raw() {
  1185. #if HAS_TEMP_0 && DISABLED(HEATER_0_USES_MAX6675)
  1186. current_temperature_raw[0] = raw_temp_value[0];
  1187. #endif
  1188. #if HAS_TEMP_1
  1189. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  1190. redundant_temperature_raw = raw_temp_value[1];
  1191. #else
  1192. current_temperature_raw[1] = raw_temp_value[1];
  1193. #endif
  1194. #if HAS_TEMP_2
  1195. current_temperature_raw[2] = raw_temp_value[2];
  1196. #if HAS_TEMP_3
  1197. current_temperature_raw[3] = raw_temp_value[3];
  1198. #endif
  1199. #endif
  1200. #endif
  1201. current_temperature_bed_raw = raw_temp_bed_value;
  1202. temp_meas_ready = true;
  1203. }
  1204. #if ENABLED(PINS_DEBUGGING)
  1205. /**
  1206. * monitors endstops & Z probe for changes
  1207. *
  1208. * If a change is detected then the LED is toggled and
  1209. * a message is sent out the serial port
  1210. *
  1211. * Yes, we could miss a rapid back & forth change but
  1212. * that won't matter because this is all manual.
  1213. *
  1214. */
  1215. void endstop_monitor() {
  1216. static uint16_t old_endstop_bits_local = 0;
  1217. static uint8_t local_LED_status = 0;
  1218. uint16_t current_endstop_bits_local = 0;
  1219. #if HAS_X_MIN
  1220. if (READ(X_MIN_PIN)) SBI(current_endstop_bits_local, X_MIN);
  1221. #endif
  1222. #if HAS_X_MAX
  1223. if (READ(X_MAX_PIN)) SBI(current_endstop_bits_local, X_MAX);
  1224. #endif
  1225. #if HAS_Y_MIN
  1226. if (READ(Y_MIN_PIN)) SBI(current_endstop_bits_local, Y_MIN);
  1227. #endif
  1228. #if HAS_Y_MAX
  1229. if (READ(Y_MAX_PIN)) SBI(current_endstop_bits_local, Y_MAX);
  1230. #endif
  1231. #if HAS_Z_MIN
  1232. if (READ(Z_MIN_PIN)) SBI(current_endstop_bits_local, Z_MIN);
  1233. #endif
  1234. #if HAS_Z_MAX
  1235. if (READ(Z_MAX_PIN)) SBI(current_endstop_bits_local, Z_MAX);
  1236. #endif
  1237. #if HAS_Z_MIN_PROBE_PIN
  1238. if (READ(Z_MIN_PROBE_PIN)) SBI(current_endstop_bits_local, Z_MIN_PROBE);
  1239. #endif
  1240. #if HAS_Z2_MIN
  1241. if (READ(Z2_MIN_PIN)) SBI(current_endstop_bits_local, Z2_MIN);
  1242. #endif
  1243. #if HAS_Z2_MAX
  1244. if (READ(Z2_MAX_PIN)) SBI(current_endstop_bits_local, Z2_MAX);
  1245. #endif
  1246. uint16_t endstop_change = current_endstop_bits_local ^ old_endstop_bits_local;
  1247. if (endstop_change) {
  1248. #if HAS_X_MIN
  1249. if (TEST(endstop_change, X_MIN)) SERIAL_PROTOCOLPAIR("X_MIN:", !!TEST(current_endstop_bits_local, X_MIN));
  1250. #endif
  1251. #if HAS_X_MAX
  1252. if (TEST(endstop_change, X_MAX)) SERIAL_PROTOCOLPAIR(" X_MAX:", !!TEST(current_endstop_bits_local, X_MAX));
  1253. #endif
  1254. #if HAS_Y_MIN
  1255. if (TEST(endstop_change, Y_MIN)) SERIAL_PROTOCOLPAIR(" Y_MIN:", !!TEST(current_endstop_bits_local, Y_MIN));
  1256. #endif
  1257. #if HAS_Y_MAX
  1258. if (TEST(endstop_change, Y_MAX)) SERIAL_PROTOCOLPAIR(" Y_MAX:", !!TEST(current_endstop_bits_local, Y_MAX));
  1259. #endif
  1260. #if HAS_Z_MIN
  1261. if (TEST(endstop_change, Z_MIN)) SERIAL_PROTOCOLPAIR(" Z_MIN:", !!TEST(current_endstop_bits_local, Z_MIN));
  1262. #endif
  1263. #if HAS_Z_MAX
  1264. if (TEST(endstop_change, Z_MAX)) SERIAL_PROTOCOLPAIR(" Z_MAX:", !!TEST(current_endstop_bits_local, Z_MAX));
  1265. #endif
  1266. #if HAS_Z_MIN_PROBE_PIN
  1267. if (TEST(endstop_change, Z_MIN_PROBE)) SERIAL_PROTOCOLPAIR(" PROBE:", !!TEST(current_endstop_bits_local, Z_MIN_PROBE));
  1268. #endif
  1269. #if HAS_Z2_MIN
  1270. if (TEST(endstop_change, Z2_MIN)) SERIAL_PROTOCOLPAIR(" Z2_MIN:", !!TEST(current_endstop_bits_local, Z2_MIN));
  1271. #endif
  1272. #if HAS_Z2_MAX
  1273. if (TEST(endstop_change, Z2_MAX)) SERIAL_PROTOCOLPAIR(" Z2_MAX:", !!TEST(current_endstop_bits_local, Z2_MAX));
  1274. #endif
  1275. SERIAL_PROTOCOLPGM("\n\n");
  1276. analogWrite(LED_PIN, local_LED_status);
  1277. local_LED_status ^= 255;
  1278. old_endstop_bits_local = current_endstop_bits_local;
  1279. }
  1280. }
  1281. #endif // PINS_DEBUGGING
  1282. /**
  1283. * Timer 0 is shared with millies so don't change the prescaler.
  1284. *
  1285. * This ISR uses the compare method so it runs at the base
  1286. * frequency (16 MHz / 64 / 256 = 976.5625 Hz), but at the TCNT0 set
  1287. * in OCR0B above (128 or halfway between OVFs).
  1288. *
  1289. * - Manage PWM to all the heaters and fan
  1290. * - Update the raw temperature values
  1291. * - Check new temperature values for MIN/MAX errors
  1292. * - Step the babysteps value for each axis towards 0
  1293. */
  1294. ISR(TIMER0_COMPB_vect) { Temperature::isr(); }
  1295. void Temperature::isr() {
  1296. //Allow UART and stepper ISRs
  1297. CBI(TIMSK0, OCIE0B); //Disable Temperature ISR
  1298. sei();
  1299. static uint8_t temp_count = 0;
  1300. static TempState temp_state = StartupDelay;
  1301. static uint8_t pwm_count = _BV(SOFT_PWM_SCALE);
  1302. // Static members for each heater
  1303. #if ENABLED(SLOW_PWM_HEATERS)
  1304. static uint8_t slow_pwm_count = 0;
  1305. #define ISR_STATICS(n) \
  1306. static uint8_t soft_pwm_ ## n; \
  1307. static uint8_t state_heater_ ## n = 0; \
  1308. static uint8_t state_timer_heater_ ## n = 0
  1309. #else
  1310. #define ISR_STATICS(n) static uint8_t soft_pwm_ ## n
  1311. #endif
  1312. // Statics per heater
  1313. ISR_STATICS(0);
  1314. #if HOTENDS > 1
  1315. ISR_STATICS(1);
  1316. #if HOTENDS > 2
  1317. ISR_STATICS(2);
  1318. #if HOTENDS > 3
  1319. ISR_STATICS(3);
  1320. #endif
  1321. #endif
  1322. #endif
  1323. #if HAS_HEATER_BED
  1324. ISR_STATICS(BED);
  1325. #endif
  1326. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  1327. static unsigned long raw_filwidth_value = 0;
  1328. #endif
  1329. #if DISABLED(SLOW_PWM_HEATERS)
  1330. /**
  1331. * Standard PWM modulation
  1332. */
  1333. if (pwm_count == 0) {
  1334. soft_pwm_0 = soft_pwm[0];
  1335. WRITE_HEATER_0(soft_pwm_0 > 0 ? 1 : 0);
  1336. #if HOTENDS > 1
  1337. soft_pwm_1 = soft_pwm[1];
  1338. WRITE_HEATER_1(soft_pwm_1 > 0 ? 1 : 0);
  1339. #if HOTENDS > 2
  1340. soft_pwm_2 = soft_pwm[2];
  1341. WRITE_HEATER_2(soft_pwm_2 > 0 ? 1 : 0);
  1342. #if HOTENDS > 3
  1343. soft_pwm_3 = soft_pwm[3];
  1344. WRITE_HEATER_3(soft_pwm_3 > 0 ? 1 : 0);
  1345. #endif
  1346. #endif
  1347. #endif
  1348. #if HAS_HEATER_BED
  1349. soft_pwm_BED = soft_pwm_bed;
  1350. WRITE_HEATER_BED(soft_pwm_BED > 0 ? 1 : 0);
  1351. #endif
  1352. #if ENABLED(FAN_SOFT_PWM)
  1353. #if HAS_FAN0
  1354. soft_pwm_fan[0] = fanSpeedSoftPwm[0] >> 1;
  1355. WRITE_FAN(soft_pwm_fan[0] > 0 ? 1 : 0);
  1356. #endif
  1357. #if HAS_FAN1
  1358. soft_pwm_fan[1] = fanSpeedSoftPwm[1] >> 1;
  1359. WRITE_FAN1(soft_pwm_fan[1] > 0 ? 1 : 0);
  1360. #endif
  1361. #if HAS_FAN2
  1362. soft_pwm_fan[2] = fanSpeedSoftPwm[2] >> 1;
  1363. WRITE_FAN2(soft_pwm_fan[2] > 0 ? 1 : 0);
  1364. #endif
  1365. #endif
  1366. }
  1367. if (soft_pwm_0 < pwm_count) WRITE_HEATER_0(0);
  1368. #if HOTENDS > 1
  1369. if (soft_pwm_1 < pwm_count) WRITE_HEATER_1(0);
  1370. #if HOTENDS > 2
  1371. if (soft_pwm_2 < pwm_count) WRITE_HEATER_2(0);
  1372. #if HOTENDS > 3
  1373. if (soft_pwm_3 < pwm_count) WRITE_HEATER_3(0);
  1374. #endif
  1375. #endif
  1376. #endif
  1377. #if HAS_HEATER_BED
  1378. if (soft_pwm_BED < pwm_count) WRITE_HEATER_BED(0);
  1379. #endif
  1380. #if ENABLED(FAN_SOFT_PWM)
  1381. #if HAS_FAN0
  1382. if (soft_pwm_fan[0] < pwm_count) WRITE_FAN(0);
  1383. #endif
  1384. #if HAS_FAN1
  1385. if (soft_pwm_fan[1] < pwm_count) WRITE_FAN1(0);
  1386. #endif
  1387. #if HAS_FAN2
  1388. if (soft_pwm_fan[2] < pwm_count) WRITE_FAN2(0);
  1389. #endif
  1390. #endif
  1391. // SOFT_PWM_SCALE to frequency:
  1392. //
  1393. // 0: 16000000/64/256/128 = 7.6294 Hz
  1394. // 1: / 64 = 15.2588 Hz
  1395. // 2: / 32 = 30.5176 Hz
  1396. // 3: / 16 = 61.0352 Hz
  1397. // 4: / 8 = 122.0703 Hz
  1398. // 5: / 4 = 244.1406 Hz
  1399. pwm_count += _BV(SOFT_PWM_SCALE);
  1400. pwm_count &= 0x7F;
  1401. #else // SLOW_PWM_HEATERS
  1402. /**
  1403. * SLOW PWM HEATERS
  1404. *
  1405. * For relay-driven heaters
  1406. */
  1407. #ifndef MIN_STATE_TIME
  1408. #define MIN_STATE_TIME 16 // MIN_STATE_TIME * 65.5 = time in milliseconds
  1409. #endif
  1410. // Macros for Slow PWM timer logic
  1411. #define _SLOW_PWM_ROUTINE(NR, src) \
  1412. soft_pwm_ ## NR = src; \
  1413. if (soft_pwm_ ## NR > 0) { \
  1414. if (state_timer_heater_ ## NR == 0) { \
  1415. if (state_heater_ ## NR == 0) state_timer_heater_ ## NR = MIN_STATE_TIME; \
  1416. state_heater_ ## NR = 1; \
  1417. WRITE_HEATER_ ## NR(1); \
  1418. } \
  1419. } \
  1420. else { \
  1421. if (state_timer_heater_ ## NR == 0) { \
  1422. if (state_heater_ ## NR == 1) state_timer_heater_ ## NR = MIN_STATE_TIME; \
  1423. state_heater_ ## NR = 0; \
  1424. WRITE_HEATER_ ## NR(0); \
  1425. } \
  1426. }
  1427. #define SLOW_PWM_ROUTINE(n) _SLOW_PWM_ROUTINE(n, soft_pwm[n])
  1428. #define PWM_OFF_ROUTINE(NR) \
  1429. if (soft_pwm_ ## NR < slow_pwm_count) { \
  1430. if (state_timer_heater_ ## NR == 0) { \
  1431. if (state_heater_ ## NR == 1) state_timer_heater_ ## NR = MIN_STATE_TIME; \
  1432. state_heater_ ## NR = 0; \
  1433. WRITE_HEATER_ ## NR (0); \
  1434. } \
  1435. }
  1436. if (slow_pwm_count == 0) {
  1437. SLOW_PWM_ROUTINE(0); // EXTRUDER 0
  1438. #if HOTENDS > 1
  1439. SLOW_PWM_ROUTINE(1); // EXTRUDER 1
  1440. #if HOTENDS > 2
  1441. SLOW_PWM_ROUTINE(2); // EXTRUDER 2
  1442. #if HOTENDS > 3
  1443. SLOW_PWM_ROUTINE(3); // EXTRUDER 3
  1444. #endif
  1445. #endif
  1446. #endif
  1447. #if HAS_HEATER_BED
  1448. _SLOW_PWM_ROUTINE(BED, soft_pwm_bed); // BED
  1449. #endif
  1450. } // slow_pwm_count == 0
  1451. PWM_OFF_ROUTINE(0); // EXTRUDER 0
  1452. #if HOTENDS > 1
  1453. PWM_OFF_ROUTINE(1); // EXTRUDER 1
  1454. #if HOTENDS > 2
  1455. PWM_OFF_ROUTINE(2); // EXTRUDER 2
  1456. #if HOTENDS > 3
  1457. PWM_OFF_ROUTINE(3); // EXTRUDER 3
  1458. #endif
  1459. #endif
  1460. #endif
  1461. #if HAS_HEATER_BED
  1462. PWM_OFF_ROUTINE(BED); // BED
  1463. #endif
  1464. #if ENABLED(FAN_SOFT_PWM)
  1465. if (pwm_count == 0) {
  1466. #if HAS_FAN0
  1467. soft_pwm_fan[0] = fanSpeedSoftPwm[0] >> 1;
  1468. WRITE_FAN(soft_pwm_fan[0] > 0 ? 1 : 0);
  1469. #endif
  1470. #if HAS_FAN1
  1471. soft_pwm_fan[1] = fanSpeedSoftPwm[1] >> 1;
  1472. WRITE_FAN1(soft_pwm_fan[1] > 0 ? 1 : 0);
  1473. #endif
  1474. #if HAS_FAN2
  1475. soft_pwm_fan[2] = fanSpeedSoftPwm[2] >> 1;
  1476. WRITE_FAN2(soft_pwm_fan[2] > 0 ? 1 : 0);
  1477. #endif
  1478. }
  1479. #if HAS_FAN0
  1480. if (soft_pwm_fan[0] < pwm_count) WRITE_FAN(0);
  1481. #endif
  1482. #if HAS_FAN1
  1483. if (soft_pwm_fan[1] < pwm_count) WRITE_FAN1(0);
  1484. #endif
  1485. #if HAS_FAN2
  1486. if (soft_pwm_fan[2] < pwm_count) WRITE_FAN2(0);
  1487. #endif
  1488. #endif //FAN_SOFT_PWM
  1489. // SOFT_PWM_SCALE to frequency:
  1490. //
  1491. // 0: 16000000/64/256/128 = 7.6294 Hz
  1492. // 1: / 64 = 15.2588 Hz
  1493. // 2: / 32 = 30.5176 Hz
  1494. // 3: / 16 = 61.0352 Hz
  1495. // 4: / 8 = 122.0703 Hz
  1496. // 5: / 4 = 244.1406 Hz
  1497. pwm_count += _BV(SOFT_PWM_SCALE);
  1498. pwm_count &= 0x7F;
  1499. // increment slow_pwm_count only every 64 pwm_count (e.g., every 8s)
  1500. if ((pwm_count % 64) == 0) {
  1501. slow_pwm_count++;
  1502. slow_pwm_count &= 0x7f;
  1503. // EXTRUDER 0
  1504. if (state_timer_heater_0 > 0) state_timer_heater_0--;
  1505. #if HOTENDS > 1 // EXTRUDER 1
  1506. if (state_timer_heater_1 > 0) state_timer_heater_1--;
  1507. #if HOTENDS > 2 // EXTRUDER 2
  1508. if (state_timer_heater_2 > 0) state_timer_heater_2--;
  1509. #if HOTENDS > 3 // EXTRUDER 3
  1510. if (state_timer_heater_3 > 0) state_timer_heater_3--;
  1511. #endif
  1512. #endif
  1513. #endif
  1514. #if HAS_HEATER_BED
  1515. if (state_timer_heater_BED > 0) state_timer_heater_BED--;
  1516. #endif
  1517. } // (pwm_count % 64) == 0
  1518. #endif // SLOW_PWM_HEATERS
  1519. #define SET_ADMUX_ADCSRA(pin) ADMUX = _BV(REFS0) | (pin & 0x07); SBI(ADCSRA, ADSC)
  1520. #ifdef MUX5
  1521. #define START_ADC(pin) if (pin > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
  1522. #else
  1523. #define START_ADC(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
  1524. #endif
  1525. // Prepare or measure a sensor, each one every 12th frame
  1526. switch (temp_state) {
  1527. case PrepareTemp_0:
  1528. #if HAS_TEMP_0
  1529. START_ADC(TEMP_0_PIN);
  1530. #endif
  1531. lcd_buttons_update();
  1532. temp_state = MeasureTemp_0;
  1533. break;
  1534. case MeasureTemp_0:
  1535. #if HAS_TEMP_0
  1536. raw_temp_value[0] += ADC;
  1537. #endif
  1538. temp_state = PrepareTemp_BED;
  1539. break;
  1540. case PrepareTemp_BED:
  1541. #if HAS_TEMP_BED
  1542. START_ADC(TEMP_BED_PIN);
  1543. #endif
  1544. lcd_buttons_update();
  1545. temp_state = MeasureTemp_BED;
  1546. break;
  1547. case MeasureTemp_BED:
  1548. #if HAS_TEMP_BED
  1549. raw_temp_bed_value += ADC;
  1550. #endif
  1551. temp_state = PrepareTemp_1;
  1552. break;
  1553. case PrepareTemp_1:
  1554. #if HAS_TEMP_1
  1555. START_ADC(TEMP_1_PIN);
  1556. #endif
  1557. lcd_buttons_update();
  1558. temp_state = MeasureTemp_1;
  1559. break;
  1560. case MeasureTemp_1:
  1561. #if HAS_TEMP_1
  1562. raw_temp_value[1] += ADC;
  1563. #endif
  1564. temp_state = PrepareTemp_2;
  1565. break;
  1566. case PrepareTemp_2:
  1567. #if HAS_TEMP_2
  1568. START_ADC(TEMP_2_PIN);
  1569. #endif
  1570. lcd_buttons_update();
  1571. temp_state = MeasureTemp_2;
  1572. break;
  1573. case MeasureTemp_2:
  1574. #if HAS_TEMP_2
  1575. raw_temp_value[2] += ADC;
  1576. #endif
  1577. temp_state = PrepareTemp_3;
  1578. break;
  1579. case PrepareTemp_3:
  1580. #if HAS_TEMP_3
  1581. START_ADC(TEMP_3_PIN);
  1582. #endif
  1583. lcd_buttons_update();
  1584. temp_state = MeasureTemp_3;
  1585. break;
  1586. case MeasureTemp_3:
  1587. #if HAS_TEMP_3
  1588. raw_temp_value[3] += ADC;
  1589. #endif
  1590. temp_state = Prepare_FILWIDTH;
  1591. break;
  1592. case Prepare_FILWIDTH:
  1593. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  1594. START_ADC(FILWIDTH_PIN);
  1595. #endif
  1596. lcd_buttons_update();
  1597. temp_state = Measure_FILWIDTH;
  1598. break;
  1599. case Measure_FILWIDTH:
  1600. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  1601. // raw_filwidth_value += ADC; //remove to use an IIR filter approach
  1602. if (ADC > 102) { //check that ADC is reading a voltage > 0.5 volts, otherwise don't take in the data.
  1603. raw_filwidth_value -= (raw_filwidth_value >> 7); //multiply raw_filwidth_value by 127/128
  1604. raw_filwidth_value += ((unsigned long)ADC << 7); //add new ADC reading
  1605. }
  1606. #endif
  1607. temp_state = PrepareTemp_0;
  1608. temp_count++;
  1609. break;
  1610. case StartupDelay:
  1611. temp_state = PrepareTemp_0;
  1612. break;
  1613. // default:
  1614. // SERIAL_ERROR_START;
  1615. // SERIAL_ERRORLNPGM("Temp measurement error!");
  1616. // break;
  1617. } // switch(temp_state)
  1618. if (temp_count >= OVERSAMPLENR) { // 10 * 16 * 1/(16000000/64/256) = 164ms.
  1619. temp_count = 0;
  1620. // Update the raw values if they've been read. Else we could be updating them during reading.
  1621. if (!temp_meas_ready) set_current_temp_raw();
  1622. // Filament Sensor - can be read any time since IIR filtering is used
  1623. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  1624. current_raw_filwidth = raw_filwidth_value >> 10; // Divide to get to 0-16384 range since we used 1/128 IIR filter approach
  1625. #endif
  1626. ZERO(raw_temp_value);
  1627. raw_temp_bed_value = 0;
  1628. int constexpr temp_dir[] = {
  1629. #if ENABLED(HEATER_0_USES_MAX6675)
  1630. 0
  1631. #elif HEATER_0_RAW_LO_TEMP > HEATER_0_RAW_HI_TEMP
  1632. -1
  1633. #else
  1634. 1
  1635. #endif
  1636. #if HAS_TEMP_1 && HOTENDS > 1
  1637. #if HEATER_1_RAW_LO_TEMP > HEATER_1_RAW_HI_TEMP
  1638. , -1
  1639. #else
  1640. , 1
  1641. #endif
  1642. #endif
  1643. #if HAS_TEMP_2 && HOTENDS > 2
  1644. #if HEATER_2_RAW_LO_TEMP > HEATER_2_RAW_HI_TEMP
  1645. , -1
  1646. #else
  1647. , 1
  1648. #endif
  1649. #endif
  1650. #if HAS_TEMP_3 && HOTENDS > 3
  1651. #if HEATER_3_RAW_LO_TEMP > HEATER_3_RAW_HI_TEMP
  1652. , -1
  1653. #else
  1654. , 1
  1655. #endif
  1656. #endif
  1657. };
  1658. for (uint8_t e = 0; e < COUNT(temp_dir); e++) {
  1659. const int tdir = temp_dir[e], rawtemp = current_temperature_raw[e] * tdir;
  1660. if (rawtemp > maxttemp_raw[e] * tdir && target_temperature[e] > 0.0f) max_temp_error(e);
  1661. if (rawtemp < minttemp_raw[e] * tdir && !is_preheating(e) && target_temperature[e] > 0.0f) {
  1662. #ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
  1663. if (++consecutive_low_temperature_error[e] >= MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED)
  1664. #endif
  1665. min_temp_error(e);
  1666. }
  1667. #ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
  1668. else
  1669. consecutive_low_temperature_error[e] = 0;
  1670. #endif
  1671. }
  1672. #if HAS_TEMP_BED
  1673. #if HEATER_BED_RAW_LO_TEMP > HEATER_BED_RAW_HI_TEMP
  1674. #define GEBED <=
  1675. #else
  1676. #define GEBED >=
  1677. #endif
  1678. if (current_temperature_bed_raw GEBED bed_maxttemp_raw && target_temperature_bed > 0.0f) max_temp_error(-1);
  1679. if (bed_minttemp_raw GEBED current_temperature_bed_raw && target_temperature_bed > 0.0f) min_temp_error(-1);
  1680. #endif
  1681. } // temp_count >= OVERSAMPLENR
  1682. #if ENABLED(BABYSTEPPING)
  1683. LOOP_XYZ(axis) {
  1684. int curTodo = babystepsTodo[axis]; //get rid of volatile for performance
  1685. if (curTodo > 0) {
  1686. stepper.babystep((AxisEnum)axis,/*fwd*/true);
  1687. babystepsTodo[axis]--; //fewer to do next time
  1688. }
  1689. else if (curTodo < 0) {
  1690. stepper.babystep((AxisEnum)axis,/*fwd*/false);
  1691. babystepsTodo[axis]++; //fewer to do next time
  1692. }
  1693. }
  1694. #endif //BABYSTEPPING
  1695. #if ENABLED(PINS_DEBUGGING)
  1696. extern bool endstop_monitor_flag;
  1697. // run the endstop monitor at 15Hz
  1698. static uint8_t endstop_monitor_count = 16; // offset this check from the others
  1699. if (endstop_monitor_flag) {
  1700. endstop_monitor_count += _BV(1); // 15 Hz
  1701. endstop_monitor_count &= 0x7F;
  1702. if (!endstop_monitor_count) endstop_monitor(); // report changes in endstop status
  1703. }
  1704. #endif
  1705. SBI(TIMSK0, OCIE0B); //re-enable Temperature ISR
  1706. }