andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Treat temperature as integer, when possible

pull/1/head
Scott Lahteine 8 years ago
parent
1b2c7ec20a
commit
2658cc707a
6 changed files with 89 additions and 91 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      Marlin/Marlin.h
  2. 53
      Marlin/Marlin_main.cpp
  3. 5
      Marlin/planner.cpp
  4. 56
      Marlin/temperature.cpp
  5. 60
      Marlin/temperature.h
  6. 4
      Marlin/ultralcd.cpp

2
Marlin/Marlin.h
View File

@ -361,7 +361,7 @@ int16_t code_value_temp_diff();
#endif
#if FAN_COUNT > 0
extern int fanSpeeds[FAN_COUNT];
extern int16_t fanSpeeds[FAN_COUNT];
#endif
#if ENABLED(BARICUDA)

53
Marlin/Marlin_main.cpp
View File

@ -440,7 +440,7 @@ float soft_endstop_min[XYZ] = { X_MIN_POS, Y_MIN_POS, Z_MIN_POS },
soft_endstop_max[XYZ] = { X_MAX_POS, Y_MAX_POS, Z_MAX_POS };
#if FAN_COUNT > 0
int fanSpeeds[FAN_COUNT] = { 0 };
int16_t fanSpeeds[FAN_COUNT] = { 0 };
#endif
// The active extruder (tool). Set with T<extruder> command.
@ -1297,20 +1297,19 @@ inline bool code_value_bool() { return !code_has_value() || code_value_byte() >
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
inline void set_input_temp_units(TempUnit units) { input_temp_units = units; }
float code_value_temp_abs() {
int16_t code_value_temp_abs() {
switch (input_temp_units) {
case TEMPUNIT_C:
return code_value_float();
case TEMPUNIT_F:
return (code_value_float() - 32) * 0.5555555556;
case TEMPUNIT_K:
return code_value_float() - 273.15;
case TEMPUNIT_C:
default:
return code_value_float();
return code_value_int();
}
}
float code_value_temp_diff() {
int16_t code_value_temp_diff() {
switch (input_temp_units) {
case TEMPUNIT_C:
case TEMPUNIT_K:
@ -1322,8 +1321,8 @@ inline bool code_value_bool() { return !code_has_value() || code_value_byte() >
}
}
#else
float code_value_temp_abs() { return code_value_float(); }
float code_value_temp_diff() { return code_value_float(); }
int16_t code_value_temp_abs() { return code_value_int(); }
int16_t code_value_temp_diff() { return code_value_int(); }
#endif
FORCE_INLINE millis_t code_value_millis() { return code_value_ulong(); }
@ -1384,7 +1383,7 @@ bool get_target_extruder_from_command(int code) {
static float raised_parked_position[XYZE]; // used in mode 1
static millis_t delayed_move_time = 0; // used in mode 1
static float duplicate_extruder_x_offset = DEFAULT_DUPLICATION_X_OFFSET; // used in mode 2
static float duplicate_extruder_temp_offset = 0; // used in mode 2
static int16_t duplicate_extruder_temp_offset = 0; // used in mode 2
#endif // DUAL_X_CARRIAGE
@ -2073,10 +2072,10 @@ static void clean_up_after_endstop_or_probe_move() {
void set_heaters_for_bltouch(const bool deploy) {
static bool heaters_were_disabled = false;
static millis_t next_emi_protection = 0;
static float temps_at_entry[HOTENDS];
static int16_t temps_at_entry[HOTENDS];
#if HAS_TEMP_BED
static float bed_temp_at_entry;
static int16_t bed_temp_at_entry;
#endif
// If called out of order or far apart something is seriously wrong
@ -6471,10 +6470,11 @@ inline void gcode_M104() {
#endif
if (code_seen('S')) {
thermalManager.setTargetHotend(code_value_temp_abs(), target_extruder);
const int16_t temp = code_value_temp_abs();
thermalManager.setTargetHotend(temp, target_extruder);
#if ENABLED(DUAL_X_CARRIAGE)
if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && target_extruder == 0)
thermalManager.setTargetHotend(code_value_temp_abs() == 0.0 ? 0.0 : code_value_temp_abs() + duplicate_extruder_temp_offset, 1);
thermalManager.setTargetHotend(temp ? temp + duplicate_extruder_temp_offset : 0, 1);
#endif
#if ENABLED(PRINTJOB_TIMER_AUTOSTART)
@ -6484,7 +6484,7 @@ inline void gcode_M104() {
* standby mode, for instance in a dual extruder setup, without affecting
* the running print timer.
*/
if (code_value_temp_abs() <= (EXTRUDE_MINTEMP)/2) {
if (code_value_temp_abs() <= (EXTRUDE_MINTEMP) / 2) {
print_job_timer.stop();
LCD_MESSAGEPGM(WELCOME_MSG);
}
@ -6507,7 +6507,7 @@ inline void gcode_M104() {
SERIAL_PROTOCOLPGM(" /");
SERIAL_PROTOCOL_F(thermalManager.degTargetHotend(target_extruder), 1);
#if ENABLED(SHOW_TEMP_ADC_VALUES)
SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_raw[target_extruder] / OVERSAMPLENR);
SERIAL_PROTOCOLPAIR(" (", thermalManager.rawHotendTemp(target_extruder) / OVERSAMPLENR);
SERIAL_PROTOCOLCHAR(')');
#endif
#endif
@ -6517,7 +6517,7 @@ inline void gcode_M104() {
SERIAL_PROTOCOLPGM(" /");
SERIAL_PROTOCOL_F(thermalManager.degTargetBed(), 1);
#if ENABLED(SHOW_TEMP_ADC_VALUES)
SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_bed_raw / OVERSAMPLENR);
SERIAL_PROTOCOLPAIR(" (", thermalManager.rawBedTemp() / OVERSAMPLENR);
SERIAL_PROTOCOLCHAR(')');
#endif
#endif
@ -6529,7 +6529,7 @@ inline void gcode_M104() {
SERIAL_PROTOCOLPGM(" /");
SERIAL_PROTOCOL_F(thermalManager.degTargetHotend(e), 1);
#if ENABLED(SHOW_TEMP_ADC_VALUES)
SERIAL_PROTOCOLPAIR(" (", thermalManager.current_temperature_raw[e] / OVERSAMPLENR);
SERIAL_PROTOCOLPAIR(" (", thermalManager.rawHotendTemp(e) / OVERSAMPLENR);
SERIAL_PROTOCOLCHAR(')');
#endif
}
@ -6665,10 +6665,11 @@ inline void gcode_M109() {
const bool no_wait_for_cooling = code_seen('S');
if (no_wait_for_cooling || code_seen('R')) {
thermalManager.setTargetHotend(code_value_temp_abs(), target_extruder);
const int16_t temp = code_value_temp_abs();
thermalManager.setTargetHotend(temp, target_extruder);
#if ENABLED(DUAL_X_CARRIAGE)
if (dual_x_carriage_mode == DXC_DUPLICATION_MODE && target_extruder == 0)
thermalManager.setTargetHotend(code_value_temp_abs() == 0.0 ? 0.0 : code_value_temp_abs() + duplicate_extruder_temp_offset, 1);
thermalManager.setTargetHotend(temp ? temp + duplicate_extruder_temp_offset : 0, 1);
#endif
#if ENABLED(PRINTJOB_TIMER_AUTOSTART)
@ -7196,7 +7197,7 @@ inline void gcode_M92() {
LOOP_XYZE(i) {
if (code_seen(axis_codes[i])) {
if (i == E_AXIS) {
const float value = code_value_per_axis_unit(E_AXIS + TARGET_EXTRUDER);
const float value = code_value_per_axis_unit((AxisEnum)(E_AXIS + TARGET_EXTRUDER));
if (value < 20.0) {
float factor = planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] / value; // increase e constants if M92 E14 is given for netfab.
planner.max_jerk[E_AXIS] *= factor;
@ -7206,7 +7207,7 @@ inline void gcode_M92() {
planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] = value;
}
else {
planner.axis_steps_per_mm[i] = code_value_per_axis_unit(i);
planner.axis_steps_per_mm[i] = code_value_per_axis_unit((AxisEnum)i);
}
}
}
@ -8100,11 +8101,11 @@ inline void gcode_M226() {
*/
inline void gcode_M303() {
#if HAS_PID_HEATING
int e = code_seen('E') ? code_value_int() : 0;
int c = code_seen('C') ? code_value_int() : 5;
bool u = code_seen('U') && code_value_bool();
const int e = code_seen('E') ? code_value_int() : 0,
c = code_seen('C') ? code_value_int() : 5;
const bool u = code_seen('U') && code_value_bool();
float temp = code_seen('S') ? code_value_temp_abs() : (e < 0 ? 70.0 : 150.0);
int16_t temp = code_seen('S') ? code_value_temp_abs() : (e < 0 ? 70 : 150);
if (WITHIN(e, 0, HOTENDS - 1))
target_extruder = e;
@ -8741,7 +8742,6 @@ inline void gcode_M503() {
const millis_t nozzle_timeout = millis() + (millis_t)(FILAMENT_CHANGE_NOZZLE_TIMEOUT) * 1000UL;
bool nozzle_timed_out = false;
float temps[4];
// Wait for filament insert by user and press button
lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_INSERT);
@ -8752,6 +8752,7 @@ inline void gcode_M503() {
idle();
int16_t temps[HOTENDS];
HOTEND_LOOP() temps[e] = thermalManager.target_temperature[e]; // Save nozzle temps
KEEPALIVE_STATE(PAUSED_FOR_USER);

5
Marlin/planner.cpp
View File

@ -387,10 +387,7 @@ void Planner::recalculate() {
float t = autotemp_min + high * autotemp_factor;
t = constrain(t, autotemp_min, autotemp_max);
if (oldt > t) {
t *= (1 - (AUTOTEMP_OLDWEIGHT));
t += (AUTOTEMP_OLDWEIGHT) * oldt;
}
if (t < oldt) t = t * (1 - (AUTOTEMP_OLDWEIGHT)) + oldt * (AUTOTEMP_OLDWEIGHT);
oldt = t;
thermalManager.setTargetHotend(t, 0);
}

56
Marlin/temperature.cpp
View File

@ -64,10 +64,10 @@ Temperature thermalManager;
float Temperature::current_temperature[HOTENDS] = { 0.0 },
Temperature::current_temperature_bed = 0.0;
int Temperature::current_temperature_raw[HOTENDS] = { 0 },
Temperature::target_temperature[HOTENDS] = { 0 },
Temperature::current_temperature_bed_raw = 0,
Temperature::target_temperature_bed = 0;
int16_t Temperature::current_temperature_raw[HOTENDS] = { 0 },
Temperature::target_temperature[HOTENDS] = { 0 },
Temperature::current_temperature_bed_raw = 0,
Temperature::target_temperature_bed = 0;
#if ENABLED(TEMP_SENSOR_1_AS_REDUNDANT)
float Temperature::redundant_temperature = 0.0;
@ -160,33 +160,33 @@ volatile bool Temperature::temp_meas_ready = false;
millis_t Temperature::next_bed_check_ms;
#endif
unsigned long Temperature::raw_temp_value[MAX_EXTRUDERS] = { 0 };
unsigned long Temperature::raw_temp_bed_value = 0;
uint16_t Temperature::raw_temp_value[MAX_EXTRUDERS] = { 0 },
Temperature::raw_temp_bed_value = 0;
// Init min and max temp with extreme values to prevent false errors during startup
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, HEATER_4_RAW_LO_TEMP),
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, HEATER_4_RAW_HI_TEMP),
Temperature::minttemp[HOTENDS] = { 0 },
Temperature::maxttemp[HOTENDS] = ARRAY_BY_HOTENDS1(16383);
int16_t 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, HEATER_4_RAW_LO_TEMP),
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, HEATER_4_RAW_HI_TEMP),
Temperature::minttemp[HOTENDS] = { 0 },
Temperature::maxttemp[HOTENDS] = ARRAY_BY_HOTENDS1(16383);
#ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
int Temperature::consecutive_low_temperature_error[HOTENDS] = { 0 };
uint8_t Temperature::consecutive_low_temperature_error[HOTENDS] = { 0 };
#endif
#ifdef MILLISECONDS_PREHEAT_TIME
unsigned long Temperature::preheat_end_time[HOTENDS] = { 0 };
millis_t Temperature::preheat_end_time[HOTENDS] = { 0 };
#endif
#ifdef BED_MINTEMP
int Temperature::bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP;
int16_t Temperature::bed_minttemp_raw = HEATER_BED_RAW_LO_TEMP;
#endif
#ifdef BED_MAXTEMP
int Temperature::bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP;
int16_t Temperature::bed_maxttemp_raw = HEATER_BED_RAW_HI_TEMP;
#endif
#if ENABLED(FILAMENT_WIDTH_SENSOR)
int Temperature::meas_shift_index; // Index of a delayed sample in buffer
int16_t Temperature::meas_shift_index; // Index of a delayed sample in buffer
#endif
#if HAS_AUTO_FAN
@ -1242,7 +1242,7 @@ void Temperature::init() {
millis_t Temperature::thermal_runaway_bed_timer;
#endif
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) {
void Temperature::thermal_runaway_protection(Temperature::TRState* state, millis_t* timer, float current, float target, int heater_id, int period_seconds, int hysteresis_degc) {
static float tr_target_temperature[HOTENDS + 1] = { 0.0 };
@ -1252,17 +1252,17 @@ void Temperature::init() {
if (heater_id < 0) SERIAL_ECHOPGM("bed"); else SERIAL_ECHO(heater_id);
SERIAL_ECHOPAIR(" ; State:", *state);
SERIAL_ECHOPAIR(" ; Timer:", *timer);
SERIAL_ECHOPAIR(" ; Temperature:", temperature);
SERIAL_ECHOPAIR(" ; Target Temp:", target_temperature);
SERIAL_ECHOPAIR(" ; Temperature:", current);
SERIAL_ECHOPAIR(" ; Target Temp:", target);
SERIAL_EOL;
*/
int heater_index = heater_id >= 0 ? heater_id : HOTENDS;
// If the target temperature changes, restart
if (tr_target_temperature[heater_index] != target_temperature) {
tr_target_temperature[heater_index] = target_temperature;
*state = target_temperature > 0 ? TRFirstHeating : TRInactive;
if (tr_target_temperature[heater_index] != target) {
tr_target_temperature[heater_index] = target;
*state = target > 0 ? TRFirstHeating : TRInactive;
}
switch (*state) {
@ -1270,11 +1270,11 @@ void Temperature::init() {
case TRInactive: break;
// When first heating, wait for the temperature to be reached then go to Stable state
case TRFirstHeating:
if (temperature < tr_target_temperature[heater_index]) break;
if (current < tr_target_temperature[heater_index]) break;
*state = TRStable;
// While the temperature is stable watch for a bad temperature
case TRStable:
if (temperature >= tr_target_temperature[heater_index] - hysteresis_degc) {
if (current >= tr_target_temperature[heater_index] - hysteresis_degc) {
*timer = millis() + period_seconds * 1000UL;
break;
}
@ -1961,9 +1961,9 @@ void Temperature::isr() {
};
for (uint8_t e = 0; e < COUNT(temp_dir); e++) {
const int tdir = temp_dir[e], rawtemp = current_temperature_raw[e] * tdir;
if (rawtemp > maxttemp_raw[e] * tdir && target_temperature[e] > 0.0f) max_temp_error(e);
if (rawtemp < minttemp_raw[e] * tdir && !is_preheating(e) && target_temperature[e] > 0.0f) {
const int16_t tdir = temp_dir[e], rawtemp = current_temperature_raw[e] * tdir;
if (rawtemp > maxttemp_raw[e] * tdir && target_temperature[e] > 0) max_temp_error(e);
if (rawtemp < minttemp_raw[e] * tdir && !is_preheating(e) && target_temperature[e] > 0) {
#ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
if (++consecutive_low_temperature_error[e] >= MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED)
#endif
@ -1981,8 +1981,8 @@ void Temperature::isr() {
#else
#define GEBED >=
#endif
if (current_temperature_bed_raw GEBED bed_maxttemp_raw && target_temperature_bed > 0.0f) max_temp_error(-1);
if (bed_minttemp_raw GEBED current_temperature_bed_raw && target_temperature_bed > 0.0f) min_temp_error(-1);
if (current_temperature_bed_raw GEBED bed_maxttemp_raw && target_temperature_bed > 0) max_temp_error(-1);
if (bed_minttemp_raw GEBED current_temperature_bed_raw && target_temperature_bed > 0) min_temp_error(-1);
#endif
} // temp_count >= OVERSAMPLENR

60
Marlin/temperature.h
View File

@ -99,10 +99,10 @@ class Temperature {
static float current_temperature[HOTENDS],
current_temperature_bed;
static int current_temperature_raw[HOTENDS],
target_temperature[HOTENDS],
current_temperature_bed_raw,
target_temperature_bed;
static int16_t current_temperature_raw[HOTENDS],
target_temperature[HOTENDS],
current_temperature_bed_raw,
target_temperature_bed;
static volatile bool in_temp_isr;
@ -217,33 +217,33 @@ class Temperature {
static millis_t next_bed_check_ms;
#endif
static unsigned long raw_temp_value[MAX_EXTRUDERS],
raw_temp_bed_value;
static uint16_t raw_temp_value[MAX_EXTRUDERS],
raw_temp_bed_value;
// Init min and max temp with extreme values to prevent false errors during startup
static int minttemp_raw[HOTENDS],
maxttemp_raw[HOTENDS],
minttemp[HOTENDS],
maxttemp[HOTENDS];
static int16_t minttemp_raw[HOTENDS],
maxttemp_raw[HOTENDS],
minttemp[HOTENDS],
maxttemp[HOTENDS];
#ifdef MAX_CONSECUTIVE_LOW_TEMPERATURE_ERROR_ALLOWED
static int consecutive_low_temperature_error[HOTENDS];
static uint8_t consecutive_low_temperature_error[HOTENDS];
#endif
#ifdef MILLISECONDS_PREHEAT_TIME
static unsigned long preheat_end_time[HOTENDS];
static millis_t preheat_end_time[HOTENDS];
#endif
#ifdef BED_MINTEMP
static int bed_minttemp_raw;
static int16_t bed_minttemp_raw;
#endif
#ifdef BED_MAXTEMP
static int bed_maxttemp_raw;
static int16_t bed_maxttemp_raw;
#endif
#if ENABLED(FILAMENT_WIDTH_SENSOR)
static int meas_shift_index; // Index of a delayed sample in buffer
static int16_t meas_shift_index; // Index of a delayed sample in buffer
#endif
#if HAS_AUTO_FAN
@ -323,31 +323,31 @@ class Temperature {
//inline so that there is no performance decrease.
//deg=degreeCelsius
static float degHotend(uint8_t e) {
static int16_t degHotend(uint8_t e) {
#if HOTENDS == 1
UNUSED(e);
#endif
return current_temperature[HOTEND_INDEX];
}
static float degBed() { return current_temperature_bed; }
static int16_t degBed() { return current_temperature_bed; }
#if ENABLED(SHOW_TEMP_ADC_VALUES)
static float rawHotendTemp(uint8_t e) {
#if HOTENDS == 1
UNUSED(e);
#endif
return current_temperature_raw[HOTEND_INDEX];
}
static float rawBedTemp() { return current_temperature_bed_raw; }
static int16_t rawHotendTemp(uint8_t e) {
#if HOTENDS == 1
UNUSED(e);
#endif
return current_temperature_raw[HOTEND_INDEX];
}
static int16_t rawBedTemp() { return current_temperature_bed_raw; }
#endif
static float degTargetHotend(uint8_t e) {
static int16_t degTargetHotend(uint8_t e) {
#if HOTENDS == 1
UNUSED(e);
#endif
return target_temperature[HOTEND_INDEX];
}
static float degTargetBed() { return target_temperature_bed; }
static int16_t degTargetBed() { return target_temperature_bed; }
#if WATCH_HOTENDS
static void start_watching_heater(uint8_t e = 0);
@ -357,14 +357,14 @@ class Temperature {
static void start_watching_bed();
#endif
static void setTargetHotend(const float& celsius, uint8_t e) {
static void setTargetHotend(const int16_t &celsius, uint8_t e) {
#if HOTENDS == 1
UNUSED(e);
#endif
#ifdef MILLISECONDS_PREHEAT_TIME
if (celsius == 0.0f)
if (celsius == 0)
reset_preheat_time(HOTEND_INDEX);
else if (target_temperature[HOTEND_INDEX] == 0.0f)
else if (target_temperature[HOTEND_INDEX] == 0)
start_preheat_time(HOTEND_INDEX);
#endif
target_temperature[HOTEND_INDEX] = celsius;
@ -373,7 +373,7 @@ class Temperature {
#endif
}
static void setTargetBed(const float& celsius) {
static void setTargetBed(const int16_t &celsius) {
target_temperature_bed = celsius;
#if WATCH_THE_BED
start_watching_bed();

4
Marlin/ultralcd.cpp
View File

@ -1179,14 +1179,14 @@ void kill_screen(const char* lcd_msg) {
}
#endif
constexpr int heater_maxtemp[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP);
constexpr int16_t heater_maxtemp[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP);
/**
*
* "Prepare" submenu items
*
*/
void _lcd_preheat(int endnum, const float temph, const float tempb, const int fan) {
void _lcd_preheat(const int endnum, const int16_t temph, const int16_t tempb, const int16_t fan) {
if (temph > 0) thermalManager.setTargetHotend(min(heater_maxtemp[endnum], temph), endnum);
#if TEMP_SENSOR_BED != 0
if (tempb >= 0) thermalManager.setTargetBed(tempb);

Write Preview
Loading…
Cancel
Save