My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

temperature.cpp 50KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656
  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 "language.h"
  29. #include "Sd2PinMap.h"
  30. #if ENABLED(USE_WATCHDOG)
  31. #include "watchdog.h"
  32. #endif
  33. #ifdef K1 // Defined in Configuration.h in the PID settings
  34. #define K2 (1.0-K1)
  35. #endif
  36. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  37. static void* heater_ttbl_map[2] = {(void*)HEATER_0_TEMPTABLE, (void*)HEATER_1_TEMPTABLE };
  38. static uint8_t heater_ttbllen_map[2] = { HEATER_0_TEMPTABLE_LEN, HEATER_1_TEMPTABLE_LEN };
  39. #else
  40. static void* heater_ttbl_map[EXTRUDERS] = ARRAY_BY_EXTRUDERS((void*)HEATER_0_TEMPTABLE, (void*)HEATER_1_TEMPTABLE, (void*)HEATER_2_TEMPTABLE, (void*)HEATER_3_TEMPTABLE);
  41. static uint8_t heater_ttbllen_map[EXTRUDERS] = ARRAY_BY_EXTRUDERS(HEATER_0_TEMPTABLE_LEN, HEATER_1_TEMPTABLE_LEN, HEATER_2_TEMPTABLE_LEN, HEATER_3_TEMPTABLE_LEN);
  42. #endif
  43. Temperature thermalManager;
  44. #if HAS_PID_HEATING
  45. void Temperature::PID_autotune(float temp, int extruder, int ncycles, bool set_result/*=false*/) {
  46. float input = 0.0;
  47. int cycles = 0;
  48. bool heating = true;
  49. millis_t temp_ms = millis(), t1 = temp_ms, t2 = temp_ms;
  50. long t_high = 0, t_low = 0;
  51. long bias, d;
  52. float Ku, Tu;
  53. float workKp = 0, workKi = 0, workKd = 0;
  54. float max = 0, min = 10000;
  55. #if HAS_AUTO_FAN
  56. next_auto_fan_check_ms = temp_ms + 2500UL;
  57. #endif
  58. if (false
  59. #if ENABLED(PIDTEMP)
  60. || extruder >= EXTRUDERS
  61. #else
  62. || extruder >= 0
  63. #endif
  64. #if DISABLED(PIDTEMPBED)
  65. || extruder < 0
  66. #endif
  67. ) {
  68. SERIAL_ECHOLN(MSG_PID_BAD_EXTRUDER_NUM);
  69. return;
  70. }
  71. SERIAL_ECHOLN(MSG_PID_AUTOTUNE_START);
  72. disable_all_heaters(); // switch off all heaters.
  73. #if HAS_PID_FOR_BOTH
  74. if (extruder < 0)
  75. soft_pwm_bed = bias = d = (MAX_BED_POWER) / 2;
  76. else
  77. soft_pwm[extruder] = bias = d = (PID_MAX) / 2;
  78. #elif ENABLED(PIDTEMP)
  79. soft_pwm[extruder] = bias = d = (PID_MAX) / 2;
  80. #else
  81. soft_pwm_bed = bias = d = (MAX_BED_POWER) / 2;
  82. #endif
  83. // PID Tuning loop
  84. for (;;) {
  85. millis_t ms = millis();
  86. if (temp_meas_ready) { // temp sample ready
  87. updateTemperaturesFromRawValues();
  88. input =
  89. #if HAS_PID_FOR_BOTH
  90. extruder < 0 ? current_temperature_bed : current_temperature[extruder]
  91. #elif ENABLED(PIDTEMP)
  92. current_temperature[extruder]
  93. #else
  94. current_temperature_bed
  95. #endif
  96. ;
  97. max = max(max, input);
  98. min = min(min, input);
  99. #if HAS_AUTO_FAN
  100. if (ELAPSED(ms, next_auto_fan_check_ms)) {
  101. checkExtruderAutoFans();
  102. next_auto_fan_check_ms = ms + 2500UL;
  103. }
  104. #endif
  105. if (heating && input > temp) {
  106. if (ELAPSED(ms, t2 + 5000UL)) {
  107. heating = false;
  108. #if HAS_PID_FOR_BOTH
  109. if (extruder < 0)
  110. soft_pwm_bed = (bias - d) >> 1;
  111. else
  112. soft_pwm[extruder] = (bias - d) >> 1;
  113. #elif ENABLED(PIDTEMP)
  114. soft_pwm[extruder] = (bias - d) >> 1;
  115. #elif ENABLED(PIDTEMPBED)
  116. soft_pwm_bed = (bias - d) >> 1;
  117. #endif
  118. t1 = ms;
  119. t_high = t1 - t2;
  120. max = temp;
  121. }
  122. }
  123. if (!heating && input < temp) {
  124. if (ELAPSED(ms, t1 + 5000UL)) {
  125. heating = true;
  126. t2 = ms;
  127. t_low = t2 - t1;
  128. if (cycles > 0) {
  129. long max_pow =
  130. #if HAS_PID_FOR_BOTH
  131. extruder < 0 ? MAX_BED_POWER : PID_MAX
  132. #elif ENABLED(PIDTEMP)
  133. PID_MAX
  134. #else
  135. MAX_BED_POWER
  136. #endif
  137. ;
  138. bias += (d * (t_high - t_low)) / (t_low + t_high);
  139. bias = constrain(bias, 20, max_pow - 20);
  140. d = (bias > max_pow / 2) ? max_pow - 1 - bias : bias;
  141. SERIAL_PROTOCOLPGM(MSG_BIAS); SERIAL_PROTOCOL(bias);
  142. SERIAL_PROTOCOLPGM(MSG_D); SERIAL_PROTOCOL(d);
  143. SERIAL_PROTOCOLPGM(MSG_T_MIN); SERIAL_PROTOCOL(min);
  144. SERIAL_PROTOCOLPGM(MSG_T_MAX); SERIAL_PROTOCOLLN(max);
  145. if (cycles > 2) {
  146. Ku = (4.0 * d) / (3.14159265 * (max - min) / 2.0);
  147. Tu = ((float)(t_low + t_high) / 1000.0);
  148. SERIAL_PROTOCOLPGM(MSG_KU); SERIAL_PROTOCOL(Ku);
  149. SERIAL_PROTOCOLPGM(MSG_TU); SERIAL_PROTOCOLLN(Tu);
  150. workKp = 0.6 * Ku;
  151. workKi = 2 * workKp / Tu;
  152. workKd = workKp * Tu / 8;
  153. SERIAL_PROTOCOLLNPGM(MSG_CLASSIC_PID);
  154. SERIAL_PROTOCOLPGM(MSG_KP); SERIAL_PROTOCOLLN(workKp);
  155. SERIAL_PROTOCOLPGM(MSG_KI); SERIAL_PROTOCOLLN(workKi);
  156. SERIAL_PROTOCOLPGM(MSG_KD); SERIAL_PROTOCOLLN(workKd);
  157. /**
  158. workKp = 0.33*Ku;
  159. workKi = workKp/Tu;
  160. workKd = workKp*Tu/3;
  161. SERIAL_PROTOCOLLNPGM(" Some overshoot ");
  162. SERIAL_PROTOCOLPGM(" Kp: "); SERIAL_PROTOCOLLN(workKp);
  163. SERIAL_PROTOCOLPGM(" Ki: "); SERIAL_PROTOCOLLN(workKi);
  164. SERIAL_PROTOCOLPGM(" Kd: "); SERIAL_PROTOCOLLN(workKd);
  165. workKp = 0.2*Ku;
  166. workKi = 2*workKp/Tu;
  167. workKd = workKp*Tu/3;
  168. SERIAL_PROTOCOLLNPGM(" No overshoot ");
  169. SERIAL_PROTOCOLPGM(" Kp: "); SERIAL_PROTOCOLLN(workKp);
  170. SERIAL_PROTOCOLPGM(" Ki: "); SERIAL_PROTOCOLLN(workKi);
  171. SERIAL_PROTOCOLPGM(" Kd: "); SERIAL_PROTOCOLLN(workKd);
  172. */
  173. }
  174. }
  175. #if HAS_PID_FOR_BOTH
  176. if (extruder < 0)
  177. soft_pwm_bed = (bias + d) >> 1;
  178. else
  179. soft_pwm[extruder] = (bias + d) >> 1;
  180. #elif ENABLED(PIDTEMP)
  181. soft_pwm[extruder] = (bias + d) >> 1;
  182. #else
  183. soft_pwm_bed = (bias + d) >> 1;
  184. #endif
  185. cycles++;
  186. min = temp;
  187. }
  188. }
  189. }
  190. #define MAX_OVERSHOOT_PID_AUTOTUNE 20
  191. if (input > temp + MAX_OVERSHOOT_PID_AUTOTUNE) {
  192. SERIAL_PROTOCOLLNPGM(MSG_PID_TEMP_TOO_HIGH);
  193. return;
  194. }
  195. // Every 2 seconds...
  196. if (ELAPSED(ms, temp_ms + 2000UL)) {
  197. #if HAS_TEMP_HOTEND || HAS_TEMP_BED
  198. print_heaterstates();
  199. SERIAL_EOL;
  200. #endif
  201. temp_ms = ms;
  202. } // every 2 seconds
  203. // Over 2 minutes?
  204. if (((ms - t1) + (ms - t2)) > (10L * 60L * 1000L * 2L)) {
  205. SERIAL_PROTOCOLLNPGM(MSG_PID_TIMEOUT);
  206. return;
  207. }
  208. if (cycles > ncycles) {
  209. SERIAL_PROTOCOLLNPGM(MSG_PID_AUTOTUNE_FINISHED);
  210. #if HAS_PID_FOR_BOTH
  211. const char* estring = extruder < 0 ? "bed" : "";
  212. SERIAL_PROTOCOLPGM("#define DEFAULT_"); SERIAL_PROTOCOL(estring); SERIAL_PROTOCOLPGM("Kp "); SERIAL_PROTOCOLLN(workKp);
  213. SERIAL_PROTOCOLPGM("#define DEFAULT_"); SERIAL_PROTOCOL(estring); SERIAL_PROTOCOLPGM("Ki "); SERIAL_PROTOCOLLN(workKi);
  214. SERIAL_PROTOCOLPGM("#define DEFAULT_"); SERIAL_PROTOCOL(estring); SERIAL_PROTOCOLPGM("Kd "); SERIAL_PROTOCOLLN(workKd);
  215. #elif ENABLED(PIDTEMP)
  216. SERIAL_PROTOCOLPGM("#define DEFAULT_Kp "); SERIAL_PROTOCOLLN(workKp);
  217. SERIAL_PROTOCOLPGM("#define DEFAULT_Ki "); SERIAL_PROTOCOLLN(workKi);
  218. SERIAL_PROTOCOLPGM("#define DEFAULT_Kd "); SERIAL_PROTOCOLLN(workKd);
  219. #else
  220. SERIAL_PROTOCOLPGM("#define DEFAULT_bedKp "); SERIAL_PROTOCOLLN(workKp);
  221. SERIAL_PROTOCOLPGM("#define DEFAULT_bedKi "); SERIAL_PROTOCOLLN(workKi);
  222. SERIAL_PROTOCOLPGM("#define DEFAULT_bedKd "); SERIAL_PROTOCOLLN(workKd);
  223. #endif
  224. #define _SET_BED_PID() \
  225. bedKp = workKp; \
  226. bedKi = scalePID_i(workKi); \
  227. bedKd = scalePID_d(workKd); \
  228. updatePID()
  229. #define _SET_EXTRUDER_PID() \
  230. PID_PARAM(Kp, extruder) = workKp; \
  231. PID_PARAM(Ki, extruder) = scalePID_i(workKi); \
  232. PID_PARAM(Kd, extruder) = scalePID_d(workKd); \
  233. updatePID()
  234. // Use the result? (As with "M303 U1")
  235. if (set_result) {
  236. #if HAS_PID_FOR_BOTH
  237. if (extruder < 0) {
  238. _SET_BED_PID();
  239. }
  240. else {
  241. _SET_EXTRUDER_PID();
  242. }
  243. #elif ENABLED(PIDTEMP)
  244. _SET_EXTRUDER_PID();
  245. #else
  246. _SET_BED_PID();
  247. #endif
  248. }
  249. return;
  250. }
  251. lcd_update();
  252. }
  253. }
  254. #endif // HAS_PID_HEATING
  255. #if ENABLED(PIDTEMP)
  256. #if ENABLED(PID_PARAMS_PER_EXTRUDER)
  257. float Temperature::Kp[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(DEFAULT_Kp),
  258. Temperature::Ki[EXTRUDERS] = ARRAY_BY_EXTRUDERS1((DEFAULT_Ki) * (PID_dT)),
  259. Temperature::Kd[EXTRUDERS] = ARRAY_BY_EXTRUDERS1((DEFAULT_Kd) / (PID_dT));
  260. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  261. float Temperature::Kc[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(DEFAULT_Kc);
  262. #endif
  263. #else
  264. float Temperature::Kp = DEFAULT_Kp,
  265. Temperature::Ki = (DEFAULT_Ki) * (PID_dT),
  266. Temperature::Kd = (DEFAULT_Kd) / (PID_dT);
  267. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  268. float Temperature::Kc = DEFAULT_Kc;
  269. #endif
  270. #endif
  271. #endif
  272. Temperature::Temperature() { }
  273. void Temperature::updatePID() {
  274. #if ENABLED(PIDTEMP)
  275. for (int e = 0; e < EXTRUDERS; e++) {
  276. temp_iState_max[e] = (PID_INTEGRAL_DRIVE_MAX) / PID_PARAM(Ki, e);
  277. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  278. last_position[e] = 0;
  279. #endif
  280. }
  281. #endif
  282. #if ENABLED(PIDTEMPBED)
  283. temp_iState_max_bed = (PID_BED_INTEGRAL_DRIVE_MAX) / bedKi;
  284. #endif
  285. }
  286. int Temperature::getHeaterPower(int heater) {
  287. return heater < 0 ? soft_pwm_bed : soft_pwm[heater];
  288. }
  289. #if HAS_AUTO_FAN
  290. void Temperature::checkExtruderAutoFans() {
  291. const int8_t fanPin[] = { EXTRUDER_0_AUTO_FAN_PIN, EXTRUDER_1_AUTO_FAN_PIN, EXTRUDER_2_AUTO_FAN_PIN, EXTRUDER_3_AUTO_FAN_PIN };
  292. const int fanBit[] = { 0,
  293. EXTRUDER_1_AUTO_FAN_PIN == EXTRUDER_0_AUTO_FAN_PIN ? 0 : 1,
  294. EXTRUDER_2_AUTO_FAN_PIN == EXTRUDER_0_AUTO_FAN_PIN ? 0 :
  295. EXTRUDER_2_AUTO_FAN_PIN == EXTRUDER_1_AUTO_FAN_PIN ? 1 : 2,
  296. EXTRUDER_3_AUTO_FAN_PIN == EXTRUDER_0_AUTO_FAN_PIN ? 0 :
  297. EXTRUDER_3_AUTO_FAN_PIN == EXTRUDER_1_AUTO_FAN_PIN ? 1 :
  298. EXTRUDER_3_AUTO_FAN_PIN == EXTRUDER_2_AUTO_FAN_PIN ? 2 : 3
  299. };
  300. uint8_t fanState = 0;
  301. for (int f = 0; f <= EXTRUDERS; f++) {
  302. if (current_temperature[f] > EXTRUDER_AUTO_FAN_TEMPERATURE)
  303. SBI(fanState, fanBit[f]);
  304. }
  305. uint8_t fanDone = 0;
  306. for (int f = 0; f <= 3; f++) {
  307. int8_t pin = fanPin[f];
  308. if (pin >= 0 && !TEST(fanDone, fanBit[f])) {
  309. unsigned char newFanSpeed = TEST(fanState, fanBit[f]) ? EXTRUDER_AUTO_FAN_SPEED : 0;
  310. // this idiom allows both digital and PWM fan outputs (see M42 handling).
  311. digitalWrite(pin, newFanSpeed);
  312. analogWrite(pin, newFanSpeed);
  313. SBI(fanDone, fanBit[f]);
  314. }
  315. }
  316. }
  317. #endif // HAS_AUTO_FAN
  318. //
  319. // Temperature Error Handlers
  320. //
  321. void Temperature::_temp_error(int e, const char* serial_msg, const char* lcd_msg) {
  322. static bool killed = false;
  323. if (IsRunning()) {
  324. SERIAL_ERROR_START;
  325. serialprintPGM(serial_msg);
  326. SERIAL_ERRORPGM(MSG_STOPPED_HEATER);
  327. if (e >= 0) SERIAL_ERRORLN((int)e); else SERIAL_ERRORLNPGM(MSG_HEATER_BED);
  328. }
  329. #if DISABLED(BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE)
  330. if (!killed) {
  331. Running = false;
  332. killed = true;
  333. kill(lcd_msg);
  334. }
  335. else
  336. disable_all_heaters(); // paranoia
  337. #endif
  338. }
  339. void Temperature::max_temp_error(uint8_t e) {
  340. _temp_error(e, PSTR(MSG_T_MAXTEMP), PSTR(MSG_ERR_MAXTEMP));
  341. }
  342. void Temperature::min_temp_error(uint8_t e) {
  343. _temp_error(e, PSTR(MSG_T_MINTEMP), PSTR(MSG_ERR_MINTEMP));
  344. }
  345. float Temperature::get_pid_output(int e) {
  346. float pid_output;
  347. #if ENABLED(PIDTEMP)
  348. #if DISABLED(PID_OPENLOOP)
  349. pid_error[e] = target_temperature[e] - current_temperature[e];
  350. dTerm[e] = K2 * PID_PARAM(Kd, e) * (current_temperature[e] - temp_dState[e]) + K1 * dTerm[e];
  351. temp_dState[e] = current_temperature[e];
  352. if (pid_error[e] > PID_FUNCTIONAL_RANGE) {
  353. pid_output = BANG_MAX;
  354. pid_reset[e] = true;
  355. }
  356. else if (pid_error[e] < -(PID_FUNCTIONAL_RANGE) || target_temperature[e] == 0) {
  357. pid_output = 0;
  358. pid_reset[e] = true;
  359. }
  360. else {
  361. if (pid_reset[e]) {
  362. temp_iState[e] = 0.0;
  363. pid_reset[e] = false;
  364. }
  365. pTerm[e] = PID_PARAM(Kp, e) * pid_error[e];
  366. temp_iState[e] += pid_error[e];
  367. temp_iState[e] = constrain(temp_iState[e], temp_iState_min[e], temp_iState_max[e]);
  368. iTerm[e] = PID_PARAM(Ki, e) * temp_iState[e];
  369. pid_output = pTerm[e] + iTerm[e] - dTerm[e];
  370. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  371. cTerm[e] = 0;
  372. if (e == active_extruder) {
  373. long e_position = stepper.position(E_AXIS);
  374. if (e_position > last_position[e]) {
  375. lpq[lpq_ptr++] = e_position - last_position[e];
  376. last_position[e] = e_position;
  377. }
  378. else {
  379. lpq[lpq_ptr++] = 0;
  380. }
  381. if (lpq_ptr >= lpq_len) lpq_ptr = 0;
  382. cTerm[e] = (lpq[lpq_ptr] / planner.axis_steps_per_unit[E_AXIS]) * PID_PARAM(Kc, e);
  383. pid_output += cTerm[e];
  384. }
  385. #endif //PID_ADD_EXTRUSION_RATE
  386. if (pid_output > PID_MAX) {
  387. if (pid_error[e] > 0) temp_iState[e] -= pid_error[e]; // conditional un-integration
  388. pid_output = PID_MAX;
  389. }
  390. else if (pid_output < 0) {
  391. if (pid_error[e] < 0) temp_iState[e] -= pid_error[e]; // conditional un-integration
  392. pid_output = 0;
  393. }
  394. }
  395. #else
  396. pid_output = constrain(target_temperature[e], 0, PID_MAX);
  397. #endif //PID_OPENLOOP
  398. #if ENABLED(PID_DEBUG)
  399. SERIAL_ECHO_START;
  400. SERIAL_ECHOPAIR(MSG_PID_DEBUG, e);
  401. SERIAL_ECHOPAIR(MSG_PID_DEBUG_INPUT, current_temperature[e]);
  402. SERIAL_ECHOPAIR(MSG_PID_DEBUG_OUTPUT, pid_output);
  403. SERIAL_ECHOPAIR(MSG_PID_DEBUG_PTERM, pTerm[e]);
  404. SERIAL_ECHOPAIR(MSG_PID_DEBUG_ITERM, iTerm[e]);
  405. SERIAL_ECHOPAIR(MSG_PID_DEBUG_DTERM, dTerm[e]);
  406. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  407. SERIAL_ECHOPAIR(MSG_PID_DEBUG_CTERM, cTerm[e]);
  408. #endif
  409. SERIAL_EOL;
  410. #endif //PID_DEBUG
  411. #else /* PID off */
  412. pid_output = (current_temperature[e] < target_temperature[e]) ? PID_MAX : 0;
  413. #endif
  414. return pid_output;
  415. }
  416. #if ENABLED(PIDTEMPBED)
  417. float Temperature::get_pid_output_bed() {
  418. float pid_output;
  419. #if DISABLED(PID_OPENLOOP)
  420. pid_error_bed = target_temperature_bed - current_temperature_bed;
  421. pTerm_bed = bedKp * pid_error_bed;
  422. temp_iState_bed += pid_error_bed;
  423. temp_iState_bed = constrain(temp_iState_bed, temp_iState_min_bed, temp_iState_max_bed);
  424. iTerm_bed = bedKi * temp_iState_bed;
  425. dTerm_bed = K2 * bedKd * (current_temperature_bed - temp_dState_bed) + K1 * dTerm_bed;
  426. temp_dState_bed = current_temperature_bed;
  427. pid_output = pTerm_bed + iTerm_bed - dTerm_bed;
  428. if (pid_output > MAX_BED_POWER) {
  429. if (pid_error_bed > 0) temp_iState_bed -= pid_error_bed; // conditional un-integration
  430. pid_output = MAX_BED_POWER;
  431. }
  432. else if (pid_output < 0) {
  433. if (pid_error_bed < 0) temp_iState_bed -= pid_error_bed; // conditional un-integration
  434. pid_output = 0;
  435. }
  436. #else
  437. pid_output = constrain(target_temperature_bed, 0, MAX_BED_POWER);
  438. #endif // PID_OPENLOOP
  439. #if ENABLED(PID_BED_DEBUG)
  440. SERIAL_ECHO_START;
  441. SERIAL_ECHO(" PID_BED_DEBUG ");
  442. SERIAL_ECHO(": Input ");
  443. SERIAL_ECHO(current_temperature_bed);
  444. SERIAL_ECHO(" Output ");
  445. SERIAL_ECHO(pid_output);
  446. SERIAL_ECHO(" pTerm ");
  447. SERIAL_ECHO(pTerm_bed);
  448. SERIAL_ECHO(" iTerm ");
  449. SERIAL_ECHO(iTerm_bed);
  450. SERIAL_ECHO(" dTerm ");
  451. SERIAL_ECHOLN(dTerm_bed);
  452. #endif //PID_BED_DEBUG
  453. return pid_output;
  454. }
  455. #endif //PIDTEMPBED
  456. /**
  457. * Manage heating activities for extruder hot-ends and a heated bed
  458. * - Acquire updated temperature readings
  459. * - Also resets the watchdog timer
  460. * - Invoke thermal runaway protection
  461. * - Manage extruder auto-fan
  462. * - Apply filament width to the extrusion rate (may move)
  463. * - Update the heated bed PID output value
  464. */
  465. void Temperature::manage_heater() {
  466. if (!temp_meas_ready) return;
  467. updateTemperaturesFromRawValues(); // also resets the watchdog
  468. #if ENABLED(HEATER_0_USES_MAX6675)
  469. float ct = current_temperature[0];
  470. if (ct > min(HEATER_0_MAXTEMP, 1023)) max_temp_error(0);
  471. if (ct < max(HEATER_0_MINTEMP, 0.01)) min_temp_error(0);
  472. #endif
  473. #if (ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0) || (ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0) || DISABLED(PIDTEMPBED) || HAS_AUTO_FAN
  474. millis_t ms = millis();
  475. #endif
  476. // Loop through all extruders
  477. for (int e = 0; e < EXTRUDERS; e++) {
  478. #if ENABLED(THERMAL_PROTECTION_HOTENDS)
  479. 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);
  480. #endif
  481. float pid_output = get_pid_output(e);
  482. // Check if temperature is within the correct range
  483. soft_pwm[e] = current_temperature[e] > minttemp[e] && current_temperature[e] < maxttemp[e] ? (int)pid_output >> 1 : 0;
  484. // Check if the temperature is failing to increase
  485. #if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
  486. // Is it time to check this extruder's heater?
  487. if (watch_heater_next_ms[e] && ELAPSED(ms, watch_heater_next_ms[e])) {
  488. // Has it failed to increase enough?
  489. if (degHotend(e) < watch_target_temp[e]) {
  490. // Stop!
  491. _temp_error(e, PSTR(MSG_T_HEATING_FAILED), PSTR(MSG_HEATING_FAILED_LCD));
  492. }
  493. else {
  494. // Start again if the target is still far off
  495. start_watching_heater(e);
  496. }
  497. }
  498. #endif // THERMAL_PROTECTION_HOTENDS
  499. // Check if the temperature is failing to increase
  500. #if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
  501. // Is it time to check the bed?
  502. if (watch_bed_next_ms && ELAPSED(ms, watch_bed_next_ms)) {
  503. // Has it failed to increase enough?
  504. if (degBed() < watch_target_bed_temp) {
  505. // Stop!
  506. _temp_error(-1, PSTR(MSG_T_HEATING_FAILED), PSTR(MSG_HEATING_FAILED_LCD));
  507. }
  508. else {
  509. // Start again if the target is still far off
  510. start_watching_bed();
  511. }
  512. }
  513. #endif // THERMAL_PROTECTION_HOTENDS
  514. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  515. if (fabs(current_temperature[0] - redundant_temperature) > MAX_REDUNDANT_TEMP_SENSOR_DIFF) {
  516. _temp_error(0, PSTR(MSG_REDUNDANCY), PSTR(MSG_ERR_REDUNDANT_TEMP));
  517. }
  518. #endif
  519. } // Extruders Loop
  520. #if HAS_AUTO_FAN
  521. if (ELAPSED(ms, next_auto_fan_check_ms)) { // only need to check fan state very infrequently
  522. checkExtruderAutoFans();
  523. next_auto_fan_check_ms = ms + 2500UL;
  524. }
  525. #endif
  526. // Control the extruder rate based on the width sensor
  527. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  528. if (filament_sensor) {
  529. meas_shift_index = filwidth_delay_index1 - meas_delay_cm;
  530. if (meas_shift_index < 0) meas_shift_index += MAX_MEASUREMENT_DELAY + 1; //loop around buffer if needed
  531. // Get the delayed info and add 100 to reconstitute to a percent of
  532. // the nominal filament diameter then square it to get an area
  533. meas_shift_index = constrain(meas_shift_index, 0, MAX_MEASUREMENT_DELAY);
  534. float vm = pow((measurement_delay[meas_shift_index] + 100.0) / 100.0, 2);
  535. NOLESS(vm, 0.01);
  536. volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM] = vm;
  537. }
  538. #endif //FILAMENT_WIDTH_SENSOR
  539. #if DISABLED(PIDTEMPBED)
  540. if (PENDING(ms, next_bed_check_ms)) return;
  541. next_bed_check_ms = ms + BED_CHECK_INTERVAL;
  542. #endif
  543. #if TEMP_SENSOR_BED != 0
  544. #if HAS_THERMALLY_PROTECTED_BED
  545. 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);
  546. #endif
  547. #if ENABLED(PIDTEMPBED)
  548. float pid_output = get_pid_output_bed();
  549. soft_pwm_bed = current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP ? (int)pid_output >> 1 : 0;
  550. #elif ENABLED(BED_LIMIT_SWITCHING)
  551. // Check if temperature is within the correct band
  552. if (current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP) {
  553. if (current_temperature_bed >= target_temperature_bed + BED_HYSTERESIS)
  554. soft_pwm_bed = 0;
  555. else if (current_temperature_bed <= target_temperature_bed - (BED_HYSTERESIS))
  556. soft_pwm_bed = MAX_BED_POWER >> 1;
  557. }
  558. else {
  559. soft_pwm_bed = 0;
  560. WRITE_HEATER_BED(LOW);
  561. }
  562. #else // !PIDTEMPBED && !BED_LIMIT_SWITCHING
  563. // Check if temperature is within the correct range
  564. if (current_temperature_bed > BED_MINTEMP && current_temperature_bed < BED_MAXTEMP) {
  565. soft_pwm_bed = current_temperature_bed < target_temperature_bed ? MAX_BED_POWER >> 1 : 0;
  566. }
  567. else {
  568. soft_pwm_bed = 0;
  569. WRITE_HEATER_BED(LOW);
  570. }
  571. #endif
  572. #endif //TEMP_SENSOR_BED != 0
  573. }
  574. #define PGM_RD_W(x) (short)pgm_read_word(&x)
  575. // Derived from RepRap FiveD extruder::getTemperature()
  576. // For hot end temperature measurement.
  577. float Temperature::analog2temp(int raw, uint8_t e) {
  578. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  579. if (e > EXTRUDERS)
  580. #else
  581. if (e >= EXTRUDERS)
  582. #endif
  583. {
  584. SERIAL_ERROR_START;
  585. SERIAL_ERROR((int)e);
  586. SERIAL_ERRORLNPGM(MSG_INVALID_EXTRUDER_NUM);
  587. kill(PSTR(MSG_KILLED));
  588. return 0.0;
  589. }
  590. #if ENABLED(HEATER_0_USES_MAX6675)
  591. if (e == 0) return 0.25 * raw;
  592. #endif
  593. if (heater_ttbl_map[e] != NULL) {
  594. float celsius = 0;
  595. uint8_t i;
  596. short(*tt)[][2] = (short(*)[][2])(heater_ttbl_map[e]);
  597. for (i = 1; i < heater_ttbllen_map[e]; i++) {
  598. if (PGM_RD_W((*tt)[i][0]) > raw) {
  599. celsius = PGM_RD_W((*tt)[i - 1][1]) +
  600. (raw - PGM_RD_W((*tt)[i - 1][0])) *
  601. (float)(PGM_RD_W((*tt)[i][1]) - PGM_RD_W((*tt)[i - 1][1])) /
  602. (float)(PGM_RD_W((*tt)[i][0]) - PGM_RD_W((*tt)[i - 1][0]));
  603. break;
  604. }
  605. }
  606. // Overflow: Set to last value in the table
  607. if (i == heater_ttbllen_map[e]) celsius = PGM_RD_W((*tt)[i - 1][1]);
  608. return celsius;
  609. }
  610. return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * (TEMP_SENSOR_AD595_GAIN)) + TEMP_SENSOR_AD595_OFFSET;
  611. }
  612. // Derived from RepRap FiveD extruder::getTemperature()
  613. // For bed temperature measurement.
  614. float Temperature::analog2tempBed(int raw) {
  615. #if ENABLED(BED_USES_THERMISTOR)
  616. float celsius = 0;
  617. byte i;
  618. for (i = 1; i < BEDTEMPTABLE_LEN; i++) {
  619. if (PGM_RD_W(BEDTEMPTABLE[i][0]) > raw) {
  620. celsius = PGM_RD_W(BEDTEMPTABLE[i - 1][1]) +
  621. (raw - PGM_RD_W(BEDTEMPTABLE[i - 1][0])) *
  622. (float)(PGM_RD_W(BEDTEMPTABLE[i][1]) - PGM_RD_W(BEDTEMPTABLE[i - 1][1])) /
  623. (float)(PGM_RD_W(BEDTEMPTABLE[i][0]) - PGM_RD_W(BEDTEMPTABLE[i - 1][0]));
  624. break;
  625. }
  626. }
  627. // Overflow: Set to last value in the table
  628. if (i == BEDTEMPTABLE_LEN) celsius = PGM_RD_W(BEDTEMPTABLE[i - 1][1]);
  629. return celsius;
  630. #elif defined(BED_USES_AD595)
  631. return ((raw * ((5.0 * 100.0) / 1024.0) / OVERSAMPLENR) * (TEMP_SENSOR_AD595_GAIN)) + TEMP_SENSOR_AD595_OFFSET;
  632. #else
  633. UNUSED(raw);
  634. return 0;
  635. #endif
  636. }
  637. /**
  638. * Get the raw values into the actual temperatures.
  639. * The raw values are created in interrupt context,
  640. * and this function is called from normal context
  641. * as it would block the stepper routine.
  642. */
  643. void Temperature::updateTemperaturesFromRawValues() {
  644. #if ENABLED(HEATER_0_USES_MAX6675)
  645. current_temperature_raw[0] = read_max6675();
  646. #endif
  647. for (uint8_t e = 0; e < EXTRUDERS; e++) {
  648. current_temperature[e] = Temperature::analog2temp(current_temperature_raw[e], e);
  649. }
  650. current_temperature_bed = Temperature::analog2tempBed(current_temperature_bed_raw);
  651. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  652. redundant_temperature = Temperature::analog2temp(redundant_temperature_raw, 1);
  653. #endif
  654. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  655. filament_width_meas = analog2widthFil();
  656. #endif
  657. #if ENABLED(USE_WATCHDOG)
  658. // Reset the watchdog after we know we have a temperature measurement.
  659. watchdog_reset();
  660. #endif
  661. CRITICAL_SECTION_START;
  662. temp_meas_ready = false;
  663. CRITICAL_SECTION_END;
  664. }
  665. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  666. // Convert raw Filament Width to millimeters
  667. float Temperature::analog2widthFil() {
  668. return current_raw_filwidth / 16383.0 * 5.0;
  669. //return current_raw_filwidth;
  670. }
  671. // Convert raw Filament Width to a ratio
  672. int Temperature::widthFil_to_size_ratio() {
  673. float temp = filament_width_meas;
  674. if (temp < MEASURED_LOWER_LIMIT) temp = filament_width_nominal; //assume sensor cut out
  675. else NOMORE(temp, MEASURED_UPPER_LIMIT);
  676. return filament_width_nominal / temp * 100;
  677. }
  678. #endif
  679. /**
  680. * Initialize the temperature manager
  681. * The manager is implemented by periodic calls to manage_heater()
  682. */
  683. void Temperature::init() {
  684. #if MB(RUMBA) && ((TEMP_SENSOR_0==-1)||(TEMP_SENSOR_1==-1)||(TEMP_SENSOR_2==-1)||(TEMP_SENSOR_BED==-1))
  685. //disable RUMBA JTAG in case the thermocouple extension is plugged on top of JTAG connector
  686. MCUCR = _BV(JTD);
  687. MCUCR = _BV(JTD);
  688. #endif
  689. // Finish init of mult extruder arrays
  690. for (int e = 0; e < EXTRUDERS; e++) {
  691. // populate with the first value
  692. maxttemp[e] = maxttemp[0];
  693. #if ENABLED(PIDTEMP)
  694. temp_iState_min[e] = 0.0;
  695. temp_iState_max[e] = (PID_INTEGRAL_DRIVE_MAX) / PID_PARAM(Ki, e);
  696. #if ENABLED(PID_ADD_EXTRUSION_RATE)
  697. last_position[e] = 0;
  698. #endif
  699. #endif //PIDTEMP
  700. #if ENABLED(PIDTEMPBED)
  701. temp_iState_min_bed = 0.0;
  702. temp_iState_max_bed = (PID_BED_INTEGRAL_DRIVE_MAX) / bedKi;
  703. #endif //PIDTEMPBED
  704. }
  705. #if HAS_HEATER_0
  706. SET_OUTPUT(HEATER_0_PIN);
  707. #endif
  708. #if HAS_HEATER_1
  709. SET_OUTPUT(HEATER_1_PIN);
  710. #endif
  711. #if HAS_HEATER_2
  712. SET_OUTPUT(HEATER_2_PIN);
  713. #endif
  714. #if HAS_HEATER_3
  715. SET_OUTPUT(HEATER_3_PIN);
  716. #endif
  717. #if HAS_HEATER_BED
  718. SET_OUTPUT(HEATER_BED_PIN);
  719. #endif
  720. #if ENABLED(FAST_PWM_FAN) || ENABLED(FAN_SOFT_PWM)
  721. #if HAS_FAN0
  722. SET_OUTPUT(FAN_PIN);
  723. #if ENABLED(FAST_PWM_FAN)
  724. setPwmFrequency(FAN_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  725. #endif
  726. #if ENABLED(FAN_SOFT_PWM)
  727. soft_pwm_fan[0] = fanSpeedSoftPwm[0] / 2;
  728. #endif
  729. #endif
  730. #if HAS_FAN1
  731. SET_OUTPUT(FAN1_PIN);
  732. #if ENABLED(FAST_PWM_FAN)
  733. setPwmFrequency(FAN1_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  734. #endif
  735. #if ENABLED(FAN_SOFT_PWM)
  736. soft_pwm_fan[1] = fanSpeedSoftPwm[1] / 2;
  737. #endif
  738. #endif
  739. #if HAS_FAN2
  740. SET_OUTPUT(FAN2_PIN);
  741. #if ENABLED(FAST_PWM_FAN)
  742. setPwmFrequency(FAN2_PIN, 1); // No prescaling. Pwm frequency = F_CPU/256/8
  743. #endif
  744. #if ENABLED(FAN_SOFT_PWM)
  745. soft_pwm_fan[2] = fanSpeedSoftPwm[2] / 2;
  746. #endif
  747. #endif
  748. #endif // FAST_PWM_FAN || FAN_SOFT_PWM
  749. #if ENABLED(HEATER_0_USES_MAX6675)
  750. #if DISABLED(SDSUPPORT)
  751. OUT_WRITE(SCK_PIN, LOW);
  752. OUT_WRITE(MOSI_PIN, HIGH);
  753. OUT_WRITE(MISO_PIN, HIGH);
  754. #else
  755. pinMode(SS_PIN, OUTPUT);
  756. digitalWrite(SS_PIN, HIGH);
  757. #endif
  758. OUT_WRITE(MAX6675_SS, HIGH);
  759. #endif //HEATER_0_USES_MAX6675
  760. #ifdef DIDR2
  761. #define ANALOG_SELECT(pin) do{ if (pin < 8) SBI(DIDR0, pin); else SBI(DIDR2, pin - 8); }while(0)
  762. #else
  763. #define ANALOG_SELECT(pin) do{ SBI(DIDR0, pin); }while(0)
  764. #endif
  765. // Set analog inputs
  766. ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
  767. DIDR0 = 0;
  768. #ifdef DIDR2
  769. DIDR2 = 0;
  770. #endif
  771. #if HAS_TEMP_0
  772. ANALOG_SELECT(TEMP_0_PIN);
  773. #endif
  774. #if HAS_TEMP_1
  775. ANALOG_SELECT(TEMP_1_PIN);
  776. #endif
  777. #if HAS_TEMP_2
  778. ANALOG_SELECT(TEMP_2_PIN);
  779. #endif
  780. #if HAS_TEMP_3
  781. ANALOG_SELECT(TEMP_3_PIN);
  782. #endif
  783. #if HAS_TEMP_BED
  784. ANALOG_SELECT(TEMP_BED_PIN);
  785. #endif
  786. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  787. ANALOG_SELECT(FILWIDTH_PIN);
  788. #endif
  789. #if HAS_AUTO_FAN_0
  790. pinMode(EXTRUDER_0_AUTO_FAN_PIN, OUTPUT);
  791. #endif
  792. #if HAS_AUTO_FAN_1 && (EXTRUDER_1_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN)
  793. pinMode(EXTRUDER_1_AUTO_FAN_PIN, OUTPUT);
  794. #endif
  795. #if HAS_AUTO_FAN_2 && (EXTRUDER_2_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN) && (EXTRUDER_2_AUTO_FAN_PIN != EXTRUDER_1_AUTO_FAN_PIN)
  796. pinMode(EXTRUDER_2_AUTO_FAN_PIN, OUTPUT);
  797. #endif
  798. #if HAS_AUTO_FAN_3 && (EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_0_AUTO_FAN_PIN) && (EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_1_AUTO_FAN_PIN) && (EXTRUDER_3_AUTO_FAN_PIN != EXTRUDER_2_AUTO_FAN_PIN)
  799. pinMode(EXTRUDER_3_AUTO_FAN_PIN, OUTPUT);
  800. #endif
  801. // Use timer0 for temperature measurement
  802. // Interleave temperature interrupt with millies interrupt
  803. OCR0B = 128;
  804. SBI(TIMSK0, OCIE0B);
  805. // Wait for temperature measurement to settle
  806. delay(250);
  807. #define TEMP_MIN_ROUTINE(NR) \
  808. minttemp[NR] = HEATER_ ## NR ## _MINTEMP; \
  809. while(analog2temp(minttemp_raw[NR], NR) < HEATER_ ## NR ## _MINTEMP) { \
  810. if (HEATER_ ## NR ## _RAW_LO_TEMP < HEATER_ ## NR ## _RAW_HI_TEMP) \
  811. minttemp_raw[NR] += OVERSAMPLENR; \
  812. else \
  813. minttemp_raw[NR] -= OVERSAMPLENR; \
  814. }
  815. #define TEMP_MAX_ROUTINE(NR) \
  816. maxttemp[NR] = HEATER_ ## NR ## _MAXTEMP; \
  817. while(analog2temp(maxttemp_raw[NR], NR) > HEATER_ ## NR ## _MAXTEMP) { \
  818. if (HEATER_ ## NR ## _RAW_LO_TEMP < HEATER_ ## NR ## _RAW_HI_TEMP) \
  819. maxttemp_raw[NR] -= OVERSAMPLENR; \
  820. else \
  821. maxttemp_raw[NR] += OVERSAMPLENR; \
  822. }
  823. #ifdef HEATER_0_MINTEMP
  824. TEMP_MIN_ROUTINE(0);
  825. #endif
  826. #ifdef HEATER_0_MAXTEMP
  827. TEMP_MAX_ROUTINE(0);
  828. #endif
  829. #if EXTRUDERS > 1
  830. #ifdef HEATER_1_MINTEMP
  831. TEMP_MIN_ROUTINE(1);
  832. #endif
  833. #ifdef HEATER_1_MAXTEMP
  834. TEMP_MAX_ROUTINE(1);
  835. #endif
  836. #if EXTRUDERS > 2
  837. #ifdef HEATER_2_MINTEMP
  838. TEMP_MIN_ROUTINE(2);
  839. #endif
  840. #ifdef HEATER_2_MAXTEMP
  841. TEMP_MAX_ROUTINE(2);
  842. #endif
  843. #if EXTRUDERS > 3
  844. #ifdef HEATER_3_MINTEMP
  845. TEMP_MIN_ROUTINE(3);
  846. #endif
  847. #ifdef HEATER_3_MAXTEMP
  848. TEMP_MAX_ROUTINE(3);
  849. #endif
  850. #endif // EXTRUDERS > 3
  851. #endif // EXTRUDERS > 2
  852. #endif // EXTRUDERS > 1
  853. #ifdef BED_MINTEMP
  854. while(analog2tempBed(bed_minttemp_raw) < BED_MINTEMP) {
  855. #if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
  856. bed_minttemp_raw += OVERSAMPLENR;
  857. #else
  858. bed_minttemp_raw -= OVERSAMPLENR;
  859. #endif
  860. }
  861. #endif //BED_MINTEMP
  862. #ifdef BED_MAXTEMP
  863. while (analog2tempBed(bed_maxttemp_raw) > BED_MAXTEMP) {
  864. #if HEATER_BED_RAW_LO_TEMP < HEATER_BED_RAW_HI_TEMP
  865. bed_maxttemp_raw -= OVERSAMPLENR;
  866. #else
  867. bed_maxttemp_raw += OVERSAMPLENR;
  868. #endif
  869. }
  870. #endif //BED_MAXTEMP
  871. }
  872. #if ENABLED(THERMAL_PROTECTION_HOTENDS) && WATCH_TEMP_PERIOD > 0
  873. /**
  874. * Start Heating Sanity Check for hotends that are below
  875. * their target temperature by a configurable margin.
  876. * This is called when the temperature is set. (M104, M109)
  877. */
  878. void Temperature::start_watching_heater(int e) {
  879. if (degHotend(e) < degTargetHotend(e) - (WATCH_TEMP_INCREASE + TEMP_HYSTERESIS + 1)) {
  880. watch_target_temp[e] = degHotend(e) + WATCH_TEMP_INCREASE;
  881. watch_heater_next_ms[e] = millis() + (WATCH_TEMP_PERIOD) * 1000UL;
  882. }
  883. else
  884. watch_heater_next_ms[e] = 0;
  885. }
  886. #endif
  887. #if ENABLED(THERMAL_PROTECTION_BED) && WATCH_BED_TEMP_PERIOD > 0
  888. /**
  889. * Start Heating Sanity Check for hotends that are below
  890. * their target temperature by a configurable margin.
  891. * This is called when the temperature is set. (M140, M190)
  892. */
  893. void Temperature::start_watching_bed() {
  894. if (degBed() < degTargetBed() - (WATCH_BED_TEMP_INCREASE + TEMP_BED_HYSTERESIS + 1)) {
  895. watch_target_bed_temp = degBed() + WATCH_BED_TEMP_INCREASE;
  896. watch_bed_next_ms = millis() + (WATCH_BED_TEMP_PERIOD) * 1000UL;
  897. }
  898. else
  899. watch_bed_next_ms = 0;
  900. }
  901. #endif
  902. #if ENABLED(THERMAL_PROTECTION_HOTENDS) || HAS_THERMALLY_PROTECTED_BED
  903. void Temperature::thermal_runaway_protection(TRState* state, millis_t* timer, float temperature, float target_temperature, int heater_id, int period_seconds, int hysteresis_degc) {
  904. static float tr_target_temperature[EXTRUDERS + 1] = { 0.0 };
  905. /**
  906. SERIAL_ECHO_START;
  907. SERIAL_ECHOPGM("Thermal Thermal Runaway Running. Heater ID: ");
  908. if (heater_id < 0) SERIAL_ECHOPGM("bed"); else SERIAL_ECHO(heater_id);
  909. SERIAL_ECHOPAIR(" ; State:", *state);
  910. SERIAL_ECHOPAIR(" ; Timer:", *timer);
  911. SERIAL_ECHOPAIR(" ; Temperature:", temperature);
  912. SERIAL_ECHOPAIR(" ; Target Temp:", target_temperature);
  913. SERIAL_EOL;
  914. */
  915. int heater_index = heater_id >= 0 ? heater_id : EXTRUDERS;
  916. // If the target temperature changes, restart
  917. if (tr_target_temperature[heater_index] != target_temperature) {
  918. tr_target_temperature[heater_index] = target_temperature;
  919. *state = target_temperature > 0 ? TRFirstHeating : TRInactive;
  920. }
  921. switch (*state) {
  922. // Inactive state waits for a target temperature to be set
  923. case TRInactive: break;
  924. // When first heating, wait for the temperature to be reached then go to Stable state
  925. case TRFirstHeating:
  926. if (temperature < tr_target_temperature[heater_index]) break;
  927. *state = TRStable;
  928. // While the temperature is stable watch for a bad temperature
  929. case TRStable:
  930. if (temperature < tr_target_temperature[heater_index] - hysteresis_degc && ELAPSED(millis(), *timer))
  931. *state = TRRunaway;
  932. else {
  933. *timer = millis() + period_seconds * 1000UL;
  934. break;
  935. }
  936. case TRRunaway:
  937. _temp_error(heater_id, PSTR(MSG_T_THERMAL_RUNAWAY), PSTR(MSG_THERMAL_RUNAWAY));
  938. }
  939. }
  940. #endif // THERMAL_PROTECTION_HOTENDS || THERMAL_PROTECTION_BED
  941. void Temperature::disable_all_heaters() {
  942. for (int i = 0; i < EXTRUDERS; i++) setTargetHotend(0, i);
  943. setTargetBed(0);
  944. // If all heaters go down then for sure our print job has stopped
  945. print_job_timer.stop();
  946. #define DISABLE_HEATER(NR) { \
  947. setTargetHotend(NR, 0); \
  948. soft_pwm[NR] = 0; \
  949. WRITE_HEATER_ ## NR (LOW); \
  950. }
  951. #if HAS_TEMP_HOTEND
  952. setTargetHotend(0, 0);
  953. soft_pwm[0] = 0;
  954. WRITE_HEATER_0P(LOW); // Should HEATERS_PARALLEL apply here? Then change to DISABLE_HEATER(0)
  955. #endif
  956. #if EXTRUDERS > 1 && HAS_TEMP_1
  957. DISABLE_HEATER(1);
  958. #endif
  959. #if EXTRUDERS > 2 && HAS_TEMP_2
  960. DISABLE_HEATER(2);
  961. #endif
  962. #if EXTRUDERS > 3 && HAS_TEMP_3
  963. DISABLE_HEATER(3);
  964. #endif
  965. #if HAS_TEMP_BED
  966. target_temperature_bed = 0;
  967. soft_pwm_bed = 0;
  968. #if HAS_HEATER_BED
  969. WRITE_HEATER_BED(LOW);
  970. #endif
  971. #endif
  972. }
  973. #if ENABLED(HEATER_0_USES_MAX6675)
  974. #define MAX6675_HEAT_INTERVAL 250u
  975. #if ENABLED(MAX6675_IS_MAX31855)
  976. uint32_t max6675_temp = 2000;
  977. #define MAX6675_ERROR_MASK 7
  978. #define MAX6675_DISCARD_BITS 18
  979. #else
  980. uint16_t max6675_temp = 2000;
  981. #define MAX6675_ERROR_MASK 4
  982. #define MAX6675_DISCARD_BITS 3
  983. #endif
  984. int Temperature::read_max6675() {
  985. static millis_t next_max6675_ms = 0;
  986. millis_t ms = millis();
  987. if (PENDING(ms, next_max6675_ms)) return (int)max6675_temp;
  988. next_max6675_ms = ms + MAX6675_HEAT_INTERVAL;
  989. CBI(
  990. #ifdef PRR
  991. PRR
  992. #elif defined(PRR0)
  993. PRR0
  994. #endif
  995. , PRSPI);
  996. SPCR = _BV(MSTR) | _BV(SPE) | _BV(SPR0);
  997. WRITE(MAX6675_SS, 0); // enable TT_MAX6675
  998. // ensure 100ns delay - a bit extra is fine
  999. asm("nop");//50ns on 20Mhz, 62.5ns on 16Mhz
  1000. asm("nop");//50ns on 20Mhz, 62.5ns on 16Mhz
  1001. // Read a big-endian temperature value
  1002. max6675_temp = 0;
  1003. for (uint8_t i = sizeof(max6675_temp); i--;) {
  1004. SPDR = 0;
  1005. for (;!TEST(SPSR, SPIF););
  1006. max6675_temp |= SPDR;
  1007. if (i > 0) max6675_temp <<= 8; // shift left if not the last byte
  1008. }
  1009. WRITE(MAX6675_SS, 1); // disable TT_MAX6675
  1010. if (max6675_temp & MAX6675_ERROR_MASK)
  1011. max6675_temp = 4000; // thermocouple open
  1012. else
  1013. max6675_temp >>= MAX6675_DISCARD_BITS;
  1014. return (int)max6675_temp;
  1015. }
  1016. #endif //HEATER_0_USES_MAX6675
  1017. /**
  1018. * Stages in the ISR loop
  1019. */
  1020. enum TempState {
  1021. PrepareTemp_0,
  1022. MeasureTemp_0,
  1023. PrepareTemp_BED,
  1024. MeasureTemp_BED,
  1025. PrepareTemp_1,
  1026. MeasureTemp_1,
  1027. PrepareTemp_2,
  1028. MeasureTemp_2,
  1029. PrepareTemp_3,
  1030. MeasureTemp_3,
  1031. Prepare_FILWIDTH,
  1032. Measure_FILWIDTH,
  1033. StartupDelay // Startup, delay initial temp reading a tiny bit so the hardware can settle
  1034. };
  1035. /**
  1036. * Get raw temperatures
  1037. */
  1038. void Temperature::set_current_temp_raw() {
  1039. #if HAS_TEMP_0 && DISABLED(HEATER_0_USES_MAX6675)
  1040. current_temperature_raw[0] = raw_temp_value[0];
  1041. #endif
  1042. #if HAS_TEMP_1
  1043. #if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
  1044. redundant_temperature_raw = raw_temp_value[1];
  1045. #else
  1046. current_temperature_raw[1] = raw_temp_value[1];
  1047. #endif
  1048. #if HAS_TEMP_2
  1049. current_temperature_raw[2] = raw_temp_value[2];
  1050. #if HAS_TEMP_3
  1051. current_temperature_raw[3] = raw_temp_value[3];
  1052. #endif
  1053. #endif
  1054. #endif
  1055. current_temperature_bed_raw = raw_temp_bed_value;
  1056. temp_meas_ready = true;
  1057. }
  1058. /**
  1059. * Timer 0 is shared with millies
  1060. * - Manage PWM to all the heaters and fan
  1061. * - Update the raw temperature values
  1062. * - Check new temperature values for MIN/MAX errors
  1063. * - Step the babysteps value for each axis towards 0
  1064. */
  1065. ISR(TIMER0_COMPB_vect) { thermalManager.isr(); }
  1066. void Temperature::isr() {
  1067. static unsigned char temp_count = 0;
  1068. static TempState temp_state = StartupDelay;
  1069. static unsigned char pwm_count = _BV(SOFT_PWM_SCALE);
  1070. // Static members for each heater
  1071. #if ENABLED(SLOW_PWM_HEATERS)
  1072. static unsigned char slow_pwm_count = 0;
  1073. #define ISR_STATICS(n) \
  1074. static unsigned char soft_pwm_ ## n; \
  1075. static unsigned char state_heater_ ## n = 0; \
  1076. static unsigned char state_timer_heater_ ## n = 0
  1077. #else
  1078. #define ISR_STATICS(n) static unsigned char soft_pwm_ ## n
  1079. #endif
  1080. // Statics per heater
  1081. ISR_STATICS(0);
  1082. #if (EXTRUDERS > 1) || ENABLED(HEATERS_PARALLEL)
  1083. ISR_STATICS(1);
  1084. #if EXTRUDERS > 2
  1085. ISR_STATICS(2);
  1086. #if EXTRUDERS > 3
  1087. ISR_STATICS(3);
  1088. #endif
  1089. #endif
  1090. #endif
  1091. #if HAS_HEATER_BED
  1092. ISR_STATICS(BED);
  1093. #endif
  1094. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  1095. static unsigned long raw_filwidth_value = 0;
  1096. #endif
  1097. #if DISABLED(SLOW_PWM_HEATERS)
  1098. /**
  1099. * standard PWM modulation
  1100. */
  1101. if (pwm_count == 0) {
  1102. soft_pwm_0 = soft_pwm[0];
  1103. if (soft_pwm_0 > 0) {
  1104. WRITE_HEATER_0(1);
  1105. }
  1106. else WRITE_HEATER_0P(0); // If HEATERS_PARALLEL should apply, change to WRITE_HEATER_0
  1107. #if EXTRUDERS > 1
  1108. soft_pwm_1 = soft_pwm[1];
  1109. WRITE_HEATER_1(soft_pwm_1 > 0 ? 1 : 0);
  1110. #if EXTRUDERS > 2
  1111. soft_pwm_2 = soft_pwm[2];
  1112. WRITE_HEATER_2(soft_pwm_2 > 0 ? 1 : 0);
  1113. #if EXTRUDERS > 3
  1114. soft_pwm_3 = soft_pwm[3];
  1115. WRITE_HEATER_3(soft_pwm_3 > 0 ? 1 : 0);
  1116. #endif
  1117. #endif
  1118. #endif
  1119. #if HAS_HEATER_BED
  1120. soft_pwm_BED = soft_pwm_bed;
  1121. WRITE_HEATER_BED(soft_pwm_BED > 0 ? 1 : 0);
  1122. #endif
  1123. #if ENABLED(FAN_SOFT_PWM)
  1124. #if HAS_FAN0
  1125. soft_pwm_fan[0] = fanSpeedSoftPwm[0] / 2;
  1126. WRITE_FAN(soft_pwm_fan[0] > 0 ? 1 : 0);
  1127. #endif
  1128. #if HAS_FAN1
  1129. soft_pwm_fan[1] = fanSpeedSoftPwm[1] / 2;
  1130. WRITE_FAN1(soft_pwm_fan[1] > 0 ? 1 : 0);
  1131. #endif
  1132. #if HAS_FAN2
  1133. soft_pwm_fan[2] = fanSpeedSoftPwm[2] / 2;
  1134. WRITE_FAN2(soft_pwm_fan[2] > 0 ? 1 : 0);
  1135. #endif
  1136. #endif
  1137. }
  1138. if (soft_pwm_0 < pwm_count) WRITE_HEATER_0(0);
  1139. #if EXTRUDERS > 1
  1140. if (soft_pwm_1 < pwm_count) WRITE_HEATER_1(0);
  1141. #if EXTRUDERS > 2
  1142. if (soft_pwm_2 < pwm_count) WRITE_HEATER_2(0);
  1143. #if EXTRUDERS > 3
  1144. if (soft_pwm_3 < pwm_count) WRITE_HEATER_3(0);
  1145. #endif
  1146. #endif
  1147. #endif
  1148. #if HAS_HEATER_BED
  1149. if (soft_pwm_BED < pwm_count) WRITE_HEATER_BED(0);
  1150. #endif
  1151. #if ENABLED(FAN_SOFT_PWM)
  1152. #if HAS_FAN0
  1153. if (soft_pwm_fan[0] < pwm_count) WRITE_FAN(0);
  1154. #endif
  1155. #if HAS_FAN1
  1156. if (soft_pwm_fan[1] < pwm_count) WRITE_FAN1(0);
  1157. #endif
  1158. #if HAS_FAN2
  1159. if (soft_pwm_fan[2] < pwm_count) WRITE_FAN2(0);
  1160. #endif
  1161. #endif
  1162. pwm_count += _BV(SOFT_PWM_SCALE);
  1163. pwm_count &= 0x7f;
  1164. #else // SLOW_PWM_HEATERS
  1165. /**
  1166. * SLOW PWM HEATERS
  1167. *
  1168. * for heaters drived by relay
  1169. */
  1170. #ifndef MIN_STATE_TIME
  1171. #define MIN_STATE_TIME 16 // MIN_STATE_TIME * 65.5 = time in milliseconds
  1172. #endif
  1173. // Macros for Slow PWM timer logic - HEATERS_PARALLEL applies
  1174. #define _SLOW_PWM_ROUTINE(NR, src) \
  1175. soft_pwm_ ## NR = src; \
  1176. if (soft_pwm_ ## NR > 0) { \
  1177. if (state_timer_heater_ ## NR == 0) { \
  1178. if (state_heater_ ## NR == 0) state_timer_heater_ ## NR = MIN_STATE_TIME; \
  1179. state_heater_ ## NR = 1; \
  1180. WRITE_HEATER_ ## NR(1); \
  1181. } \
  1182. } \
  1183. else { \
  1184. if (state_timer_heater_ ## NR == 0) { \
  1185. if (state_heater_ ## NR == 1) state_timer_heater_ ## NR = MIN_STATE_TIME; \
  1186. state_heater_ ## NR = 0; \
  1187. WRITE_HEATER_ ## NR(0); \
  1188. } \
  1189. }
  1190. #define SLOW_PWM_ROUTINE(n) _SLOW_PWM_ROUTINE(n, soft_pwm[n])
  1191. #define PWM_OFF_ROUTINE(NR) \
  1192. if (soft_pwm_ ## NR < slow_pwm_count) { \
  1193. if (state_timer_heater_ ## NR == 0) { \
  1194. if (state_heater_ ## NR == 1) state_timer_heater_ ## NR = MIN_STATE_TIME; \
  1195. state_heater_ ## NR = 0; \
  1196. WRITE_HEATER_ ## NR (0); \
  1197. } \
  1198. }
  1199. if (slow_pwm_count == 0) {
  1200. SLOW_PWM_ROUTINE(0); // EXTRUDER 0
  1201. #if EXTRUDERS > 1
  1202. SLOW_PWM_ROUTINE(1); // EXTRUDER 1
  1203. #if EXTRUDERS > 2
  1204. SLOW_PWM_ROUTINE(2); // EXTRUDER 2
  1205. #if EXTRUDERS > 3
  1206. SLOW_PWM_ROUTINE(3); // EXTRUDER 3
  1207. #endif
  1208. #endif
  1209. #endif
  1210. #if HAS_HEATER_BED
  1211. _SLOW_PWM_ROUTINE(BED, soft_pwm_bed); // BED
  1212. #endif
  1213. } // slow_pwm_count == 0
  1214. PWM_OFF_ROUTINE(0); // EXTRUDER 0
  1215. #if EXTRUDERS > 1
  1216. PWM_OFF_ROUTINE(1); // EXTRUDER 1
  1217. #if EXTRUDERS > 2
  1218. PWM_OFF_ROUTINE(2); // EXTRUDER 2
  1219. #if EXTRUDERS > 3
  1220. PWM_OFF_ROUTINE(3); // EXTRUDER 3
  1221. #endif
  1222. #endif
  1223. #endif
  1224. #if HAS_HEATER_BED
  1225. PWM_OFF_ROUTINE(BED); // BED
  1226. #endif
  1227. #if ENABLED(FAN_SOFT_PWM)
  1228. if (pwm_count == 0) {
  1229. #if HAS_FAN0
  1230. soft_pwm_fan[0] = fanSpeedSoftPwm[0] / 2;
  1231. WRITE_FAN(soft_pwm_fan[0] > 0 ? 1 : 0);
  1232. #endif
  1233. #if HAS_FAN1
  1234. soft_pwm_fan[1] = fanSpeedSoftPwm[1] / 2;
  1235. WRITE_FAN1(soft_pwm_fan[1] > 0 ? 1 : 0);
  1236. #endif
  1237. #if HAS_FAN2
  1238. soft_pwm_fan[2] = fanSpeedSoftPwm[2] / 2;
  1239. WRITE_FAN2(soft_pwm_fan[2] > 0 ? 1 : 0);
  1240. #endif
  1241. }
  1242. #if HAS_FAN0
  1243. if (soft_pwm_fan[0] < pwm_count) WRITE_FAN(0);
  1244. #endif
  1245. #if HAS_FAN1
  1246. if (soft_pwm_fan[1] < pwm_count) WRITE_FAN1(0);
  1247. #endif
  1248. #if HAS_FAN2
  1249. if (soft_pwm_fan[2] < pwm_count) WRITE_FAN2(0);
  1250. #endif
  1251. #endif //FAN_SOFT_PWM
  1252. pwm_count += _BV(SOFT_PWM_SCALE);
  1253. pwm_count &= 0x7f;
  1254. // increment slow_pwm_count only every 64 pwm_count circa 65.5ms
  1255. if ((pwm_count % 64) == 0) {
  1256. slow_pwm_count++;
  1257. slow_pwm_count &= 0x7f;
  1258. // EXTRUDER 0
  1259. if (state_timer_heater_0 > 0) state_timer_heater_0--;
  1260. #if EXTRUDERS > 1 // EXTRUDER 1
  1261. if (state_timer_heater_1 > 0) state_timer_heater_1--;
  1262. #if EXTRUDERS > 2 // EXTRUDER 2
  1263. if (state_timer_heater_2 > 0) state_timer_heater_2--;
  1264. #if EXTRUDERS > 3 // EXTRUDER 3
  1265. if (state_timer_heater_3 > 0) state_timer_heater_3--;
  1266. #endif
  1267. #endif
  1268. #endif
  1269. #if HAS_HEATER_BED
  1270. if (state_timer_heater_BED > 0) state_timer_heater_BED--;
  1271. #endif
  1272. } // (pwm_count % 64) == 0
  1273. #endif // SLOW_PWM_HEATERS
  1274. #define SET_ADMUX_ADCSRA(pin) ADMUX = _BV(REFS0) | (pin & 0x07); SBI(ADCSRA, ADSC)
  1275. #ifdef MUX5
  1276. #define START_ADC(pin) if (pin > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
  1277. #else
  1278. #define START_ADC(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
  1279. #endif
  1280. // Prepare or measure a sensor, each one every 12th frame
  1281. switch (temp_state) {
  1282. case PrepareTemp_0:
  1283. #if HAS_TEMP_0
  1284. START_ADC(TEMP_0_PIN);
  1285. #endif
  1286. lcd_buttons_update();
  1287. temp_state = MeasureTemp_0;
  1288. break;
  1289. case MeasureTemp_0:
  1290. #if HAS_TEMP_0
  1291. raw_temp_value[0] += ADC;
  1292. #endif
  1293. temp_state = PrepareTemp_BED;
  1294. break;
  1295. case PrepareTemp_BED:
  1296. #if HAS_TEMP_BED
  1297. START_ADC(TEMP_BED_PIN);
  1298. #endif
  1299. lcd_buttons_update();
  1300. temp_state = MeasureTemp_BED;
  1301. break;
  1302. case MeasureTemp_BED:
  1303. #if HAS_TEMP_BED
  1304. raw_temp_bed_value += ADC;
  1305. #endif
  1306. temp_state = PrepareTemp_1;
  1307. break;
  1308. case PrepareTemp_1:
  1309. #if HAS_TEMP_1
  1310. START_ADC(TEMP_1_PIN);
  1311. #endif
  1312. lcd_buttons_update();
  1313. temp_state = MeasureTemp_1;
  1314. break;
  1315. case MeasureTemp_1:
  1316. #if HAS_TEMP_1
  1317. raw_temp_value[1] += ADC;
  1318. #endif
  1319. temp_state = PrepareTemp_2;
  1320. break;
  1321. case PrepareTemp_2:
  1322. #if HAS_TEMP_2
  1323. START_ADC(TEMP_2_PIN);
  1324. #endif
  1325. lcd_buttons_update();
  1326. temp_state = MeasureTemp_2;
  1327. break;
  1328. case MeasureTemp_2:
  1329. #if HAS_TEMP_2
  1330. raw_temp_value[2] += ADC;
  1331. #endif
  1332. temp_state = PrepareTemp_3;
  1333. break;
  1334. case PrepareTemp_3:
  1335. #if HAS_TEMP_3
  1336. START_ADC(TEMP_3_PIN);
  1337. #endif
  1338. lcd_buttons_update();
  1339. temp_state = MeasureTemp_3;
  1340. break;
  1341. case MeasureTemp_3:
  1342. #if HAS_TEMP_3
  1343. raw_temp_value[3] += ADC;
  1344. #endif
  1345. temp_state = Prepare_FILWIDTH;
  1346. break;
  1347. case Prepare_FILWIDTH:
  1348. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  1349. START_ADC(FILWIDTH_PIN);
  1350. #endif
  1351. lcd_buttons_update();
  1352. temp_state = Measure_FILWIDTH;
  1353. break;
  1354. case Measure_FILWIDTH:
  1355. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  1356. // raw_filwidth_value += ADC; //remove to use an IIR filter approach
  1357. if (ADC > 102) { //check that ADC is reading a voltage > 0.5 volts, otherwise don't take in the data.
  1358. raw_filwidth_value -= (raw_filwidth_value >> 7); //multiply raw_filwidth_value by 127/128
  1359. raw_filwidth_value += ((unsigned long)ADC << 7); //add new ADC reading
  1360. }
  1361. #endif
  1362. temp_state = PrepareTemp_0;
  1363. temp_count++;
  1364. break;
  1365. case StartupDelay:
  1366. temp_state = PrepareTemp_0;
  1367. break;
  1368. // default:
  1369. // SERIAL_ERROR_START;
  1370. // SERIAL_ERRORLNPGM("Temp measurement error!");
  1371. // break;
  1372. } // switch(temp_state)
  1373. if (temp_count >= OVERSAMPLENR) { // 10 * 16 * 1/(16000000/64/256) = 164ms.
  1374. // Update the raw values if they've been read. Else we could be updating them during reading.
  1375. if (!temp_meas_ready) set_current_temp_raw();
  1376. // Filament Sensor - can be read any time since IIR filtering is used
  1377. #if ENABLED(FILAMENT_WIDTH_SENSOR)
  1378. current_raw_filwidth = raw_filwidth_value >> 10; // Divide to get to 0-16384 range since we used 1/128 IIR filter approach
  1379. #endif
  1380. temp_count = 0;
  1381. for (int i = 0; i < 4; i++) raw_temp_value[i] = 0;
  1382. raw_temp_bed_value = 0;
  1383. #if HAS_TEMP_0 && DISABLED(HEATER_0_USES_MAX6675)
  1384. #if HEATER_0_RAW_LO_TEMP > HEATER_0_RAW_HI_TEMP
  1385. #define GE0 <=
  1386. #else
  1387. #define GE0 >=
  1388. #endif
  1389. if (current_temperature_raw[0] GE0 maxttemp_raw[0]) max_temp_error(0);
  1390. if (minttemp_raw[0] GE0 current_temperature_raw[0]) min_temp_error(0);
  1391. #endif
  1392. #if HAS_TEMP_1 && EXTRUDERS > 1
  1393. #if HEATER_1_RAW_LO_TEMP > HEATER_1_RAW_HI_TEMP
  1394. #define GE1 <=
  1395. #else
  1396. #define GE1 >=
  1397. #endif
  1398. if (current_temperature_raw[1] GE1 maxttemp_raw[1]) max_temp_error(1);
  1399. if (minttemp_raw[1] GE1 current_temperature_raw[1]) min_temp_error(1);
  1400. #endif // TEMP_SENSOR_1
  1401. #if HAS_TEMP_2 && EXTRUDERS > 2
  1402. #if HEATER_2_RAW_LO_TEMP > HEATER_2_RAW_HI_TEMP
  1403. #define GE2 <=
  1404. #else
  1405. #define GE2 >=
  1406. #endif
  1407. if (current_temperature_raw[2] GE2 maxttemp_raw[2]) max_temp_error(2);
  1408. if (minttemp_raw[2] GE2 current_temperature_raw[2]) min_temp_error(2);
  1409. #endif // TEMP_SENSOR_2
  1410. #if HAS_TEMP_3 && EXTRUDERS > 3
  1411. #if HEATER_3_RAW_LO_TEMP > HEATER_3_RAW_HI_TEMP
  1412. #define GE3 <=
  1413. #else
  1414. #define GE3 >=
  1415. #endif
  1416. if (current_temperature_raw[3] GE3 maxttemp_raw[3]) max_temp_error(3);
  1417. if (minttemp_raw[3] GE3 current_temperature_raw[3]) min_temp_error(3);
  1418. #endif // TEMP_SENSOR_3
  1419. #if HAS_TEMP_BED
  1420. #if HEATER_BED_RAW_LO_TEMP > HEATER_BED_RAW_HI_TEMP
  1421. #define GEBED <=
  1422. #else
  1423. #define GEBED >=
  1424. #endif
  1425. if (current_temperature_bed_raw GEBED bed_maxttemp_raw) _temp_error(-1, PSTR(MSG_T_MAXTEMP), PSTR(MSG_ERR_MAXTEMP_BED));
  1426. if (bed_minttemp_raw GEBED current_temperature_bed_raw) _temp_error(-1, PSTR(MSG_T_MINTEMP), PSTR(MSG_ERR_MINTEMP_BED));
  1427. #endif
  1428. } // temp_count >= OVERSAMPLENR
  1429. #if ENABLED(BABYSTEPPING)
  1430. for (uint8_t axis = X_AXIS; axis <= Z_AXIS; axis++) {
  1431. int curTodo = babystepsTodo[axis]; //get rid of volatile for performance
  1432. if (curTodo > 0) {
  1433. stepper.babystep(axis,/*fwd*/true);
  1434. babystepsTodo[axis]--; //fewer to do next time
  1435. }
  1436. else if (curTodo < 0) {
  1437. stepper.babystep(axis,/*fwd*/false);
  1438. babystepsTodo[axis]++; //fewer to do next time
  1439. }
  1440. }
  1441. #endif //BABYSTEPPING
  1442. }