bissen21/Marlin_Firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases 4 Wiki Activity

🧑‍💻 Remove extraneous 'inline' hints

Browse Source
This commit is contained in:
Scott Lahteine 2021-12-28 02:57:24 -06:00 committed by Scott Lahteine
parent ccc66a8528
commit 5b9f3bd4b1
67 changed files with 537 additions and 537 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Marlin/src/HAL/AVR/MarlinSerial.h
View File

@ -217,7 +217,7 @@
#endif #endif
enum { HasEmergencyParser = Cfg::EMERGENCYPARSER }; enum { HasEmergencyParser = Cfg::EMERGENCYPARSER };
static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; } static bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; } FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; } FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }

2
Marlin/src/HAL/DUE/MarlinSerial.h
View File

@ -118,7 +118,7 @@ public:
static size_t write(const uint8_t c); static size_t write(const uint8_t c);
static void flushTX(); static void flushTX();
static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; } static bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; } FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; } FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }

2
Marlin/src/HAL/LPC1768/include/SPI.h
View File

@ -77,7 +77,7 @@ public:
//uint32_t spiRate() const { return spi_speed; } //uint32_t spiRate() const { return spi_speed; }
static inline uint32_t spiRate2Clock(uint32_t spiRate) { static uint32_t spiRate2Clock(uint32_t spiRate) {
uint32_t Marlin_speed[7]; // CPSR is always 2 uint32_t Marlin_speed[7]; // CPSR is always 2
Marlin_speed[0] = 8333333; //(SCR: 2) desired: 8,000,000 actual: 8,333,333 +4.2% SPI_FULL_SPEED Marlin_speed[0] = 8333333; //(SCR: 2) desired: 8,000,000 actual: 8,333,333 +4.2% SPI_FULL_SPEED
Marlin_speed[1] = 4166667; //(SCR: 5) desired: 4,000,000 actual: 4,166,667 +4.2% SPI_HALF_SPEED Marlin_speed[1] = 4166667; //(SCR: 5) desired: 4,000,000 actual: 4,166,667 +4.2% SPI_HALF_SPEED

4
Marlin/src/HAL/LPC1768/tft/xpt2046.h
View File

@ -65,8 +65,8 @@ private:
static uint16_t getRawData(const XPTCoordinate coordinate); static uint16_t getRawData(const XPTCoordinate coordinate);
static bool isTouched(); static bool isTouched();
static inline void DataTransferBegin() { WRITE(TOUCH_CS_PIN, LOW); }; static void DataTransferBegin() { WRITE(TOUCH_CS_PIN, LOW); };
static inline void DataTransferEnd() { WRITE(TOUCH_CS_PIN, HIGH); }; static void DataTransferEnd() { WRITE(TOUCH_CS_PIN, HIGH); };
#if ENABLED(TOUCH_BUTTONS_HW_SPI) #if ENABLED(TOUCH_BUTTONS_HW_SPI)
static uint16_t HardwareIO(uint16_t data); static uint16_t HardwareIO(uint16_t data);
#endif #endif

4
Marlin/src/HAL/NATIVE_SIM/tft/xpt2046.h
View File

@ -62,8 +62,8 @@ private:
static uint16_t getRawData(const XPTCoordinate coordinate); static uint16_t getRawData(const XPTCoordinate coordinate);
static bool isTouched(); static bool isTouched();
static inline void DataTransferBegin(); static void DataTransferBegin();
static inline void DataTransferEnd(); static void DataTransferEnd();
#if ENABLED(TOUCH_BUTTONS_HW_SPI) #if ENABLED(TOUCH_BUTTONS_HW_SPI)
static uint16_t HardwareIO(uint16_t data); static uint16_t HardwareIO(uint16_t data);
#endif #endif

4
Marlin/src/HAL/STM32/tft/xpt2046.h
View File

@ -69,8 +69,8 @@ private:
static uint16_t getRawData(const XPTCoordinate coordinate); static uint16_t getRawData(const XPTCoordinate coordinate);
static bool isTouched(); static bool isTouched();
static inline void DataTransferBegin() { if (SPIx.Instance) { HAL_SPI_Init(&SPIx); } WRITE(TOUCH_CS_PIN, LOW); }; static void DataTransferBegin() { if (SPIx.Instance) { HAL_SPI_Init(&SPIx); } WRITE(TOUCH_CS_PIN, LOW); };
static inline void DataTransferEnd() { WRITE(TOUCH_CS_PIN, HIGH); }; static void DataTransferEnd() { WRITE(TOUCH_CS_PIN, HIGH); };
static uint16_t HardwareIO(uint16_t data); static uint16_t HardwareIO(uint16_t data);
static uint16_t SoftwareIO(uint16_t data); static uint16_t SoftwareIO(uint16_t data);
static uint16_t IO(uint16_t data = 0) { return SPIx.Instance ? HardwareIO(data) : SoftwareIO(data); } static uint16_t IO(uint16_t data = 0) { return SPIx.Instance ? HardwareIO(data) : SoftwareIO(data); }

2
Marlin/src/HAL/STM32F1/SPI.h
View File

@ -417,7 +417,7 @@ private:
/** /**
* @brief Wait until TXE (tx empty) flag is set and BSY (busy) flag unset. * @brief Wait until TXE (tx empty) flag is set and BSY (busy) flag unset.
*/ */
static inline void waitSpiTxEnd(spi_dev *spi_d) { static void waitSpiTxEnd(spi_dev *spi_d) {
while (spi_is_tx_empty(spi_d) == 0) { /* nada */ } // wait until TXE=1 while (spi_is_tx_empty(spi_d) == 0) { /* nada */ } // wait until TXE=1
while (spi_is_busy(spi_d) != 0) { /* nada */ } // wait until BSY=0 while (spi_is_busy(spi_d) != 0) { /* nada */ } // wait until BSY=0
} }

14
Marlin/src/HAL/STM32F1/pinsDebug.h
View File

@ -54,11 +54,11 @@ extern const stm32_pin_info PIN_MAP[BOARD_NR_GPIO_PINS];
#define M43_NEVER_TOUCH(Q) (Q >= 9 && Q <= 12) // SERIAL/USB pins PA9(TX) PA10(RX) #define M43_NEVER_TOUCH(Q) (Q >= 9 && Q <= 12) // SERIAL/USB pins PA9(TX) PA10(RX)
#endif #endif
static inline int8_t get_pin_mode(pin_t pin) { static int8_t get_pin_mode(pin_t pin) {
return VALID_PIN(pin) ? _GET_MODE(pin) : -1; return VALID_PIN(pin) ? _GET_MODE(pin) : -1;
} }
static inline pin_t DIGITAL_PIN_TO_ANALOG_PIN(pin_t pin) { static pin_t DIGITAL_PIN_TO_ANALOG_PIN(pin_t pin) {
if (!VALID_PIN(pin)) return -1; if (!VALID_PIN(pin)) return -1;
int8_t adc_channel = int8_t(PIN_MAP[pin].adc_channel); int8_t adc_channel = int8_t(PIN_MAP[pin].adc_channel);
#ifdef NUM_ANALOG_INPUTS #ifdef NUM_ANALOG_INPUTS
@ -67,7 +67,7 @@ static inline pin_t DIGITAL_PIN_TO_ANALOG_PIN(pin_t pin) {
return pin_t(adc_channel); return pin_t(adc_channel);
} }
static inline bool IS_ANALOG(pin_t pin) { static bool IS_ANALOG(pin_t pin) {
if (!VALID_PIN(pin)) return false; if (!VALID_PIN(pin)) return false;
if (PIN_MAP[pin].adc_channel != ADCx) { if (PIN_MAP[pin].adc_channel != ADCx) {
#ifdef NUM_ANALOG_INPUTS #ifdef NUM_ANALOG_INPUTS
@ -78,11 +78,11 @@ static inline bool IS_ANALOG(pin_t pin) {
return false; return false;
} }
static inline bool GET_PINMODE(const pin_t pin) { static bool GET_PINMODE(const pin_t pin) {
return VALID_PIN(pin) && !IS_INPUT(pin); return VALID_PIN(pin) && !IS_INPUT(pin);
} }
static inline bool GET_ARRAY_IS_DIGITAL(const int16_t array_pin) { static bool GET_ARRAY_IS_DIGITAL(const int16_t array_pin) {
const pin_t pin = GET_ARRAY_PIN(array_pin); const pin_t pin = GET_ARRAY_PIN(array_pin);
return (!IS_ANALOG(pin) return (!IS_ANALOG(pin)
#ifdef NUM_ANALOG_INPUTS #ifdef NUM_ANALOG_INPUTS
@ -93,7 +93,7 @@ static inline bool GET_ARRAY_IS_DIGITAL(const int16_t array_pin) {
#include "../../inc/MarlinConfig.h" // Allow pins/pins.h to set density #include "../../inc/MarlinConfig.h" // Allow pins/pins.h to set density
static inline void pwm_details(const pin_t pin) { static void pwm_details(const pin_t pin) {
if (PWM_PIN(pin)) { if (PWM_PIN(pin)) {
timer_dev * const tdev = PIN_MAP[pin].timer_device; timer_dev * const tdev = PIN_MAP[pin].timer_device;
const uint8_t channel = PIN_MAP[pin].timer_channel; const uint8_t channel = PIN_MAP[pin].timer_channel;
@ -113,7 +113,7 @@ static inline void pwm_details(const pin_t pin) {
} }
} }
static inline void print_port(pin_t pin) { static void print_port(pin_t pin) {
const char port = 'A' + char(pin >> 4); // pin div 16 const char port = 'A' + char(pin >> 4); // pin div 16
const int16_t gbit = PIN_MAP[pin].gpio_bit; const int16_t gbit = PIN_MAP[pin].gpio_bit;
char buffer[8]; char buffer[8];

4
Marlin/src/HAL/STM32F1/tft/xpt2046.h
View File

@ -65,8 +65,8 @@ private:
static uint16_t getRawData(const XPTCoordinate coordinate); static uint16_t getRawData(const XPTCoordinate coordinate);
static bool isTouched(); static bool isTouched();
static inline void DataTransferBegin() { WRITE(TOUCH_CS_PIN, LOW); }; static void DataTransferBegin() { WRITE(TOUCH_CS_PIN, LOW); };
static inline void DataTransferEnd() { WRITE(TOUCH_CS_PIN, HIGH); }; static void DataTransferEnd() { WRITE(TOUCH_CS_PIN, HIGH); };
#if ENABLED(TOUCH_BUTTONS_HW_SPI) #if ENABLED(TOUCH_BUTTONS_HW_SPI)
static uint16_t HardwareIO(uint16_t data); static uint16_t HardwareIO(uint16_t data);
#endif #endif

6
Marlin/src/HAL/shared/eeprom_api.h
View File

@ -49,7 +49,7 @@ public:
// Write one or more bytes of data // Write one or more bytes of data
// Return 'true' on write error // Return 'true' on write error
static inline bool write_data(const int pos, const uint8_t *value, const size_t size=sizeof(uint8_t)) { static bool write_data(const int pos, const uint8_t *value, const size_t size=sizeof(uint8_t)) {
int data_pos = pos; int data_pos = pos;
uint16_t crc = 0; uint16_t crc = 0;
return write_data(data_pos, value, size, &crc); return write_data(data_pos, value, size, &crc);
@ -57,11 +57,11 @@ public:
// Write a single byte of data // Write a single byte of data
// Return 'true' on write error // Return 'true' on write error
static inline bool write_data(const int pos, const uint8_t value) { return write_data(pos, &value); } static bool write_data(const int pos, const uint8_t value) { return write_data(pos, &value); }
// Read one or more bytes of data // Read one or more bytes of data
// Return 'true' on read error // Return 'true' on read error
static inline bool read_data(const int pos, uint8_t *value, const size_t size=1) { static bool read_data(const int pos, uint8_t *value, const size_t size=1) {
int data_pos = pos; int data_pos = pos;
uint16_t crc = 0; uint16_t crc = 0;
return read_data(data_pos, value, size, &crc); return read_data(data_pos, value, size, &crc);

16
Marlin/src/core/macros.h
View File

@ -131,13 +131,13 @@
#ifdef __cplusplus #ifdef __cplusplus
// C++11 solution that is standards compliant. // C++11 solution that is standards compliant.
template <class V, class N> static inline constexpr void NOLESS(V& v, const N n) { template <class V, class N> static constexpr void NOLESS(V& v, const N n) {
if (n > v) v = n; if (n > v) v = n;
} }
template <class V, class N> static inline constexpr void NOMORE(V& v, const N n) { template <class V, class N> static constexpr void NOMORE(V& v, const N n) {
if (n < v) v = n; if (n < v) v = n;
} }
template <class V, class N1, class N2> static inline constexpr void LIMIT(V& v, const N1 n1, const N2 n2) { template <class V, class N1, class N2> static constexpr void LIMIT(V& v, const N1 n1, const N2 n2) {
if (n1 > v) v = n1; if (n1 > v) v = n1;
else if (n2 < v) v = n2; else if (n2 < v) v = n2;
} }
@ -366,7 +366,7 @@
#undef ABS #undef ABS
#ifdef __cplusplus #ifdef __cplusplus
template <class T> static inline constexpr const T ABS(const T v) { return v >= 0 ? v : -v; } template <class T> static constexpr const T ABS(const T v) { return v >= 0 ? v : -v; }
#else #else
#define ABS(a) ({__typeof__(a) _a = (a); _a >= 0 ? _a : -_a;}) #define ABS(a) ({__typeof__(a) _a = (a); _a >= 0 ? _a : -_a;})
#endif #endif
@ -409,14 +409,14 @@
extern "C++" { extern "C++" {
// C++11 solution that is standards compliant. Return type is deduced automatically // C++11 solution that is standards compliant. Return type is deduced automatically
template <class L, class R> static inline constexpr auto _MIN(const L lhs, const R rhs) -> decltype(lhs + rhs) { template <class L, class R> static constexpr auto _MIN(const L lhs, const R rhs) -> decltype(lhs + rhs) {
return lhs < rhs ? lhs : rhs; return lhs < rhs ? lhs : rhs;
} }
template <class L, class R> static inline constexpr auto _MAX(const L lhs, const R rhs) -> decltype(lhs + rhs) { template <class L, class R> static constexpr auto _MAX(const L lhs, const R rhs) -> decltype(lhs + rhs) {
return lhs > rhs ? lhs : rhs; return lhs > rhs ? lhs : rhs;
} }
template<class T, class ... Ts> static inline constexpr const T _MIN(T V, Ts... Vs) { return _MIN(V, _MIN(Vs...)); } template<class T, class ... Ts> static constexpr const T _MIN(T V, Ts... Vs) { return _MIN(V, _MIN(Vs...)); }
template<class T, class ... Ts> static inline constexpr const T _MAX(T V, Ts... Vs) { return _MAX(V, _MAX(Vs...)); } template<class T, class ... Ts> static constexpr const T _MAX(T V, Ts... Vs) { return _MAX(V, _MAX(Vs...)); }
} }

2
Marlin/src/core/serial_hook.h
View File

@ -37,7 +37,7 @@ public:
inline constexpr bool enabled(const SerialMask PortMask) const { return mask & PortMask.mask; } inline constexpr bool enabled(const SerialMask PortMask) const { return mask & PortMask.mask; }
inline constexpr SerialMask combine(const SerialMask other) const { return SerialMask(mask | other.mask); } inline constexpr SerialMask combine(const SerialMask other) const { return SerialMask(mask | other.mask); }
inline constexpr SerialMask operator<< (const int offset) const { return SerialMask(mask << offset); } inline constexpr SerialMask operator<< (const int offset) const { return SerialMask(mask << offset); }
static inline SerialMask from(const serial_index_t index) { static SerialMask from(const serial_index_t index) {
if (index.valid()) return SerialMask(_BV(index.index)); if (index.valid()) return SerialMask(_BV(index.index));
return SerialMask(0); // A invalid index mean no output return SerialMask(0); // A invalid index mean no output
} }

6
Marlin/src/feature/babystep.h
View File

@ -54,7 +54,7 @@ public:
#if ENABLED(BABYSTEP_DISPLAY_TOTAL) #if ENABLED(BABYSTEP_DISPLAY_TOTAL)
static int16_t axis_total[BS_TOTAL_IND(Z_AXIS) + 1]; // Total babysteps since G28 static int16_t axis_total[BS_TOTAL_IND(Z_AXIS) + 1]; // Total babysteps since G28
static inline void reset_total(const AxisEnum axis) { static void reset_total(const AxisEnum axis) {
if (TERN1(BABYSTEP_XY, axis == Z_AXIS)) if (TERN1(BABYSTEP_XY, axis == Z_AXIS))
axis_total[BS_TOTAL_IND(axis)] = 0; axis_total[BS_TOTAL_IND(axis)] = 0;
} }
@ -63,7 +63,7 @@ public:
static void add_steps(const AxisEnum axis, const int16_t distance); static void add_steps(const AxisEnum axis, const int16_t distance);
static void add_mm(const AxisEnum axis, const_float_t mm); static void add_mm(const AxisEnum axis, const_float_t mm);
static inline bool has_steps() { static bool has_steps() {
return steps[BS_AXIS_IND(X_AXIS)] || steps[BS_AXIS_IND(Y_AXIS)] || steps[BS_AXIS_IND(Z_AXIS)]; return steps[BS_AXIS_IND(X_AXIS)] || steps[BS_AXIS_IND(Y_AXIS)] || steps[BS_AXIS_IND(Z_AXIS)];
} }
@ -71,7 +71,7 @@ public:
// Called by the Temperature or Stepper ISR to // Called by the Temperature or Stepper ISR to
// apply accumulated babysteps to the axes. // apply accumulated babysteps to the axes.
// //
static inline void task() { static void task() {
LOOP_LE_N(i, BS_AXIS_IND(Z_AXIS)) step_axis(BS_AXIS(i)); LOOP_LE_N(i, BS_AXIS_IND(Z_AXIS)) step_axis(BS_AXIS(i));
} }

10
Marlin/src/feature/backlash.h
View File

@ -35,8 +35,8 @@ public:
static float smoothing_mm; static float smoothing_mm;
#endif #endif
static inline void set_correction(const_float_t v) { correction = _MAX(0, _MIN(1.0, v)) * all_on; } static void set_correction(const_float_t v) { correction = _MAX(0, _MIN(1.0, v)) * all_on; }
static inline float get_correction() { return float(ui8_to_percent(correction)) / 100.0f; } static float get_correction() { return float(ui8_to_percent(correction)) / 100.0f; }
#else #else
static constexpr uint8_t correction = (BACKLASH_CORRECTION) * 0xFF; static constexpr uint8_t correction = (BACKLASH_CORRECTION) * 0xFF;
static const xyz_float_t distance_mm; static const xyz_float_t distance_mm;
@ -53,7 +53,7 @@ public:
static void measure_with_probe(); static void measure_with_probe();
#endif #endif
static inline float get_measurement(const AxisEnum a) { static float get_measurement(const AxisEnum a) {
UNUSED(a); UNUSED(a);
// Return the measurement averaged over all readings // Return the measurement averaged over all readings
return TERN(MEASURE_BACKLASH_WHEN_PROBING return TERN(MEASURE_BACKLASH_WHEN_PROBING
@ -62,12 +62,12 @@ public:
); );
} }
static inline bool has_measurement(const AxisEnum a) { static bool has_measurement(const AxisEnum a) {
UNUSED(a); UNUSED(a);
return TERN0(MEASURE_BACKLASH_WHEN_PROBING, measured_count[a] > 0); return TERN0(MEASURE_BACKLASH_WHEN_PROBING, measured_count[a] > 0);
} }
static inline bool has_any_measurement() { static bool has_any_measurement() {
return has_measurement(X_AXIS) || has_measurement(Y_AXIS) || has_measurement(Z_AXIS); return has_measurement(X_AXIS) || has_measurement(Y_AXIS) || has_measurement(Z_AXIS);
} }

10
Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.h
View File

@ -58,7 +58,7 @@ public:
static void set_z(const int8_t px, const int8_t py, const_float_t z) { z_values[px][py] = z; } static void set_z(const int8_t px, const int8_t py, const_float_t z) { z_values[px][py] = z; }
static inline void zigzag(const int8_t index, int8_t &px, int8_t &py) { static void zigzag(const int8_t index, int8_t &px, int8_t &py) {
px = index % (GRID_MAX_POINTS_X); px = index % (GRID_MAX_POINTS_X);
py = index / (GRID_MAX_POINTS_X); py = index / (GRID_MAX_POINTS_X);
if (py & 1) px = (GRID_MAX_POINTS_X) - 1 - px; // Zig zag if (py & 1) px = (GRID_MAX_POINTS_X) - 1 - px; // Zig zag
@ -78,10 +78,10 @@ public:
int8_t cy = (y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST); int8_t cy = (y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST);
return constrain(cy, 0, GRID_MAX_CELLS_Y - 1); return constrain(cy, 0, GRID_MAX_CELLS_Y - 1);
} }
static inline xy_int8_t cell_indexes(const_float_t x, const_float_t y) { static xy_int8_t cell_indexes(const_float_t x, const_float_t y) {
return { cell_index_x(x), cell_index_y(y) }; return { cell_index_x(x), cell_index_y(y) };
} }
static inline xy_int8_t cell_indexes(const xy_pos_t &xy) { return cell_indexes(xy.x, xy.y); } static xy_int8_t cell_indexes(const xy_pos_t &xy) { return cell_indexes(xy.x, xy.y); }
static int8_t probe_index_x(const_float_t x) { static int8_t probe_index_x(const_float_t x) {
int8_t px = (x - (MESH_MIN_X) + 0.5f * (MESH_X_DIST)) * RECIPROCAL(MESH_X_DIST); int8_t px = (x - (MESH_MIN_X) + 0.5f * (MESH_X_DIST)) * RECIPROCAL(MESH_X_DIST);
@ -91,10 +91,10 @@ public:
int8_t py = (y - (MESH_MIN_Y) + 0.5f * (MESH_Y_DIST)) * RECIPROCAL(MESH_Y_DIST); int8_t py = (y - (MESH_MIN_Y) + 0.5f * (MESH_Y_DIST)) * RECIPROCAL(MESH_Y_DIST);
return WITHIN(py, 0, (GRID_MAX_POINTS_Y) - 1) ? py : -1; return WITHIN(py, 0, (GRID_MAX_POINTS_Y) - 1) ? py : -1;
} }
static inline xy_int8_t probe_indexes(const_float_t x, const_float_t y) { static xy_int8_t probe_indexes(const_float_t x, const_float_t y) {
return { probe_index_x(x), probe_index_y(y) }; return { probe_index_x(x), probe_index_y(y) };
} }
static inline xy_int8_t probe_indexes(const xy_pos_t &xy) { return probe_indexes(xy.x, xy.y); } static xy_int8_t probe_indexes(const xy_pos_t &xy) { return probe_indexes(xy.x, xy.y); }
static float calc_z0(const_float_t a0, const_float_t a1, const_float_t z1, const_float_t a2, const_float_t z2) { static float calc_z0(const_float_t a0, const_float_t a1, const_float_t z1, const_float_t a2, const_float_t z2) {
const float delta_z = (z2 - z1) / (a2 - a1), const float delta_z = (z2 - z1) / (a2 - a1),

22
Marlin/src/feature/bedlevel/ubl/ubl.h
View File

@ -80,7 +80,7 @@ private:
static void tilt_mesh_based_on_3pts(const_float_t z1, const_float_t z2, const_float_t z3); static void tilt_mesh_based_on_3pts(const_float_t z1, const_float_t z2, const_float_t z3);
static void tilt_mesh_based_on_probed_grid(const bool do_ubl_mesh_map); static void tilt_mesh_based_on_probed_grid(const bool do_ubl_mesh_map);
static bool smart_fill_one(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir); static bool smart_fill_one(const uint8_t x, const uint8_t y, const int8_t xdir, const int8_t ydir);
static inline bool smart_fill_one(const xy_uint8_t &pos, const xy_uint8_t &dir) { static bool smart_fill_one(const xy_uint8_t &pos, const xy_uint8_t &dir) {
return smart_fill_one(pos.x, pos.y, dir.x, dir.y); return smart_fill_one(pos.x, pos.y, dir.x, dir.y);
} }
static void smart_fill_mesh(); static void smart_fill_mesh();
@ -124,7 +124,7 @@ public:
static bool lcd_map_control; static bool lcd_map_control;
static void steppers_were_disabled(); static void steppers_were_disabled();
#else #else
static inline void steppers_were_disabled() {} static void steppers_were_disabled() {}
#endif #endif
static volatile int16_t encoder_diff; // Volatile because buttons may change it at interrupt time static volatile int16_t encoder_diff; // Volatile because buttons may change it at interrupt time
@ -157,10 +157,10 @@ public:
return constrain(cell_index_y_raw(y), 0, GRID_MAX_CELLS_Y - 1); return constrain(cell_index_y_raw(y), 0, GRID_MAX_CELLS_Y - 1);
} }
static inline xy_int8_t cell_indexes(const_float_t x, const_float_t y) { static xy_int8_t cell_indexes(const_float_t x, const_float_t y) {
return { cell_index_x(x), cell_index_y(y) }; return { cell_index_x(x), cell_index_y(y) };
} }
static inline xy_int8_t cell_indexes(const xy_pos_t &xy) { return cell_indexes(xy.x, xy.y); } static xy_int8_t cell_indexes(const xy_pos_t &xy) { return cell_indexes(xy.x, xy.y); }
static int8_t closest_x_index(const_float_t x) { static int8_t closest_x_index(const_float_t x) {
const int8_t px = (x - (MESH_MIN_X) + (MESH_X_DIST) * 0.5) * RECIPROCAL(MESH_X_DIST); const int8_t px = (x - (MESH_MIN_X) + (MESH_X_DIST) * 0.5) * RECIPROCAL(MESH_X_DIST);
@ -170,7 +170,7 @@ public:
const int8_t py = (y - (MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * RECIPROCAL(MESH_Y_DIST); const int8_t py = (y - (MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * RECIPROCAL(MESH_Y_DIST);
return WITHIN(py, 0, (GRID_MAX_POINTS_Y) - 1) ? py : -1; return WITHIN(py, 0, (GRID_MAX_POINTS_Y) - 1) ? py : -1;
} }
static inline xy_int8_t closest_indexes(const xy_pos_t &xy) { static xy_int8_t closest_indexes(const xy_pos_t &xy) {
return { closest_x_index(xy.x), closest_y_index(xy.y) }; return { closest_x_index(xy.x), closest_y_index(xy.y) };
} }
@ -203,7 +203,7 @@ public:
* z_correction_for_x_on_horizontal_mesh_line is an optimization for * z_correction_for_x_on_horizontal_mesh_line is an optimization for
* the case where the printer is making a vertical line that only crosses horizontal mesh lines. * the case where the printer is making a vertical line that only crosses horizontal mesh lines.
*/ */
static inline float z_correction_for_x_on_horizontal_mesh_line(const_float_t rx0, const int x1_i, const int yi) { static float z_correction_for_x_on_horizontal_mesh_line(const_float_t rx0, const int x1_i, const int yi) {
if (!WITHIN(x1_i, 0, (GRID_MAX_POINTS_X) - 1) || !WITHIN(yi, 0, (GRID_MAX_POINTS_Y) - 1)) { if (!WITHIN(x1_i, 0, (GRID_MAX_POINTS_X) - 1) || !WITHIN(yi, 0, (GRID_MAX_POINTS_Y) - 1)) {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
@ -226,7 +226,7 @@ public:
// //
// See comments above for z_correction_for_x_on_horizontal_mesh_line // See comments above for z_correction_for_x_on_horizontal_mesh_line
// //
static inline float z_correction_for_y_on_vertical_mesh_line(const_float_t ry0, const int xi, const int y1_i) { static float z_correction_for_y_on_vertical_mesh_line(const_float_t ry0, const int xi, const int y1_i) {
if (!WITHIN(xi, 0, (GRID_MAX_POINTS_X) - 1) || !WITHIN(y1_i, 0, (GRID_MAX_POINTS_Y) - 1)) { if (!WITHIN(xi, 0, (GRID_MAX_POINTS_X) - 1) || !WITHIN(y1_i, 0, (GRID_MAX_POINTS_Y) - 1)) {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
@ -285,12 +285,12 @@ public:
return z0; return z0;
} }
static inline float get_z_correction(const xy_pos_t &pos) { return get_z_correction(pos.x, pos.y); } static float get_z_correction(const xy_pos_t &pos) { return get_z_correction(pos.x, pos.y); }
static inline float mesh_index_to_xpos(const uint8_t i) { static float mesh_index_to_xpos(const uint8_t i) {
return i < (GRID_MAX_POINTS_X) ? pgm_read_float(&_mesh_index_to_xpos[i]) : MESH_MIN_X + i * (MESH_X_DIST); return i < (GRID_MAX_POINTS_X) ? pgm_read_float(&_mesh_index_to_xpos[i]) : MESH_MIN_X + i * (MESH_X_DIST);
} }
static inline float mesh_index_to_ypos(const uint8_t i) { static float mesh_index_to_ypos(const uint8_t i) {
return i < (GRID_MAX_POINTS_Y) ? pgm_read_float(&_mesh_index_to_ypos[i]) : MESH_MIN_Y + i * (MESH_Y_DIST); return i < (GRID_MAX_POINTS_Y) ? pgm_read_float(&_mesh_index_to_ypos[i]) : MESH_MIN_Y + i * (MESH_Y_DIST);
} }
@ -300,7 +300,7 @@ public:
static void line_to_destination_cartesian(const_feedRate_t scaled_fr_mm_s, const uint8_t e); static void line_to_destination_cartesian(const_feedRate_t scaled_fr_mm_s, const uint8_t e);
#endif #endif
static inline bool mesh_is_valid() { static bool mesh_is_valid() {
GRID_LOOP(x, y) if (isnan(z_values[x][y])) return false; GRID_LOOP(x, y) if (isnan(z_values[x][y])) return false;
return true; return true;
} }

2
Marlin/src/feature/bltouch.h
View File

@ -76,7 +76,7 @@ public:
static constexpr bool high_speed_mode = false; static constexpr bool high_speed_mode = false;
#endif #endif
static inline float z_extra_clearance() { return high_speed_mode ? 7 : 0; } static float z_extra_clearance() { return high_speed_mode ? 7 : 0; }
// DEPLOY and STOW are wrapped for error handling - these are used by homing and by probing // DEPLOY and STOW are wrapped for error handling - these are used by homing and by probing
static bool deploy() { return deploy_proc(); } static bool deploy() { return deploy_proc(); }

8
Marlin/src/feature/cancel_object.h
View File

@ -32,10 +32,10 @@ public:
static void cancel_object(const int8_t obj); static void cancel_object(const int8_t obj);
static void uncancel_object(const int8_t obj); static void uncancel_object(const int8_t obj);
static void report(); static void report();
static inline bool is_canceled(const int8_t obj) { return TEST(canceled, obj); } static bool is_canceled(const int8_t obj) { return TEST(canceled, obj); }
static inline void clear_active_object() { set_active_object(-1); } static void clear_active_object() { set_active_object(-1); }
static inline void cancel_active_object() { cancel_object(active_object); } static void cancel_active_object() { cancel_object(active_object); }
static inline void reset() { canceled = 0x0000; object_count = 0; clear_active_object(); } static void reset() { canceled = 0x0000; object_count = 0; clear_active_object(); }
}; };
extern CancelObject cancelable; extern CancelObject cancelable;

4
Marlin/src/feature/caselight.h
View File

@ -49,8 +49,8 @@ public:
} }
static void update(const bool sflag); static void update(const bool sflag);
static inline void update_brightness() { update(false); } static void update_brightness() { update(false); }
static inline void update_enabled() { update(true); } static void update_enabled() { update(true); }
#if ENABLED(CASE_LIGHT_IS_COLOR_LED) #if ENABLED(CASE_LIGHT_IS_COLOR_LED)
private: private:

6
Marlin/src/feature/controllerfan.h
View File

@ -60,9 +60,9 @@ class ControllerFan {
#else #else
static const controllerFan_settings_t &settings; static const controllerFan_settings_t &settings;
#endif #endif
static inline bool state() { return speed > 0; } static bool state() { return speed > 0; }
static inline void init() { reset(); } static void init() { reset(); }
static inline void reset() { TERN_(CONTROLLER_FAN_EDITABLE, settings = controllerFan_defaults); } static void reset() { TERN_(CONTROLLER_FAN_EDITABLE, settings = controllerFan_defaults); }
static void setup(); static void setup();
static void update(); static void update();
}; };

8
Marlin/src/feature/fancheck.h
View File

@ -56,7 +56,7 @@ class FanCheck {
static uint8_t rps[TACHO_COUNT]; static uint8_t rps[TACHO_COUNT];
static TachoError error; static TachoError error;
static inline void report_speed_error(uint8_t fan); static void report_speed_error(uint8_t fan);
public: public:
@ -67,11 +67,11 @@ class FanCheck {
static void compute_speed(uint16_t elapsedTime); static void compute_speed(uint16_t elapsedTime);
static void print_fan_states(); static void print_fan_states();
#if HAS_PWMFANCHECK #if HAS_PWMFANCHECK
static inline void toggle_measuring() { measuring = !measuring; } static void toggle_measuring() { measuring = !measuring; }
static inline bool is_measuring() { return measuring; } static bool is_measuring() { return measuring; }
#endif #endif
static inline void check_deferred_error() { static void check_deferred_error() {
if (error == TachoError::DETECTED) { if (error == TachoError::DETECTED) {
error = TachoError::REPORTED; error = TachoError::REPORTED;
TERN(PARK_HEAD_ON_PAUSE, queue.inject(F("M125")), kill(GET_TEXT_F(MSG_FAN_SPEED_FAULT))); TERN(PARK_HEAD_ON_PAUSE, queue.inject(F("M125")), kill(GET_TEXT_F(MSG_FAN_SPEED_FAULT)));

16
Marlin/src/feature/filwidth.h
View File

@ -41,9 +41,9 @@ public:
FilamentWidthSensor() { init(); } FilamentWidthSensor() { init(); }
static void init(); static void init();
static inline void enable(const bool ena) { enabled = ena; } static void enable(const bool ena) { enabled = ena; }
static inline void set_delay_cm(const uint8_t cm) { static void set_delay_cm(const uint8_t cm) {
meas_delay_cm = _MIN(cm, MAX_MEASUREMENT_DELAY); meas_delay_cm = _MIN(cm, MAX_MEASUREMENT_DELAY);
} }
@ -67,18 +67,18 @@ public:
} }
// Convert raw measurement to mm // Convert raw measurement to mm
static inline float raw_to_mm(const uint16_t v) { return v * 5.0f * RECIPROCAL(float(MAX_RAW_THERMISTOR_VALUE)); } static float raw_to_mm(const uint16_t v) { return v * 5.0f * RECIPROCAL(float(MAX_RAW_THERMISTOR_VALUE)); }
static inline float raw_to_mm() { return raw_to_mm(raw); } static float raw_to_mm() { return raw_to_mm(raw); }
// A scaled reading is ready // A scaled reading is ready
// Divide to get to 0-16384 range since we used 1/128 IIR filter approach // Divide to get to 0-16384 range since we used 1/128 IIR filter approach
static inline void reading_ready() { raw = accum >> 10; } static void reading_ready() { raw = accum >> 10; }
// Update mm from the raw measurement // Update mm from the raw measurement
static inline void update_measured_mm() { measured_mm = raw_to_mm(); } static void update_measured_mm() { measured_mm = raw_to_mm(); }
// Update ring buffer used to delay filament measurements // Update ring buffer used to delay filament measurements
static inline void advance_e(const_float_t e_move) { static void advance_e(const_float_t e_move) {
// Increment counters with the E distance // Increment counters with the E distance
e_count += e_move; e_count += e_move;
@ -106,7 +106,7 @@ public:
} }
// Dynamically set the volumetric multiplier based on the delayed width measurement. // Dynamically set the volumetric multiplier based on the delayed width measurement.
static inline void update_volumetric() { static void update_volumetric() {
if (enabled) { if (enabled) {
int8_t read_index = index_r - meas_delay_cm; int8_t read_index = index_r - meas_delay_cm;
if (read_index < 0) read_index += MMD_CM; // Loop around buffer if needed if (read_index < 0) read_index += MMD_CM; // Loop around buffer if needed

4
Marlin/src/feature/host_actions.h
View File

@ -97,7 +97,7 @@ class HostUI {
static void handle_response(const uint8_t response); static void handle_response(const uint8_t response);
static void notify_P(PGM_P const message); static void notify_P(PGM_P const message);
static inline void notify(FSTR_P const fmsg) { notify_P(FTOP(fmsg)); } static void notify(FSTR_P const fmsg) { notify_P(FTOP(fmsg)); }
static void notify(const char * const message); static void notify(const char * const message);
static void prompt_begin(const PromptReason reason, FSTR_P const fstr, const char extra_char='\0'); static void prompt_begin(const PromptReason reason, FSTR_P const fstr, const char extra_char='\0');
@ -105,7 +105,7 @@ class HostUI {
static void prompt_end(); static void prompt_end();
static void prompt_do(const PromptReason reason, FSTR_P const pstr, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr); static void prompt_do(const PromptReason reason, FSTR_P const pstr, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr);
static void prompt_do(const PromptReason reason, FSTR_P const pstr, const char extra_char, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr); static void prompt_do(const PromptReason reason, FSTR_P const pstr, const char extra_char, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr);
static inline void prompt_open(const PromptReason reason, FSTR_P const pstr, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr) { static void prompt_open(const PromptReason reason, FSTR_P const pstr, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr) {
if (host_prompt_reason == PROMPT_NOT_DEFINED) prompt_do(reason, pstr, btn1, btn2); if (host_prompt_reason == PROMPT_NOT_DEFINED) prompt_do(reason, pstr, btn1, btn2);
} }

52
Marlin/src/feature/leds/leds.h
View File

@ -118,7 +118,7 @@ public:
OPTARG(NEOPIXEL_IS_SEQUENTIAL, bool isSequence=false) OPTARG(NEOPIXEL_IS_SEQUENTIAL, bool isSequence=false)
); );
static inline void set_color(uint8_t r, uint8_t g, uint8_t b static void set_color(uint8_t r, uint8_t g, uint8_t b
OPTARG(HAS_WHITE_LED, uint8_t w=0) OPTARG(HAS_WHITE_LED, uint8_t w=0)
OPTARG(NEOPIXEL_LED, uint8_t i=NEOPIXEL_BRIGHTNESS) OPTARG(NEOPIXEL_LED, uint8_t i=NEOPIXEL_BRIGHTNESS)
OPTARG(NEOPIXEL_IS_SEQUENTIAL, bool isSequence=false) OPTARG(NEOPIXEL_IS_SEQUENTIAL, bool isSequence=false)
@ -126,23 +126,23 @@ public:
set_color(LEDColor(r, g, b OPTARG(HAS_WHITE_LED, w) OPTARG(NEOPIXEL_LED, i)) OPTARG(NEOPIXEL_IS_SEQUENTIAL, isSequence)); set_color(LEDColor(r, g, b OPTARG(HAS_WHITE_LED, w) OPTARG(NEOPIXEL_LED, i)) OPTARG(NEOPIXEL_IS_SEQUENTIAL, isSequence));
} }
static inline void set_off() { set_color(LEDColorOff()); } static void set_off() { set_color(LEDColorOff()); }
static inline void set_green() { set_color(LEDColorGreen()); } static void set_green() { set_color(LEDColorGreen()); }
static inline void set_white() { set_color(LEDColorWhite()); } static void set_white() { set_color(LEDColorWhite()); }
#if ENABLED(LED_COLOR_PRESETS) #if ENABLED(LED_COLOR_PRESETS)
static const LEDColor defaultLEDColor; static const LEDColor defaultLEDColor;
static inline void set_default() { set_color(defaultLEDColor); } static void set_default() { set_color(defaultLEDColor); }
static inline void set_red() { set_color(LEDColorRed()); } static void set_red() { set_color(LEDColorRed()); }
static inline void set_orange() { set_color(LEDColorOrange()); } static void set_orange() { set_color(LEDColorOrange()); }
static inline void set_yellow() { set_color(LEDColorYellow()); } static void set_yellow() { set_color(LEDColorYellow()); }
static inline void set_blue() { set_color(LEDColorBlue()); } static void set_blue() { set_color(LEDColorBlue()); }
static inline void set_indigo() { set_color(LEDColorIndigo()); } static void set_indigo() { set_color(LEDColorIndigo()); }
static inline void set_violet() { set_color(LEDColorViolet()); } static void set_violet() { set_color(LEDColorViolet()); }
#endif #endif
#if ENABLED(PRINTER_EVENT_LEDS) #if ENABLED(PRINTER_EVENT_LEDS)
static inline LEDColor get_color() { return lights_on ? color : LEDColorOff(); } static LEDColor get_color() { return lights_on ? color : LEDColorOff(); }
#endif #endif
#if ANY(LED_CONTROL_MENU, PRINTER_EVENT_LEDS, CASE_LIGHT_IS_COLOR_LED) #if ANY(LED_CONTROL_MENU, PRINTER_EVENT_LEDS, CASE_LIGHT_IS_COLOR_LED)
@ -154,14 +154,14 @@ public:
static void toggle(); // swap "off" with color static void toggle(); // swap "off" with color
#endif #endif
#if EITHER(LED_CONTROL_MENU, CASE_LIGHT_USE_RGB_LED) #if EITHER(LED_CONTROL_MENU, CASE_LIGHT_USE_RGB_LED)
static inline void update() { set_color(color); } static void update() { set_color(color); }
#endif #endif
#ifdef LED_BACKLIGHT_TIMEOUT #ifdef LED_BACKLIGHT_TIMEOUT
private: private:
static millis_t led_off_time; static millis_t led_off_time;
public: public:
static inline void reset_timeout(const millis_t &ms) { static void reset_timeout(const millis_t &ms) {
led_off_time = ms + LED_BACKLIGHT_TIMEOUT; led_off_time = ms + LED_BACKLIGHT_TIMEOUT;
if (!lights_on) update(); if (!lights_on) update();
} }
@ -181,7 +181,7 @@ extern LEDLights leds;
static void set_color(const LEDColor &color); static void set_color(const LEDColor &color);
static inline void set_color(uint8_t r, uint8_t g, uint8_t b static void set_color(uint8_t r, uint8_t g, uint8_t b
OPTARG(HAS_WHITE_LED, uint8_t w=0) OPTARG(HAS_WHITE_LED, uint8_t w=0)
OPTARG(NEOPIXEL_LED, uint8_t i=NEOPIXEL_BRIGHTNESS) OPTARG(NEOPIXEL_LED, uint8_t i=NEOPIXEL_BRIGHTNESS)
) { ) {
@ -191,26 +191,26 @@ extern LEDLights leds;
)); ));
} }
static inline void set_off() { set_color(LEDColorOff()); } static void set_off() { set_color(LEDColorOff()); }
static inline void set_green() { set_color(LEDColorGreen()); } static void set_green() { set_color(LEDColorGreen()); }
static inline void set_white() { set_color(LEDColorWhite()); } static void set_white() { set_color(LEDColorWhite()); }
#if ENABLED(NEO2_COLOR_PRESETS) #if ENABLED(NEO2_COLOR_PRESETS)
static const LEDColor defaultLEDColor; static const LEDColor defaultLEDColor;
static inline void set_default() { set_color(defaultLEDColor); } static void set_default() { set_color(defaultLEDColor); }
static inline void set_red() { set_color(LEDColorRed()); } static void set_red() { set_color(LEDColorRed()); }
static inline void set_orange() { set_color(LEDColorOrange()); } static void set_orange() { set_color(LEDColorOrange()); }
static inline void set_yellow() { set_color(LEDColorYellow()); } static void set_yellow() { set_color(LEDColorYellow()); }
static inline void set_blue() { set_color(LEDColorBlue()); } static void set_blue() { set_color(LEDColorBlue()); }
static inline void set_indigo() { set_color(LEDColorIndigo()); } static void set_indigo() { set_color(LEDColorIndigo()); }
static inline void set_violet() { set_color(LEDColorViolet()); } static void set_violet() { set_color(LEDColorViolet()); }
#endif #endif
#if ENABLED(NEOPIXEL2_SEPARATE) #if ENABLED(NEOPIXEL2_SEPARATE)
static LEDColor color; // last non-off color static LEDColor color; // last non-off color
static bool lights_on; // the last set color was "on" static bool lights_on; // the last set color was "on"
static void toggle(); // swap "off" with color static void toggle(); // swap "off" with color
static inline void update() { set_color(color); } static void update() { set_color(color); }
#endif #endif
}; };

28
Marlin/src/feature/leds/neopixel.h
View File

@ -94,12 +94,12 @@ public:
static void reset_background_color(); static void reset_background_color();
#endif #endif
static inline void begin() { static void begin() {
adaneo1.begin(); adaneo1.begin();
TERN_(CONJOINED_NEOPIXEL, adaneo2.begin()); TERN_(CONJOINED_NEOPIXEL, adaneo2.begin());
} }
static inline void set_pixel_color(const uint16_t n, const uint32_t c) { static void set_pixel_color(const uint16_t n, const uint32_t c) {
#if ENABLED(NEOPIXEL2_INSERIES) #if ENABLED(NEOPIXEL2_INSERIES)
if (n >= NEOPIXEL_PIXELS) adaneo2.setPixelColor(n - (NEOPIXEL_PIXELS), c); if (n >= NEOPIXEL_PIXELS) adaneo2.setPixelColor(n - (NEOPIXEL_PIXELS), c);
else adaneo1.setPixelColor(n, c); else adaneo1.setPixelColor(n, c);
@ -109,12 +109,12 @@ public:
#endif #endif
} }
static inline void set_brightness(const uint8_t b) { static void set_brightness(const uint8_t b) {
adaneo1.setBrightness(b); adaneo1.setBrightness(b);
TERN_(CONJOINED_NEOPIXEL, adaneo2.setBrightness(b)); TERN_(CONJOINED_NEOPIXEL, adaneo2.setBrightness(b));
} }
static inline void show() { static void show() {
// Some platforms cannot maintain PWM output when NeoPixel disables interrupts for long durations. // Some platforms cannot maintain PWM output when NeoPixel disables interrupts for long durations.
TERN_(HAS_PAUSE_SERVO_OUTPUT, PAUSE_SERVO_OUTPUT()); TERN_(HAS_PAUSE_SERVO_OUTPUT, PAUSE_SERVO_OUTPUT());
adaneo1.show(); adaneo1.show();
@ -130,11 +130,11 @@ public:
} }
// Accessors // Accessors
static inline uint16_t pixels() { return adaneo1.numPixels() * TERN1(NEOPIXEL2_INSERIES, 2); } static uint16_t pixels() { return adaneo1.numPixels() * TERN1(NEOPIXEL2_INSERIES, 2); }
static inline uint8_t brightness() { return adaneo1.getBrightness(); } static uint8_t brightness() { return adaneo1.getBrightness(); }
static inline uint32_t Color(uint8_t r, uint8_t g, uint8_t b OPTARG(HAS_WHITE_LED, uint8_t w)) { static uint32_t Color(uint8_t r, uint8_t g, uint8_t b OPTARG(HAS_WHITE_LED, uint8_t w)) {
return adaneo1.Color(r, g, b OPTARG(HAS_WHITE_LED, w)); return adaneo1.Color(r, g, b OPTARG(HAS_WHITE_LED, w));
} }
}; };
@ -165,18 +165,18 @@ extern Marlin_NeoPixel neo;
static void set_color(const uint32_t c); static void set_color(const uint32_t c);
static inline void begin() { adaneo.begin(); } static void begin() { adaneo.begin(); }
static inline void set_pixel_color(const uint16_t n, const uint32_t c) { adaneo.setPixelColor(n, c); } static void set_pixel_color(const uint16_t n, const uint32_t c) { adaneo.setPixelColor(n, c); }
static inline void set_brightness(const uint8_t b) { adaneo.setBrightness(b); } static void set_brightness(const uint8_t b) { adaneo.setBrightness(b); }
static inline void show() { static void show() {
adaneo.show(); adaneo.show();
adaneo.setPin(NEOPIXEL2_PIN); adaneo.setPin(NEOPIXEL2_PIN);
} }
// Accessors // Accessors
static inline uint16_t pixels() { return adaneo.numPixels();} static uint16_t pixels() { return adaneo.numPixels();}
static inline uint8_t brightness() { return adaneo.getBrightness(); } static uint8_t brightness() { return adaneo.getBrightness(); }
static inline uint32_t Color(uint8_t r, uint8_t g, uint8_t b OPTARG(HAS_WHITE_LED2, uint8_t w)) { static uint32_t Color(uint8_t r, uint8_t g, uint8_t b OPTARG(HAS_WHITE_LED2, uint8_t w)) {
return adaneo.Color(r, g, b OPTARG(HAS_WHITE_LED2, w)); return adaneo.Color(r, g, b OPTARG(HAS_WHITE_LED2, w));
} }
}; };

16
Marlin/src/feature/leds/printer_event_leds.h
View File

@ -36,32 +36,32 @@ private:
static bool leds_off_after_print; static bool leds_off_after_print;
#endif #endif
static inline void set_done() { TERN(LED_COLOR_PRESETS, leds.set_default(), leds.set_off()); } static void set_done() { TERN(LED_COLOR_PRESETS, leds.set_default(), leds.set_off()); }
public: public:
#if HAS_TEMP_HOTEND #if HAS_TEMP_HOTEND
static inline LEDColor onHotendHeatingStart() { old_intensity = 0; return leds.get_color(); } static LEDColor onHotendHeatingStart() { old_intensity = 0; return leds.get_color(); }
static void onHotendHeating(const celsius_t start, const celsius_t current, const celsius_t target); static void onHotendHeating(const celsius_t start, const celsius_t current, const celsius_t target);
#endif #endif
#if HAS_HEATED_BED #if HAS_HEATED_BED
static inline LEDColor onBedHeatingStart() { old_intensity = 127; return leds.get_color(); } static LEDColor onBedHeatingStart() { old_intensity = 127; return leds.get_color(); }
static void onBedHeating(const celsius_t start, const celsius_t current, const celsius_t target); static void onBedHeating(const celsius_t start, const celsius_t current, const celsius_t target);
#endif #endif
#if HAS_HEATED_CHAMBER #if HAS_HEATED_CHAMBER
static inline LEDColor onChamberHeatingStart() { old_intensity = 127; return leds.get_color(); } static LEDColor onChamberHeatingStart() { old_intensity = 127; return leds.get_color(); }
static void onChamberHeating(const celsius_t start, const celsius_t current, const celsius_t target); static void onChamberHeating(const celsius_t start, const celsius_t current, const celsius_t target);
#endif #endif
#if HAS_TEMP_HOTEND || HAS_HEATED_BED || HAS_HEATED_CHAMBER #if HAS_TEMP_HOTEND || HAS_HEATED_BED || HAS_HEATED_CHAMBER
static inline void onHeatingDone() { leds.set_white(); } static void onHeatingDone() { leds.set_white(); }
static inline void onPidTuningDone(LEDColor c) { leds.set_color(c); } static void onPidTuningDone(LEDColor c) { leds.set_color(c); }
#endif #endif
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
static inline void onPrintCompleted() { static void onPrintCompleted() {
leds.set_green(); leds.set_green();
#if HAS_LEDS_OFF_FLAG #if HAS_LEDS_OFF_FLAG
leds_off_after_print = true; leds_off_after_print = true;
@ -71,7 +71,7 @@ public:
#endif #endif
} }
static inline void onResumeAfterWait() { static void onResumeAfterWait() {
#if HAS_LEDS_OFF_FLAG #if HAS_LEDS_OFF_FLAG
if (leds_off_after_print) { if (leds_off_after_print) {
set_done(); set_done();

6
Marlin/src/feature/max7219.h
View File

@ -88,13 +88,13 @@ public:
static void send(const uint8_t reg, const uint8_t data); static void send(const uint8_t reg, const uint8_t data);
// Refresh all units // Refresh all units
static inline void refresh() { for (uint8_t i = 0; i < 8; i++) refresh_line(i); } static void refresh() { for (uint8_t i = 0; i < 8; i++) refresh_line(i); }
// Suspend / resume updates to the LED unit // Suspend / resume updates to the LED unit
// Use these methods to speed up multiple changes // Use these methods to speed up multiple changes
// or to apply updates from interrupt context. // or to apply updates from interrupt context.
static inline void suspend() { suspended++; } static void suspend() { suspended++; }
static inline void resume() { suspended--; suspended |= 0x80; } static void resume() { suspended--; suspended |= 0x80; }
// Update a single native line on all units // Update a single native line on all units
static void refresh_line(const uint8_t line); static void refresh_line(const uint8_t line);

10
Marlin/src/feature/mixing.h
View File

@ -126,7 +126,7 @@ class Mixer {
static mixer_perc_t mix[MIXING_STEPPERS]; // Scratch array for the Mix in proportion to 100 static mixer_perc_t mix[MIXING_STEPPERS]; // Scratch array for the Mix in proportion to 100
static inline void copy_mix_to_color(mixer_comp_t (&tcolor)[MIXING_STEPPERS]) { static void copy_mix_to_color(mixer_comp_t (&tcolor)[MIXING_STEPPERS]) {
// Scale each component to the largest one in terms of COLOR_A_MASK // Scale each component to the largest one in terms of COLOR_A_MASK
// So the largest component will be COLOR_A_MASK and the other will be in proportion to it // So the largest component will be COLOR_A_MASK and the other will be in proportion to it
const float scale = (COLOR_A_MASK) * RECIPROCAL(_MAX( const float scale = (COLOR_A_MASK) * RECIPROCAL(_MAX(
@ -145,7 +145,7 @@ class Mixer {
#endif #endif
} }
static inline void update_mix_from_vtool(const uint8_t j=selected_vtool) { static void update_mix_from_vtool(const uint8_t j=selected_vtool) {
float ctot = 0; float ctot = 0;
MIXER_STEPPER_LOOP(i) ctot += color[j][i]; MIXER_STEPPER_LOOP(i) ctot += color[j][i];
//MIXER_STEPPER_LOOP(i) mix[i] = 100.0f * color[j][i] / ctot; //MIXER_STEPPER_LOOP(i) mix[i] = 100.0f * color[j][i] / ctot;
@ -165,7 +165,7 @@ class Mixer {
#if HAS_DUAL_MIXING #if HAS_DUAL_MIXING
// Update the virtual tool from an edited mix // Update the virtual tool from an edited mix
static inline void update_vtool_from_mix() { static void update_vtool_from_mix() {
copy_mix_to_color(color[selected_vtool]); copy_mix_to_color(color[selected_vtool]);
TERN_(GRADIENT_MIX, refresh_gradient()); TERN_(GRADIENT_MIX, refresh_gradient());
// MIXER_STEPPER_LOOP(i) collector[i] = mix[i]; // MIXER_STEPPER_LOOP(i) collector[i] = mix[i];
@ -182,7 +182,7 @@ class Mixer {
// Update the current mix from the gradient for a given Z // Update the current mix from the gradient for a given Z
static void update_gradient_for_z(const_float_t z); static void update_gradient_for_z(const_float_t z);
static void update_gradient_for_planner_z(); static void update_gradient_for_planner_z();
static inline void gradient_control(const_float_t z) { static void gradient_control(const_float_t z) {
if (gradient.enabled) { if (gradient.enabled) {
if (z >= gradient.end_z) if (z >= gradient.end_z)
T(gradient.end_vtool); T(gradient.end_vtool);
@ -191,7 +191,7 @@ class Mixer {
} }
} }
static inline void update_mix_from_gradient() { static void update_mix_from_gradient() {
float ctot = 0; float ctot = 0;
MIXER_STEPPER_LOOP(i) ctot += gradient.color[i]; MIXER_STEPPER_LOOP(i) ctot += gradient.color[i];
MIXER_STEPPER_LOOP(i) mix[i] = (mixer_perc_t)CEIL(100.0f * gradient.color[i] / ctot); MIXER_STEPPER_LOOP(i) mix[i] = (mixer_perc_t)CEIL(100.0f * gradient.color[i] / ctot);

12
Marlin/src/feature/mmu/mmu2.h
View File

@ -43,7 +43,7 @@ public:
static void init(); static void init();
static void reset(); static void reset();
static inline bool enabled() { return _enabled; } static bool enabled() { return _enabled; }
static void mmu_loop(); static void mmu_loop();
static void tool_change(const uint8_t index); static void tool_change(const uint8_t index);
static void tool_change(const char *special); static void tool_change(const char *special);
@ -57,10 +57,10 @@ public:
static bool eject_filament(const uint8_t index, const bool recover); static bool eject_filament(const uint8_t index, const bool recover);
private: private:
static inline bool rx_str(FSTR_P fstr); static bool rx_str(FSTR_P fstr);
static inline void tx_str(FSTR_P fstr); static void tx_str(FSTR_P fstr);
static inline void tx_printf(FSTR_P ffmt, const int argument); static void tx_printf(FSTR_P ffmt, const int argument);
static inline void tx_printf(FSTR_P ffmt, const int argument1, const int argument2); static void tx_printf(FSTR_P ffmt, const int argument1, const int argument2);
static void clear_rx_buffer(); static void clear_rx_buffer();
static bool rx_ok(); static bool rx_ok();
@ -99,7 +99,7 @@ private:
static millis_t prev_request, prev_P0_request; static millis_t prev_request, prev_P0_request;
static char rx_buffer[MMU_RX_SIZE], tx_buffer[MMU_TX_SIZE]; static char rx_buffer[MMU_RX_SIZE], tx_buffer[MMU_TX_SIZE];
static inline void set_runout_valid(const bool valid) { static void set_runout_valid(const bool valid) {
finda_runout_valid = valid; finda_runout_valid = valid;
#if HAS_FILAMENT_SENSOR #if HAS_FILAMENT_SENSOR
if (valid) runout.reset(); if (valid) runout.reset();

2
Marlin/src/feature/power.h
View File

@ -40,7 +40,7 @@ class Power {
#if ENABLED(AUTO_POWER_CONTROL) && POWER_OFF_DELAY > 0 #if ENABLED(AUTO_POWER_CONTROL) && POWER_OFF_DELAY > 0
static void power_off_soon(); static void power_off_soon();
#else #else
static inline void power_off_soon() { power_off(); } static void power_off_soon() { power_off(); }
#endif #endif
#if ENABLED(AUTO_POWER_CONTROL) #if ENABLED(AUTO_POWER_CONTROL)

22
Marlin/src/feature/powerloss.h
View File

@ -152,7 +152,7 @@ class PrintJobRecovery {
static void init(); static void init();
static void prepare(); static void prepare();
static inline void setup() { static void setup() {
#if PIN_EXISTS(POWER_LOSS) #if PIN_EXISTS(POWER_LOSS)
#if ENABLED(POWER_LOSS_PULLUP) #if ENABLED(POWER_LOSS_PULLUP)
SET_INPUT_PULLUP(POWER_LOSS_PIN); SET_INPUT_PULLUP(POWER_LOSS_PIN);
@ -165,28 +165,28 @@ class PrintJobRecovery {
} }
// Track each command's file offsets // Track each command's file offsets
static inline uint32_t command_sdpos() { return sdpos[queue_index_r]; } static uint32_t command_sdpos() { return sdpos[queue_index_r]; }
static inline void commit_sdpos(const uint8_t index_w) { sdpos[index_w] = cmd_sdpos; } static void commit_sdpos(const uint8_t index_w) { sdpos[index_w] = cmd_sdpos; }
static bool enabled; static bool enabled;
static void enable(const bool onoff); static void enable(const bool onoff);
static void changed(); static void changed();
static inline bool exists() { return card.jobRecoverFileExists(); } static bool exists() { return card.jobRecoverFileExists(); }
static inline void open(const bool read) { card.openJobRecoveryFile(read); } static void open(const bool read) { card.openJobRecoveryFile(read); }
static inline void close() { file.close(); } static void close() { file.close(); }
static void check(); static void check();
static void resume(); static void resume();
static void purge(); static void purge();
static inline void cancel() { purge(); IF_DISABLED(NO_SD_AUTOSTART, card.autofile_begin()); } static void cancel() { purge(); IF_DISABLED(NO_SD_AUTOSTART, card.autofile_begin()); }
static void load(); static void load();
static void save(const bool force=ENABLED(SAVE_EACH_CMD_MODE), const float zraise=POWER_LOSS_ZRAISE, const bool raised=false); static void save(const bool force=ENABLED(SAVE_EACH_CMD_MODE), const float zraise=POWER_LOSS_ZRAISE, const bool raised=false);
#if PIN_EXISTS(POWER_LOSS) #if PIN_EXISTS(POWER_LOSS)
static inline void outage() { static void outage() {
static constexpr uint8_t OUTAGE_THRESHOLD = 3; static constexpr uint8_t OUTAGE_THRESHOLD = 3;
static uint8_t outage_counter = 0; static uint8_t outage_counter = 0;
if (enabled && READ(POWER_LOSS_PIN) == POWER_LOSS_STATE) { if (enabled && READ(POWER_LOSS_PIN) == POWER_LOSS_STATE) {
@ -199,14 +199,14 @@ class PrintJobRecovery {
#endif #endif
// The referenced file exists // The referenced file exists
static inline bool interrupted_file_exists() { return card.fileExists(info.sd_filename); } static bool interrupted_file_exists() { return card.fileExists(info.sd_filename); }
static inline bool valid() { return info.valid() && interrupted_file_exists(); } static bool valid() { return info.valid() && interrupted_file_exists(); }
#if ENABLED(DEBUG_POWER_LOSS_RECOVERY) #if ENABLED(DEBUG_POWER_LOSS_RECOVERY)
static void debug(FSTR_P const prefix); static void debug(FSTR_P const prefix);
#else #else
static inline void debug(FSTR_P const) {} static void debug(FSTR_P const) {}
#endif #endif
private: private:

6
Marlin/src/feature/probe_temp_comp.h
View File

@ -74,11 +74,11 @@ class ProbeTempComp {
static int16_t z_offsets_hotend[PTC_HOTEND_COUNT]; // (µm) static int16_t z_offsets_hotend[PTC_HOTEND_COUNT]; // (µm)
#endif #endif
static inline void reset_index() { calib_idx = 0; }; static void reset_index() { calib_idx = 0; };
static inline uint8_t get_index() { return calib_idx; } static uint8_t get_index() { return calib_idx; }
static void reset(); static void reset();
static void clear_offsets(const TempSensorID tsi); static void clear_offsets(const TempSensorID tsi);
static inline void clear_all_offsets() { static void clear_all_offsets() {
TERN_(PTC_PROBE, clear_offsets(TSI_PROBE)); TERN_(PTC_PROBE, clear_offsets(TSI_PROBE));
TERN_(PTC_BED, clear_offsets(TSI_BED)); TERN_(PTC_BED, clear_offsets(TSI_BED));
TERN_(PTC_HOTEND, clear_offsets(TSI_EXT)); TERN_(PTC_HOTEND, clear_offsets(TSI_EXT));

4
Marlin/src/feature/repeat.h
View File

@ -38,8 +38,8 @@ private:
static repeat_marker_t marker[MAX_REPEAT_NESTING]; static repeat_marker_t marker[MAX_REPEAT_NESTING];
static uint8_t index; static uint8_t index;
public: public:
static inline void reset() { index = 0; } static void reset() { index = 0; }
static inline bool is_active() { static bool is_active() {
LOOP_L_N(i, index) if (marker[i].counter) return true; LOOP_L_N(i, index) if (marker[i].counter) return true;
return false; return false;
} }

54
Marlin/src/feature/runout.h
View File

@ -83,30 +83,30 @@ class TFilamentMonitor : public FilamentMonitorBase {
static sensor_t sensor; static sensor_t sensor;
public: public:
static inline void setup() { static void setup() {
sensor.setup(); sensor.setup();
reset(); reset();
} }
static inline void reset() { static void reset() {
filament_ran_out = false; filament_ran_out = false;
response.reset(); response.reset();
} }
// Call this method when filament is present, // Call this method when filament is present,
// so the response can reset its counter. // so the response can reset its counter.
static inline void filament_present(const uint8_t extruder) { static void filament_present(const uint8_t extruder) {
response.filament_present(extruder); response.filament_present(extruder);
} }
#if HAS_FILAMENT_RUNOUT_DISTANCE #if HAS_FILAMENT_RUNOUT_DISTANCE
static inline float& runout_distance() { return response.runout_distance_mm; } static float& runout_distance() { return response.runout_distance_mm; }
static inline void set_runout_distance(const_float_t mm) { response.runout_distance_mm = mm; } static void set_runout_distance(const_float_t mm) { response.runout_distance_mm = mm; }
#endif #endif
// Handle a block completion. RunoutResponseDelayed uses this to // Handle a block completion. RunoutResponseDelayed uses this to
// add up the length of filament moved while the filament is out. // add up the length of filament moved while the filament is out.
static inline void block_completed(const block_t * const b) { static void block_completed(const block_t * const b) {
if (enabled) { if (enabled) {
response.block_completed(b); response.block_completed(b);
sensor.block_completed(b); sensor.block_completed(b);
@ -114,7 +114,7 @@ class TFilamentMonitor : public FilamentMonitorBase {
} }
// Give the response a chance to update its counter. // Give the response a chance to update its counter.
static inline void run() { static void run() {
if (enabled && !filament_ran_out && (printingIsActive() || did_pause_print)) { if (enabled && !filament_ran_out && (printingIsActive() || did_pause_print)) {
TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, cli()); // Prevent RunoutResponseDelayed::block_completed from accumulating here TERN_(HAS_FILAMENT_RUNOUT_DISTANCE, cli()); // Prevent RunoutResponseDelayed::block_completed from accumulating here
response.run(); response.run();
@ -168,12 +168,12 @@ class FilamentSensorBase {
* Called by FilamentSensorSwitch::run when filament is detected. * Called by FilamentSensorSwitch::run when filament is detected.
* Called by FilamentSensorEncoder::block_completed when motion is detected. * Called by FilamentSensorEncoder::block_completed when motion is detected.
*/ */
static inline void filament_present(const uint8_t extruder) { static void filament_present(const uint8_t extruder) {
runout.filament_present(extruder); // ...which calls response.filament_present(extruder) runout.filament_present(extruder); // ...which calls response.filament_present(extruder)
} }
public: public:
static inline void setup() { static void setup() {
#define _INIT_RUNOUT_PIN(P,S,U,D) do{ if (ENABLED(U)) SET_INPUT_PULLUP(P); else if (ENABLED(D)) SET_INPUT_PULLDOWN(P); else SET_INPUT(P); }while(0) #define _INIT_RUNOUT_PIN(P,S,U,D) do{ if (ENABLED(U)) SET_INPUT_PULLUP(P); else if (ENABLED(D)) SET_INPUT_PULLDOWN(P); else SET_INPUT(P); }while(0)
#define INIT_RUNOUT_PIN(N) _INIT_RUNOUT_PIN(FIL_RUNOUT##N##_PIN, FIL_RUNOUT##N##_STATE, FIL_RUNOUT##N##_PULLUP, FIL_RUNOUT##N##_PULLDOWN) #define INIT_RUNOUT_PIN(N) _INIT_RUNOUT_PIN(FIL_RUNOUT##N##_PIN, FIL_RUNOUT##N##_STATE, FIL_RUNOUT##N##_PULLUP, FIL_RUNOUT##N##_PULLDOWN)
#if NUM_RUNOUT_SENSORS >= 1 #if NUM_RUNOUT_SENSORS >= 1
@ -205,14 +205,14 @@ class FilamentSensorBase {
} }
// Return a bitmask of runout pin states // Return a bitmask of runout pin states
static inline uint8_t poll_runout_pins() { static uint8_t poll_runout_pins() {
#define _OR_RUNOUT(N) | (READ(FIL_RUNOUT##N##_PIN) ? _BV((N) - 1) : 0) #define _OR_RUNOUT(N) | (READ(FIL_RUNOUT##N##_PIN) ? _BV((N) - 1) : 0)
return (0 REPEAT_1(NUM_RUNOUT_SENSORS, _OR_RUNOUT)); return (0 REPEAT_1(NUM_RUNOUT_SENSORS, _OR_RUNOUT));
#undef _OR_RUNOUT #undef _OR_RUNOUT
} }
// Return a bitmask of runout flag states (1 bits always indicates runout) // Return a bitmask of runout flag states (1 bits always indicates runout)
static inline uint8_t poll_runout_states() { static uint8_t poll_runout_states() {
return poll_runout_pins() ^ uint8_t(0 return poll_runout_pins() ^ uint8_t(0
#if NUM_RUNOUT_SENSORS >= 1 #if NUM_RUNOUT_SENSORS >= 1
| (FIL_RUNOUT1_STATE ? 0 : _BV(1 - 1)) | (FIL_RUNOUT1_STATE ? 0 : _BV(1 - 1))
@ -254,7 +254,7 @@ class FilamentSensorBase {
private: private:
static uint8_t motion_detected; static uint8_t motion_detected;
static inline void poll_motion_sensor() { static void poll_motion_sensor() {
static uint8_t old_state; static uint8_t old_state;
const uint8_t new_state = poll_runout_pins(), const uint8_t new_state = poll_runout_pins(),
change = old_state ^ new_state; change = old_state ^ new_state;
@ -273,7 +273,7 @@ class FilamentSensorBase {
} }
public: public:
static inline void block_completed(const block_t * const b) { static void block_completed(const block_t * const b) {
// If the sensor wheel has moved since the last call to // If the sensor wheel has moved since the last call to
// this method reset the runout counter for the extruder. // this method reset the runout counter for the extruder.
if (TEST(motion_detected, b->extruder)) if (TEST(motion_detected, b->extruder))
@ -283,7 +283,7 @@ class FilamentSensorBase {
motion_detected = 0; motion_detected = 0;
} }
static inline void run() { poll_motion_sensor(); } static void run() { poll_motion_sensor(); }
}; };
#else #else
@ -294,7 +294,7 @@ class FilamentSensorBase {
*/ */
class FilamentSensorSwitch : public FilamentSensorBase { class FilamentSensorSwitch : public FilamentSensorBase {
private: private:
static inline bool poll_runout_state(const uint8_t extruder) { static bool poll_runout_state(const uint8_t extruder) {
const uint8_t runout_states = poll_runout_states(); const uint8_t runout_states = poll_runout_states();
#if MULTI_FILAMENT_SENSOR #if MULTI_FILAMENT_SENSOR
if ( !TERN0(DUAL_X_CARRIAGE, idex_is_duplicating()) if ( !TERN0(DUAL_X_CARRIAGE, idex_is_duplicating())
@ -307,9 +307,9 @@ class FilamentSensorBase {
} }
public: public:
static inline void block_completed(const block_t * const) {} static void block_completed(const block_t * const) {}
static inline void run() { static void run() {
LOOP_L_N(s, NUM_RUNOUT_SENSORS) { LOOP_L_N(s, NUM_RUNOUT_SENSORS) {
const bool out = poll_runout_state(s); const bool out = poll_runout_state(s);
if (!out) filament_present(s); if (!out) filament_present(s);
@ -341,11 +341,11 @@ class FilamentSensorBase {
public: public:
static float runout_distance_mm; static float runout_distance_mm;
static inline void reset() { static void reset() {
LOOP_L_N(i, NUM_RUNOUT_SENSORS) filament_present(i); LOOP_L_N(i, NUM_RUNOUT_SENSORS) filament_present(i);
} }
static inline void run() { static void run() {
#if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG) #if ENABLED(FILAMENT_RUNOUT_SENSOR_DEBUG)
static millis_t t = 0; static millis_t t = 0;
const millis_t ms = millis(); const millis_t ms = millis();
@ -358,17 +358,17 @@ class FilamentSensorBase {
#endif #endif
} }
static inline uint8_t has_run_out() { static uint8_t has_run_out() {
uint8_t runout_flags = 0; uint8_t runout_flags = 0;
LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_mm_countdown[i] < 0) SBI(runout_flags, i); LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_mm_countdown[i] < 0) SBI(runout_flags, i);
return runout_flags; return runout_flags;
} }
static inline void filament_present(const uint8_t extruder) { static void filament_present(const uint8_t extruder) {
runout_mm_countdown[extruder] = runout_distance_mm; runout_mm_countdown[extruder] = runout_distance_mm;
} }
static inline void block_completed(const block_t * const b) { static void block_completed(const block_t * const b) {
if (b->steps.x || b->steps.y || b->steps.z || did_pause_print) { // Allow pause purge move to re-trigger runout state if (b->steps.x || b->steps.y || b->steps.z || did_pause_print) { // Allow pause purge move to re-trigger runout state
// Only trigger on extrusion with XYZ movement to allow filament change and retract/recover. // Only trigger on extrusion with XYZ movement to allow filament change and retract/recover.
const uint8_t e = b->extruder; const uint8_t e = b->extruder;
@ -389,23 +389,23 @@ class FilamentSensorBase {
static int8_t runout_count[NUM_RUNOUT_SENSORS]; static int8_t runout_count[NUM_RUNOUT_SENSORS];
public: public:
static inline void reset() { static void reset() {
LOOP_L_N(i, NUM_RUNOUT_SENSORS) filament_present(i); LOOP_L_N(i, NUM_RUNOUT_SENSORS) filament_present(i);
} }
static inline void run() { static void run() {
LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_count[i] >= 0) runout_count[i]--; LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_count[i] >= 0) runout_count[i]--;
} }
static inline uint8_t has_run_out() { static uint8_t has_run_out() {
uint8_t runout_flags = 0; uint8_t runout_flags = 0;
LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_count[i] < 0) SBI(runout_flags, i); LOOP_L_N(i, NUM_RUNOUT_SENSORS) if (runout_count[i] < 0) SBI(runout_flags, i);
return runout_flags; return runout_flags;
} }
static inline void block_completed(const block_t * const) { } static void block_completed(const block_t * const) { }
static inline void filament_present(const uint8_t extruder) { static void filament_present(const uint8_t extruder) {
runout_count[extruder] = runout_threshold; runout_count[extruder] = runout_threshold;
} }
}; };

42
Marlin/src/feature/spindle_laser.h
View File

@ -103,12 +103,12 @@ public:
static void init(); static void init();
#if ENABLED(MARLIN_DEV_MODE) #if ENABLED(MARLIN_DEV_MODE)
static inline void refresh_frequency() { set_pwm_frequency(pin_t(SPINDLE_LASER_PWM_PIN), frequency); } static void refresh_frequency() { set_pwm_frequency(pin_t(SPINDLE_LASER_PWM_PIN), frequency); }
#endif #endif
// Modifying this function should update everywhere // Modifying this function should update everywhere
static inline bool enabled(const cutter_power_t opwr) { return opwr > 0; } static bool enabled(const cutter_power_t opwr) { return opwr > 0; }
static inline bool enabled() { return enabled(power); } static bool enabled() { return enabled(power); }
static void apply_power(const uint8_t inpow); static void apply_power(const uint8_t inpow);
@ -124,13 +124,13 @@ public:
public: public:
static void set_ocr(const uint8_t ocr); static void set_ocr(const uint8_t ocr);
static inline void ocr_set_power(const uint8_t ocr) { power = ocr; set_ocr(ocr); } static void ocr_set_power(const uint8_t ocr) { power = ocr; set_ocr(ocr); }
static void ocr_off(); static void ocr_off();
/** /**
* Update output for power->OCR translation * Update output for power->OCR translation
*/ */
static inline uint8_t upower_to_ocr(const cutter_power_t upwr) { static uint8_t upower_to_ocr(const cutter_power_t upwr) {
return uint8_t( return uint8_t(
#if CUTTER_UNIT_IS(PWM255) #if CUTTER_UNIT_IS(PWM255)
upwr upwr
@ -145,11 +145,11 @@ public:
/** /**
* Correct power to configured range * Correct power to configured range
*/ */
static inline cutter_power_t power_to_range(const cutter_power_t pwr) { static cutter_power_t power_to_range(const cutter_power_t pwr) {
return power_to_range(pwr, _CUTTER_POWER(CUTTER_POWER_UNIT)); return power_to_range(pwr, _CUTTER_POWER(CUTTER_POWER_UNIT));
} }
static inline cutter_power_t power_to_range(const cutter_power_t pwr, const uint8_t pwrUnit) { static cutter_power_t power_to_range(const cutter_power_t pwr, const uint8_t pwrUnit) {
static constexpr float static constexpr float
min_pct = TERN(CUTTER_POWER_RELATIVE, 0, TERN(SPINDLE_FEATURE, round(100.0f * (SPEED_POWER_MIN) / (SPEED_POWER_MAX)), SPEED_POWER_MIN)), min_pct = TERN(CUTTER_POWER_RELATIVE, 0, TERN(SPINDLE_FEATURE, round(100.0f * (SPEED_POWER_MIN) / (SPEED_POWER_MAX)), SPEED_POWER_MIN)),
max_pct = TERN(SPINDLE_FEATURE, 100, SPEED_POWER_MAX); max_pct = TERN(SPINDLE_FEATURE, 100, SPEED_POWER_MAX);
@ -188,7 +188,7 @@ public:
* Enable/Disable spindle/laser * Enable/Disable spindle/laser
* @param enable true = enable; false = disable * @param enable true = enable; false = disable
*/ */
static inline void set_enabled(const bool enable) { static void set_enabled(const bool enable) {
uint8_t value = 0; uint8_t value = 0;
if (enable) { if (enable) {
#if ENABLED(SPINDLE_LASER_USE_PWM) #if ENABLED(SPINDLE_LASER_USE_PWM)
@ -203,14 +203,14 @@ public:
set_power(value); set_power(value);
} }
static inline void disable() { isReady = false; set_enabled(false); } static void disable() { isReady = false; set_enabled(false); }
/** /**
* Wait for spindle to spin up or spin down * Wait for spindle to spin up or spin down
* *
* @param on true = state to on; false = state to off. * @param on true = state to on; false = state to off.
*/ */
static inline void power_delay(const bool on) { static void power_delay(const bool on) {
#if DISABLED(LASER_POWER_INLINE) #if DISABLED(LASER_POWER_INLINE)
safe_delay(on ? SPINDLE_LASER_POWERUP_DELAY : SPINDLE_LASER_POWERDOWN_DELAY); safe_delay(on ? SPINDLE_LASER_POWERUP_DELAY : SPINDLE_LASER_POWERDOWN_DELAY);
#endif #endif
@ -220,7 +220,7 @@ public:
static void set_reverse(const bool reverse); static void set_reverse(const bool reverse);
static bool is_reverse() { return READ(SPINDLE_DIR_PIN) == SPINDLE_INVERT_DIR; } static bool is_reverse() { return READ(SPINDLE_DIR_PIN) == SPINDLE_INVERT_DIR; }
#else #else
static inline void set_reverse(const bool) {} static void set_reverse(const bool) {}
static bool is_reverse() { return false; } static bool is_reverse() { return false; }
#endif #endif
@ -228,7 +228,7 @@ public:
static void air_evac_enable(); // Turn On Cutter Vacuum or Laser Blower motor static void air_evac_enable(); // Turn On Cutter Vacuum or Laser Blower motor
static void air_evac_disable(); // Turn Off Cutter Vacuum or Laser Blower motor static void air_evac_disable(); // Turn Off Cutter Vacuum or Laser Blower motor
static void air_evac_toggle(); // Toggle Cutter Vacuum or Laser Blower motor static void air_evac_toggle(); // Toggle Cutter Vacuum or Laser Blower motor
static inline bool air_evac_state() { // Get current state static bool air_evac_state() { // Get current state
return (READ(AIR_EVACUATION_PIN) == AIR_EVACUATION_ACTIVE); return (READ(AIR_EVACUATION_PIN) == AIR_EVACUATION_ACTIVE);
} }
#endif #endif
@ -237,13 +237,13 @@ public:
static void air_assist_enable(); // Turn on air assist static void air_assist_enable(); // Turn on air assist
static void air_assist_disable(); // Turn off air assist static void air_assist_disable(); // Turn off air assist
static void air_assist_toggle(); // Toggle air assist static void air_assist_toggle(); // Toggle air assist
static inline bool air_assist_state() { // Get current state static bool air_assist_state() { // Get current state
return (READ(AIR_ASSIST_PIN) == AIR_ASSIST_ACTIVE); return (READ(AIR_ASSIST_PIN) == AIR_ASSIST_ACTIVE);
} }
#endif #endif
#if HAS_LCD_MENU #if HAS_LCD_MENU
static inline void enable_with_dir(const bool reverse) { static void enable_with_dir(const bool reverse) {
isReady = true; isReady = true;
const uint8_t ocr = TERN(SPINDLE_LASER_USE_PWM, upower_to_ocr(menuPower), 255); const uint8_t ocr = TERN(SPINDLE_LASER_USE_PWM, upower_to_ocr(menuPower), 255);
if (menuPower) if (menuPower)
@ -259,7 +259,7 @@ public:
FORCE_INLINE static void enable_same_dir() { enable_with_dir(is_reverse()); } FORCE_INLINE static void enable_same_dir() { enable_with_dir(is_reverse()); }
#if ENABLED(SPINDLE_LASER_USE_PWM) #if ENABLED(SPINDLE_LASER_USE_PWM)
static inline void update_from_mpower() { static void update_from_mpower() {
if (isReady) power = upower_to_ocr(menuPower); if (isReady) power = upower_to_ocr(menuPower);
unitPower = menuPower; unitPower = menuPower;
} }
@ -271,7 +271,7 @@ public:
* Also fires with any PWM power that was previous set * Also fires with any PWM power that was previous set
* If not set defaults to 80% power * If not set defaults to 80% power
*/ */
static inline void test_fire_pulse() { static void test_fire_pulse() {
TERN_(USE_BEEPER, buzzer.tone(30, 3000)); TERN_(USE_BEEPER, buzzer.tone(30, 3000));
enable_forward(); // Turn Laser on (Spindle speak but same funct) enable_forward(); // Turn Laser on (Spindle speak but same funct)
delay(testPulse); // Delay for time set by user in pulse ms menu screen. delay(testPulse); // Delay for time set by user in pulse ms menu screen.
@ -288,7 +288,7 @@ public:
*/ */
// Force disengage planner power control // Force disengage planner power control
static inline void inline_disable() { static void inline_disable() {
isReady = false; isReady = false;
unitPower = 0; unitPower = 0;
planner.laser_inline.status.isPlanned = false; planner.laser_inline.status.isPlanned = false;
@ -297,7 +297,7 @@ public:
} }
// Inline modes of all other functions; all enable planner inline power control // Inline modes of all other functions; all enable planner inline power control
static inline void set_inline_enabled(const bool enable) { static void set_inline_enabled(const bool enable) {
if (enable) if (enable)
inline_power(255); inline_power(255);
else { else {
@ -326,10 +326,10 @@ public:
#endif #endif
} }
static inline void inline_direction(const bool) { /* never */ } static void inline_direction(const bool) { /* never */ }
#if ENABLED(SPINDLE_LASER_USE_PWM) #if ENABLED(SPINDLE_LASER_USE_PWM)
static inline void inline_ocr_power(const uint8_t ocrpwr) { static void inline_ocr_power(const uint8_t ocrpwr) {
isReady = ocrpwr > 0; isReady = ocrpwr > 0;
planner.laser_inline.status.isEnabled = ocrpwr > 0; planner.laser_inline.status.isEnabled = ocrpwr > 0;
planner.laser_inline.power = ocrpwr; planner.laser_inline.power = ocrpwr;
@ -337,7 +337,7 @@ public:
#endif #endif
#endif // LASER_POWER_INLINE #endif // LASER_POWER_INLINE
static inline void kill() { static void kill() {
TERN_(LASER_POWER_INLINE, inline_disable()); TERN_(LASER_POWER_INLINE, inline_disable());
disable(); disable();
} }

8
Marlin/src/feature/twibus.h
View File

@ -244,11 +244,11 @@ class TWIBus {
static void debug(FSTR_P const func, char c); static void debug(FSTR_P const func, char c);
static void debug(FSTR_P const func, char adr[]); static void debug(FSTR_P const func, char adr[]);
#else #else
static inline void debug(FSTR_P const, uint32_t) {} static void debug(FSTR_P const, uint32_t) {}
static inline void debug(FSTR_P const, char) {} static void debug(FSTR_P const, char) {}
static inline void debug(FSTR_P const, char[]) {} static void debug(FSTR_P const, char[]) {}
#endif #endif
static inline void debug(FSTR_P const func, uint8_t v) { debug(func, (uint32_t)v); } static void debug(FSTR_P const func, uint8_t v) { debug(func, (uint32_t)v); }
}; };
extern TWIBus i2c; extern TWIBus i2c;

18
Marlin/src/gcode/gcode.h
View File

@ -349,7 +349,7 @@ public:
static axis_bits_t axis_relative; static axis_bits_t axis_relative;
static inline bool axis_is_relative(const AxisEnum a) { static bool axis_is_relative(const AxisEnum a) {
#if HAS_EXTRUDERS #if HAS_EXTRUDERS
if (a == E_AXIS) { if (a == E_AXIS) {
if (TEST(axis_relative, E_MODE_REL)) return true; if (TEST(axis_relative, E_MODE_REL)) return true;
@ -358,7 +358,7 @@ public:
#endif #endif
return TEST(axis_relative, a); return TEST(axis_relative, a);
} }
static inline void set_relative_mode(const bool rel) { static void set_relative_mode(const bool rel) {
axis_relative = rel ? (0 LOGICAL_AXIS_GANG( axis_relative = rel ? (0 LOGICAL_AXIS_GANG(
| _BV(REL_E), | _BV(REL_E),
| _BV(REL_X), | _BV(REL_Y), | _BV(REL_Z), | _BV(REL_X), | _BV(REL_Y), | _BV(REL_Z),
@ -366,11 +366,11 @@ public:
)) : 0; )) : 0;
} }
#if HAS_EXTRUDERS #if HAS_EXTRUDERS
static inline void set_e_relative() { static void set_e_relative() {
CBI(axis_relative, E_MODE_ABS); CBI(axis_relative, E_MODE_ABS);
SBI(axis_relative, E_MODE_REL); SBI(axis_relative, E_MODE_REL);
} }
static inline void set_e_absolute() { static void set_e_absolute() {
CBI(axis_relative, E_MODE_REL); CBI(axis_relative, E_MODE_REL);
SBI(axis_relative, E_MODE_ABS); SBI(axis_relative, E_MODE_ABS);
} }
@ -403,7 +403,7 @@ public:
static void report_echo_start(const bool forReplay); static void report_echo_start(const bool forReplay);
static void report_heading(const bool forReplay, FSTR_P const fstr, const bool eol=true); static void report_heading(const bool forReplay, FSTR_P const fstr, const bool eol=true);
static inline void report_heading_etc(const bool forReplay, FSTR_P const fstr, const bool eol=true) { static void report_heading_etc(const bool forReplay, FSTR_P const fstr, const bool eol=true) {
report_heading(forReplay, fstr, eol); report_heading(forReplay, fstr, eol);
report_echo_start(forReplay); report_echo_start(forReplay);
} }
@ -420,20 +420,20 @@ public:
static void process_subcommands_now(FSTR_P fgcode); static void process_subcommands_now(FSTR_P fgcode);
static void process_subcommands_now(char * gcode); static void process_subcommands_now(char * gcode);
static inline void home_all_axes(const bool keep_leveling=false) { static void home_all_axes(const bool keep_leveling=false) {
process_subcommands_now(keep_leveling ? FPSTR(G28_STR) : TERN(CAN_SET_LEVELING_AFTER_G28, F("G28L0"), FPSTR(G28_STR))); process_subcommands_now(keep_leveling ? FPSTR(G28_STR) : TERN(CAN_SET_LEVELING_AFTER_G28, F("G28L0"), FPSTR(G28_STR)));
} }
#if EITHER(HAS_AUTO_REPORTING, HOST_KEEPALIVE_FEATURE) #if EITHER(HAS_AUTO_REPORTING, HOST_KEEPALIVE_FEATURE)
static bool autoreport_paused; static bool autoreport_paused;
static inline bool set_autoreport_paused(const bool p) { static bool set_autoreport_paused(const bool p) {
const bool was = autoreport_paused; const bool was = autoreport_paused;
autoreport_paused = p; autoreport_paused = p;
return was; return was;
} }
#else #else
static constexpr bool autoreport_paused = false; static constexpr bool autoreport_paused = false;
static inline bool set_autoreport_paused(const bool) { return false; } static bool set_autoreport_paused(const bool) { return false; }
#endif #endif
#if ENABLED(HOST_KEEPALIVE_FEATURE) #if ENABLED(HOST_KEEPALIVE_FEATURE)
@ -453,7 +453,7 @@ public:
static uint8_t host_keepalive_interval; static uint8_t host_keepalive_interval;
static void host_keepalive(); static void host_keepalive();
static inline bool host_keepalive_is_paused() { return busy_state >= PAUSED_FOR_USER; } static bool host_keepalive_is_paused() { return busy_state >= PAUSED_FOR_USER; }
#define KEEPALIVE_STATE(N) REMEMBER(_KA_, gcode.busy_state, gcode.N) #define KEEPALIVE_STATE(N) REMEMBER(_KA_, gcode.busy_state, gcode.N)
#else #else

118
Marlin/src/gcode/parser.h
View File

@ -126,7 +126,7 @@ public:
} }
// Set the flag and pointer for a parameter // Set the flag and pointer for a parameter
static inline void set(const char c, char * const ptr) { static void set(const char c, char * const ptr) {
const uint8_t ind = LETTER_BIT(c); const uint8_t ind = LETTER_BIT(c);
if (ind >= COUNT(param)) return; // Only A-Z if (ind >= COUNT(param)) return; // Only A-Z
SBI32(codebits, ind); // parameter exists SBI32(codebits, ind); // parameter exists
@ -142,7 +142,7 @@ public:
// Code seen bit was set. If not found, value_ptr is unchanged. // Code seen bit was set. If not found, value_ptr is unchanged.
// This allows "if (seen('A')||seen('B'))" to use the last-found value. // This allows "if (seen('A')||seen('B'))" to use the last-found value.
static inline bool seen(const char c) { static bool seen(const char c) {
const uint8_t ind = LETTER_BIT(c); const uint8_t ind = LETTER_BIT(c);
if (ind >= COUNT(param)) return false; // Only A-Z if (ind >= COUNT(param)) return false; // Only A-Z
const bool b = TEST32(codebits, ind); const bool b = TEST32(codebits, ind);
@ -183,7 +183,7 @@ public:
} }
#endif #endif
static inline bool seen_any() { return !!codebits; } static bool seen_any() { return !!codebits; }
FORCE_INLINE static bool seen_test(const char c) { return TEST32(codebits, LETTER_BIT(c)); } FORCE_INLINE static bool seen_test(const char c) { return TEST32(codebits, LETTER_BIT(c)); }
@ -204,19 +204,19 @@ public:
// Code is found in the string. If not found, value_ptr is unchanged. // Code is found in the string. If not found, value_ptr is unchanged.
// This allows "if (seen('A')||seen('B'))" to use the last-found value. // This allows "if (seen('A')||seen('B'))" to use the last-found value.
static inline bool seen(const char c) { static bool seen(const char c) {
char *p = strgchr(command_args, c); char *p = strgchr(command_args, c);
const bool b = !!p; const bool b = !!p;
if (b) value_ptr = valid_number(&p[1]) ? &p[1] : nullptr; if (b) value_ptr = valid_number(&p[1]) ? &p[1] : nullptr;
return b; return b;
} }
static inline bool seen_any() { return *command_args == '\0'; } static bool seen_any() { return *command_args == '\0'; }
FORCE_INLINE static bool seen_test(const char c) { return (bool)strgchr(command_args, c); } FORCE_INLINE static bool seen_test(const char c) { return (bool)strgchr(command_args, c); }
// At least one of a list of code letters was seen // At least one of a list of code letters was seen
static inline bool seen(const char * const str) { static bool seen(const char * const str) {
for (uint8_t i = 0; const char c = str[i]; i++) for (uint8_t i = 0; const char c = str[i]; i++)
if (seen_test(c)) return true; if (seen_test(c)) return true;
return false; return false;
@ -225,7 +225,7 @@ public:
#endif // !FASTER_GCODE_PARSER #endif // !FASTER_GCODE_PARSER
// Seen any axis parameter // Seen any axis parameter
static inline bool seen_axis() { return seen(LOGICAL_AXES_STRING); } static bool seen_axis() { return seen(LOGICAL_AXES_STRING); }
#if ENABLED(GCODE_QUOTED_STRINGS) #if ENABLED(GCODE_QUOTED_STRINGS)
static char* unescape_string(char* &src); static char* unescape_string(char* &src);
@ -243,19 +243,19 @@ public:
#endif #endif
// Test whether the parsed command matches the input // Test whether the parsed command matches the input
static inline bool is_command(const char ltr, const uint16_t num) { return command_letter == ltr && codenum == num; } static bool is_command(const char ltr, const uint16_t num) { return command_letter == ltr && codenum == num; }
// The code value pointer was set // The code value pointer was set
FORCE_INLINE static bool has_value() { return !!value_ptr; } FORCE_INLINE static bool has_value() { return !!value_ptr; }
// Seen a parameter with a value // Seen a parameter with a value
static inline bool seenval(const char c) { return seen(c) && has_value(); } static bool seenval(const char c) { return seen(c) && has_value(); }
// The value as a string // The value as a string
static inline char* value_string() { return value_ptr; } static char* value_string() { return value_ptr; }
// Float removes 'E' to prevent scientific notation interpretation // Float removes 'E' to prevent scientific notation interpretation
static inline float value_float() { static float value_float() {
if (value_ptr) { if (value_ptr) {
char *e = value_ptr; char *e = value_ptr;
for (;;) { for (;;) {
@ -275,31 +275,31 @@ public:
} }
// Code value as a long or ulong // Code value as a long or ulong
static inline int32_t value_long() { return value_ptr ? strtol(value_ptr, nullptr, 10) : 0L; } static int32_t value_long() { return value_ptr ? strtol(value_ptr, nullptr, 10) : 0L; }
static inline uint32_t value_ulong() { return value_ptr ? strtoul(value_ptr, nullptr, 10) : 0UL; } static uint32_t value_ulong() { return value_ptr ? strtoul(value_ptr, nullptr, 10) : 0UL; }
// Code value for use as time // Code value for use as time
static inline millis_t value_millis() { return value_ulong(); } static millis_t value_millis() { return value_ulong(); }
static inline millis_t value_millis_from_seconds() { return (millis_t)SEC_TO_MS(value_float()); } static millis_t value_millis_from_seconds() { return (millis_t)SEC_TO_MS(value_float()); }
// Reduce to fewer bits // Reduce to fewer bits
static inline int16_t value_int() { return (int16_t)value_long(); } static int16_t value_int() { return (int16_t)value_long(); }
static inline uint16_t value_ushort() { return (uint16_t)value_long(); } static uint16_t value_ushort() { return (uint16_t)value_long(); }
static inline uint8_t value_byte() { return (uint8_t)constrain(value_long(), 0, 255); } static uint8_t value_byte() { return (uint8_t)constrain(value_long(), 0, 255); }
// Bool is true with no value or non-zero // Bool is true with no value or non-zero
static inline bool value_bool() { return !has_value() || !!value_byte(); } static bool value_bool() { return !has_value() || !!value_byte(); }
// Units modes: Inches, Fahrenheit, Kelvin // Units modes: Inches, Fahrenheit, Kelvin
#if ENABLED(INCH_MODE_SUPPORT) #if ENABLED(INCH_MODE_SUPPORT)
static inline float mm_to_linear_unit(const_float_t mm) { return mm / linear_unit_factor; } static float mm_to_linear_unit(const_float_t mm) { return mm / linear_unit_factor; }
static inline float mm_to_volumetric_unit(const_float_t mm) { return mm / (volumetric_enabled ? volumetric_unit_factor : linear_unit_factor); } static float mm_to_volumetric_unit(const_float_t mm) { return mm / (volumetric_enabled ? volumetric_unit_factor : linear_unit_factor); }
// Init linear units by constructor // Init linear units by constructor
GCodeParser() { set_input_linear_units(LINEARUNIT_MM); } GCodeParser() { set_input_linear_units(LINEARUNIT_MM); }
static inline void set_input_linear_units(const LinearUnit units) { static void set_input_linear_units(const LinearUnit units) {
switch (units) { switch (units) {
default: default:
case LINEARUNIT_MM: linear_unit_factor = 1.0f; break; case LINEARUNIT_MM: linear_unit_factor = 1.0f; break;
@ -308,7 +308,7 @@ public:
volumetric_unit_factor = POW(linear_unit_factor, 3); volumetric_unit_factor = POW(linear_unit_factor, 3);
} }
static inline float axis_unit_factor(const AxisEnum axis) { static float axis_unit_factor(const AxisEnum axis) {
return ( return (
#if HAS_EXTRUDERS #if HAS_EXTRUDERS
axis >= E_AXIS && volumetric_enabled ? volumetric_unit_factor : linear_unit_factor axis >= E_AXIS && volumetric_enabled ? volumetric_unit_factor : linear_unit_factor
@ -318,46 +318,46 @@ public:
); );
} }
static inline float linear_value_to_mm(const_float_t v) { return v * linear_unit_factor; } static float linear_value_to_mm(const_float_t v) { return v * linear_unit_factor; }
static inline float axis_value_to_mm(const AxisEnum axis, const float v) { return v * axis_unit_factor(axis); } static float axis_value_to_mm(const AxisEnum axis, const float v) { return v * axis_unit_factor(axis); }
static inline float per_axis_value(const AxisEnum axis, const float v) { return v / axis_unit_factor(axis); } static float per_axis_value(const AxisEnum axis, const float v) { return v / axis_unit_factor(axis); }
#else #else
static inline float mm_to_linear_unit(const_float_t mm) { return mm; } static float mm_to_linear_unit(const_float_t mm) { return mm; }
static inline float mm_to_volumetric_unit(const_float_t mm) { return mm; } static float mm_to_volumetric_unit(const_float_t mm) { return mm; }
static inline float linear_value_to_mm(const_float_t v) { return v; } static float linear_value_to_mm(const_float_t v) { return v; }
static inline float axis_value_to_mm(const AxisEnum, const float v) { return v; } static float axis_value_to_mm(const AxisEnum, const float v) { return v; }
static inline float per_axis_value(const AxisEnum, const float v) { return v; } static float per_axis_value(const AxisEnum, const float v) { return v; }
#endif #endif
static inline bool using_inch_units() { return mm_to_linear_unit(1.0f) != 1.0f; } static bool using_inch_units() { return mm_to_linear_unit(1.0f) != 1.0f; }
#define IN_TO_MM(I) ((I) * 25.4f) #define IN_TO_MM(I) ((I) * 25.4f)
#define MM_TO_IN(M) ((M) / 25.4f) #define MM_TO_IN(M) ((M) / 25.4f)
#define LINEAR_UNIT(V) parser.mm_to_linear_unit(V) #define LINEAR_UNIT(V) parser.mm_to_linear_unit(V)
#define VOLUMETRIC_UNIT(V) parser.mm_to_volumetric_unit(V) #define VOLUMETRIC_UNIT(V) parser.mm_to_volumetric_unit(V)
static inline float value_linear_units() { return linear_value_to_mm(value_float()); } static float value_linear_units() { return linear_value_to_mm(value_float()); }
static inline float value_axis_units(const AxisEnum axis) { return axis_value_to_mm(axis, value_float()); } static float value_axis_units(const AxisEnum axis) { return axis_value_to_mm(axis, value_float()); }
static inline float value_per_axis_units(const AxisEnum axis) { return per_axis_value(axis, value_float()); } static float value_per_axis_units(const AxisEnum axis) { return per_axis_value(axis, value_float()); }
#if ENABLED(TEMPERATURE_UNITS_SUPPORT) #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
static inline void set_input_temp_units(const TempUnit units) { input_temp_units = units; } static void set_input_temp_units(const TempUnit units) { input_temp_units = units; }
static inline char temp_units_code() { static char temp_units_code() {
return input_temp_units == TEMPUNIT_K ? 'K' : input_temp_units == TEMPUNIT_F ? 'F' : 'C'; return input_temp_units == TEMPUNIT_K ? 'K' : input_temp_units == TEMPUNIT_F ? 'F' : 'C';
} }
static inline FSTR_P temp_units_name() { static FSTR_P temp_units_name() {
return input_temp_units == TEMPUNIT_K ? F("Kelvin") : input_temp_units == TEMPUNIT_F ? F("Fahrenheit") : F("Celsius"); return input_temp_units == TEMPUNIT_K ? F("Kelvin") : input_temp_units == TEMPUNIT_F ? F("Fahrenheit") : F("Celsius");
} }
#if HAS_LCD_MENU && DISABLED(DISABLE_M503) #if HAS_LCD_MENU && DISABLED(DISABLE_M503)
static inline float to_temp_units(celsius_t c) { static float to_temp_units(celsius_t c) {
switch (input_temp_units) { switch (input_temp_units) {
default: default:
case TEMPUNIT_C: return c; case TEMPUNIT_C: return c;
@ -368,7 +368,7 @@ public:
#endif // HAS_LCD_MENU && !DISABLE_M503 #endif // HAS_LCD_MENU && !DISABLE_M503
static inline celsius_t value_celsius() { static celsius_t value_celsius() {
float f = value_float(); float f = value_float();
switch (input_temp_units) { switch (input_temp_units) {
default: default:
@ -379,7 +379,7 @@ public:
return LROUND(f); return LROUND(f);
} }
static inline celsius_t value_celsius_diff() { static celsius_t value_celsius_diff() {
float f = value_float(); float f = value_float();
switch (input_temp_units) { switch (input_temp_units) {
default: default:
@ -392,35 +392,35 @@ public:
#else // !TEMPERATURE_UNITS_SUPPORT #else // !TEMPERATURE_UNITS_SUPPORT
static inline float to_temp_units(int16_t c) { return (float)c; } static float to_temp_units(int16_t c) { return (float)c; }
static inline celsius_t value_celsius() { return value_int(); } static celsius_t value_celsius() { return value_int(); }
static inline celsius_t value_celsius_diff() { return value_int(); } static celsius_t value_celsius_diff() { return value_int(); }
#endif // !TEMPERATURE_UNITS_SUPPORT #endif // !TEMPERATURE_UNITS_SUPPORT
static inline feedRate_t value_feedrate() { return MMM_TO_MMS(value_linear_units()); } static feedRate_t value_feedrate() { return MMM_TO_MMS(value_linear_units()); }
void unknown_command_warning(); void unknown_command_warning();
// Provide simple value accessors with default option // Provide simple value accessors with default option
static inline char* stringval(const char c, char * const dval=nullptr) { return seenval(c) ? value_string() : dval; } static char* stringval(const char c, char * const dval=nullptr) { return seenval(c) ? value_string() : dval; }
static inline float floatval(const char c, const float dval=0.0) { return seenval(c) ? value_float() : dval; } static float floatval(const char c, const float dval=0.0) { return seenval(c) ? value_float() : dval; }
static inline bool boolval(const char c, const bool dval=false) { return seenval(c) ? value_bool() : (seen(c) ? true : dval); } static bool boolval(const char c, const bool dval=false) { return seenval(c) ? value_bool() : (seen(c) ? true : dval); }
static inline uint8_t byteval(const char c, const uint8_t dval=0) { return seenval(c) ? value_byte() : dval; } static uint8_t byteval(const char c, const uint8_t dval=0) { return seenval(c) ? value_byte() : dval; }
static inline int16_t intval(const char c, const int16_t dval=0) { return seenval(c) ? value_int() : dval; } static int16_t intval(const char c, const int16_t dval=0) { return seenval(c) ? value_int() : dval; }
static inline uint16_t ushortval(const char c, const uint16_t dval=0) { return seenval(c) ? value_ushort() : dval; } static uint16_t ushortval(const char c, const uint16_t dval=0) { return seenval(c) ? value_ushort() : dval; }
static inline int32_t longval(const char c, const int32_t dval=0) { return seenval(c) ? value_long() : dval; } static int32_t longval(const char c, const int32_t dval=0) { return seenval(c) ? value_long() : dval; }
static inline uint32_t ulongval(const char c, const uint32_t dval=0) { return seenval(c) ? value_ulong() : dval; } static uint32_t ulongval(const char c, const uint32_t dval=0) { return seenval(c) ? value_ulong() : dval; }
static inline float linearval(const char c, const float dval=0) { return seenval(c) ? value_linear_units() : dval; } static float linearval(const char c, const float dval=0) { return seenval(c) ? value_linear_units() : dval; }
static inline float axisunitsval(const char c, const AxisEnum a, const float dval=0) static float axisunitsval(const char c, const AxisEnum a, const float dval=0)
{ return seenval(c) ? value_axis_units(a) : dval; } { return seenval(c) ? value_axis_units(a) : dval; }
static inline celsius_t celsiusval(const char c, const celsius_t dval=0) { return seenval(c) ? value_celsius() : dval; } static celsius_t celsiusval(const char c, const celsius_t dval=0) { return seenval(c) ? value_celsius() : dval; }
static inline feedRate_t feedrateval(const char c, const feedRate_t dval=0) { return seenval(c) ? value_feedrate() : dval; } static feedRate_t feedrateval(const char c, const feedRate_t dval=0) { return seenval(c) ? value_feedrate() : dval; }
#if ENABLED(MARLIN_DEV_MODE) #if ENABLED(MARLIN_DEV_MODE)
static inline uint8_t* hex_adr_val(const char c, uint8_t * const dval=nullptr) { static uint8_t* hex_adr_val(const char c, uint8_t * const dval=nullptr) {
if (!seen(c) || *value_ptr != 'x') return dval; if (!seen(c) || *value_ptr != 'x') return dval;
uint8_t *out = nullptr; uint8_t *out = nullptr;
for (char *vp = value_ptr + 1; HEXCHR(*vp) >= 0; vp++) for (char *vp = value_ptr + 1; HEXCHR(*vp) >= 0; vp++)
@ -428,7 +428,7 @@ public:
return out; return out;
} }
static inline uint16_t hex_val(const char c, uint16_t const dval=0) { static uint16_t hex_val(const char c, uint16_t const dval=0) {
if (!seen(c) || *value_ptr != 'x') return dval; if (!seen(c) || *value_ptr != 'x') return dval;
uint16_t out = 0; uint16_t out = 0;
for (char *vp = value_ptr + 1; HEXCHR(*vp) >= 0; vp++) for (char *vp = value_ptr + 1; HEXCHR(*vp) >= 0; vp++)

14
Marlin/src/gcode/queue.h
View File

@ -126,14 +126,14 @@ public:
* Don't inject comments or use leading spaces! * Don't inject comments or use leading spaces!
* Aborts the current PROGMEM queue so only use for one or two commands. * Aborts the current PROGMEM queue so only use for one or two commands.
*/ */
static inline void inject_P(PGM_P const pgcode) { injected_commands_P = pgcode; } static void inject_P(PGM_P const pgcode) { injected_commands_P = pgcode; }
static inline void inject(FSTR_P const fgcode) { inject_P(FTOP(fgcode)); } static void inject(FSTR_P const fgcode) { inject_P(FTOP(fgcode)); }
/** /**
* Enqueue command(s) to run from SRAM. Drained by process_injected_command(). * Enqueue command(s) to run from SRAM. Drained by process_injected_command().
* Aborts the current SRAM queue so only use for one or two commands. * Aborts the current SRAM queue so only use for one or two commands.
*/ */
static inline void inject(const char * const gcode) { static void inject(const char * const gcode) {
strncpy(injected_commands, gcode, sizeof(injected_commands) - 1); strncpy(injected_commands, gcode, sizeof(injected_commands) - 1);
} }
@ -158,7 +158,7 @@ public:
* Enqueue from program memory and return only when commands are actually enqueued * Enqueue from program memory and return only when commands are actually enqueued
*/ */
static void enqueue_now_P(PGM_P const pcmd); static void enqueue_now_P(PGM_P const pcmd);
static inline void enqueue_now(FSTR_P const fcmd) { enqueue_now_P(FTOP(fcmd)); } static void enqueue_now(FSTR_P const fcmd) { enqueue_now_P(FTOP(fcmd)); }
/** /**
* Check whether there are any commands yet to be executed * Check whether there are any commands yet to be executed
@ -192,7 +192,7 @@ public:
* P<int> Planner space remaining * P<int> Planner space remaining
* B<int> Block queue space remaining * B<int> Block queue space remaining
*/ */
static inline void ok_to_send() { ring_buffer.ok_to_send(); } static void ok_to_send() { ring_buffer.ok_to_send(); }
/** /**
* Clear the serial line and request a resend of * Clear the serial line and request a resend of
@ -203,7 +203,7 @@ public:
/** /**
* (Re)Set the current line number for the last received command * (Re)Set the current line number for the last received command
*/ */
static inline void set_current_line_number(long n) { serial_state[ring_buffer.command_port().index].last_N = n; } static void set_current_line_number(long n) { serial_state[ring_buffer.command_port().index].last_N = n; }
#if ENABLED(BUFFER_MONITORING) #if ENABLED(BUFFER_MONITORING)
@ -237,7 +237,7 @@ public:
static void auto_report_buffer_statistics(); static void auto_report_buffer_statistics();
static inline void set_auto_report_interval(uint8_t v) { static void set_auto_report_interval(uint8_t v) {
NOMORE(v, 60); NOMORE(v, 60);
auto_buffer_report_interval = v; auto_buffer_report_interval = v;
next_buffer_report_ms = millis() + 1000UL * v; next_buffer_report_ms = millis() + 1000UL * v;

2
Marlin/src/lcd/e3v2/enhanced/lockscreen.h
View File

@ -39,7 +39,7 @@ public:
static void init(); static void init();
static void onEncoder(EncoderState encoder_diffState); static void onEncoder(EncoderState encoder_diffState);
static void draw(); static void draw();
static inline bool isUnlocked() { return unlocked; } static bool isUnlocked() { return unlocked; }
}; };
extern LockScreenClass lockScreen; extern LockScreenClass lockScreen;

16
Marlin/src/lcd/e3v2/marlinui/dwin_string.h
View File

@ -55,7 +55,7 @@ class DWIN_String {
//static font_t *font() { return font_header; }; //static font_t *font() { return font_header; };
//static uint16_t font_height() { return font_header->FontAscent - font_header->FontDescent; } //static uint16_t font_height() { return font_header->FontAscent - font_header->FontDescent; }
//static glyph_t *glyph(uint8_t character) { return glyphs[character] ?: glyphs[0x3F]; } /* Use '?' for unknown glyphs */ //static glyph_t *glyph(uint8_t character) { return glyphs[character] ?: glyphs[0x3F]; } /* Use '?' for unknown glyphs */
//static inline glyph_t *glyph(uint8_t *character) { return glyph(*character); } //static glyph_t *glyph(uint8_t *character) { return glyph(*character); }
static void set(); static void set();
//static void add(uint8_t character) { add_character(character); eol(); } //static void add(uint8_t character) { add_character(character); eol(); }
@ -65,10 +65,10 @@ class DWIN_String {
static void set(uint8_t *string) { set(); add(string); } static void set(uint8_t *string) { set(); add(string); }
static void set(wchar_t character) { set(); add(character); } static void set(wchar_t character) { set(); add(character); }
static void set(uint8_t *string, int8_t index, const char *itemString=nullptr) { set(); add(string, index, (uint8_t *)itemString); } static void set(uint8_t *string, int8_t index, const char *itemString=nullptr) { set(); add(string, index, (uint8_t *)itemString); }
static inline void set(FSTR_P fstring) { set((uint8_t *)fstring); } static void set(FSTR_P fstring) { set((uint8_t *)fstring); }
static inline void set(const char *string) { set((uint8_t *)string); } static void set(const char *string) { set((uint8_t *)string); }
static inline void set(const char *string, int8_t index, const char *itemString=nullptr) { set((uint8_t *)string, index, itemString); } static void set(const char *string, int8_t index, const char *itemString=nullptr) { set((uint8_t *)string, index, itemString); }
static inline void add(const char *string) { add((uint8_t *)string); } static void add(const char *string) { add((uint8_t *)string); }
static void trim(const uint8_t character=0x20); static void trim(const uint8_t character=0x20);
static void rtrim(const uint8_t character=0x20); static void rtrim(const uint8_t character=0x20);
@ -76,9 +76,9 @@ class DWIN_String {
static void truncate(uint8_t maxlen) { if (len > maxlen) { len = maxlen; eol(); } } static void truncate(uint8_t maxlen) { if (len > maxlen) { len = maxlen; eol(); } }
static inline uint8_t length() { return len; } static uint8_t length() { return len; }
static inline uint16_t width() { return span; } static uint16_t width() { return span; }
static inline uint8_t *string() { return data; } static uint8_t *string() { return data; }
static uint16_t center(uint16_t width) { return span > width ? 0 : (width - span) / 2; } static uint16_t center(uint16_t width) { return span > width ? 0 : (width - span) / 2; }
}; };

4
Marlin/src/lcd/extui/dgus/DGUSDisplay.h
View File

@ -95,14 +95,14 @@ public:
// Checks two things: Can we confirm the presence of the display and has we initialized it. // Checks two things: Can we confirm the presence of the display and has we initialized it.
// (both boils down that the display answered to our chatting) // (both boils down that the display answered to our chatting)
static inline bool isInitialized() { return Initialized; } static bool isInitialized() { return Initialized; }
private: private:
static void WriteHeader(uint16_t adr, uint8_t cmd, uint8_t payloadlen); static void WriteHeader(uint16_t adr, uint8_t cmd, uint8_t payloadlen);
static void WritePGM(const char str[], uint8_t len); static void WritePGM(const char str[], uint8_t len);
static void ProcessRx(); static void ProcessRx();
static inline uint16_t swap16(const uint16_t value) { return (value & 0xFFU) << 8U | (value >> 8U); } static uint16_t swap16(const uint16_t value) { return (value & 0xFFU) << 8U | (value >> 8U); }
static rx_datagram_state_t rx_datagram_state; static rx_datagram_state_t rx_datagram_state;
static uint8_t rx_datagram_len; static uint8_t rx_datagram_len;
static bool Initialized, no_reentrance; static bool Initialized, no_reentrance;

12
Marlin/src/lcd/extui/dgus/fysetc/DGUSScreenHandler.h
View File

@ -38,10 +38,10 @@ public:
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifying whether the strings are in RAM or FLASH. // The bools specifying whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) { static void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash); sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash);
} }
static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) { static void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash); sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash);
} }
@ -213,13 +213,13 @@ public:
} }
// Force an update of all VP on the current screen. // Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; } static void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
// Has all VPs sent to the screen // Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; } static bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; } static DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; } static void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private: private:
static DGUSLCD_Screens current_screen; //< currently on screen static DGUSLCD_Screens current_screen; //< currently on screen

12
Marlin/src/lcd/extui/dgus/hiprecy/DGUSScreenHandler.h
View File

@ -38,10 +38,10 @@ public:
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifying whether the strings are in RAM or FLASH. // The bools specifying whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) { static void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash); sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash);
} }
static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) { static void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash); sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash);
} }
@ -213,13 +213,13 @@ public:
} }
// Force an update of all VP on the current screen. // Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; } static void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
// Has all VPs sent to the screen // Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; } static bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; } static DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; } static void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private: private:
static DGUSLCD_Screens current_screen; //< currently on screen static DGUSLCD_Screens current_screen; //< currently on screen

12
Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.h
View File

@ -38,10 +38,10 @@ public:
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifying whether the strings are in RAM or FLASH. // The bools specifying whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) { static void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash); sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash);
} }
static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) { static void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash); sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash);
} }
@ -280,13 +280,13 @@ public:
} }
// Force an update of all VP on the current screen. // Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; } static void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
// Has all VPs sent to the screen // Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; } static bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; } static DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; } static void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private: private:
static DGUSLCD_Screens current_screen; //< currently on screen static DGUSLCD_Screens current_screen; //< currently on screen

12
Marlin/src/lcd/extui/dgus/origin/DGUSScreenHandler.h
View File

@ -38,10 +38,10 @@ public:
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen // Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifying whether the strings are in RAM or FLASH. // The bools specifying whether the strings are in RAM or FLASH.
static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash); static void sendinfoscreen(const char *line1, const char *line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) { static void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, const char *line3, const char *line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash); sendinfoscreen(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash);
} }
static inline void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) { static void sendinfoscreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash); sendinfoscreen(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash);
} }
@ -213,13 +213,13 @@ public:
} }
// Force an update of all VP on the current screen. // Force an update of all VP on the current screen.
static inline void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; } static void ForceCompleteUpdate() { update_ptr = 0; ScreenComplete = false; }
// Has all VPs sent to the screen // Has all VPs sent to the screen
static inline bool IsScreenComplete() { return ScreenComplete; } static bool IsScreenComplete() { return ScreenComplete; }
static inline DGUSLCD_Screens getCurrentScreen() { return current_screen; } static DGUSLCD_Screens getCurrentScreen() { return current_screen; }
static inline void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; } static void SetupConfirmAction( void (*f)()) { confirm_action_cb = f; }
private: private:
static DGUSLCD_Screens current_screen; //< currently on screen static DGUSLCD_Screens current_screen; //< currently on screen

2
Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.h
View File

@ -98,7 +98,7 @@ public:
// Checks two things: Can we confirm the presence of the display and has we initialized it. // Checks two things: Can we confirm the presence of the display and has we initialized it.
// (both boils down that the display answered to our chatting) // (both boils down that the display answered to our chatting)
static inline bool IsInitialized() { static bool IsInitialized() {
return initialized; return initialized;
} }

4
Marlin/src/lcd/extui/ftdi_eve_touch_ui/compat.h
View File

@ -43,8 +43,8 @@
#define min(a,b) ((a)<(b)?(a):(b)) #define min(a,b) ((a)<(b)?(a):(b))
#else #else
namespace UI { namespace UI {
static inline uint32_t safe_millis() { return millis(); } static uint32_t safe_millis() { return millis(); }
static inline void yield() {} static void yield() {}
}; };
#endif #endif

28
Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/compat.h
View File

@ -40,13 +40,13 @@
template<typename port_t,uint8_t bits> template<typename port_t,uint8_t bits>
struct port_pin { struct port_pin {
typedef port_t port; typedef port_t port;
static inline void set_high() {port::port() = (port::port() | bits);} static void set_high() {port::port() = (port::port() | bits);}
static inline void set_low() {port::port() = (port::port() & (~bits));} static void set_low() {port::port() = (port::port() & (~bits));}
static inline void set_input() {port::ddr() = (port::ddr() & (~bits));} static void set_input() {port::ddr() = (port::ddr() & (~bits));}
static inline void set_input_pullup() {set_input(); set_high();} static void set_input_pullup() {set_input(); set_high();}
static inline void set_output() {port::ddr() = (port::ddr() | bits);} static void set_output() {port::ddr() = (port::ddr() | bits);}
static inline uint8_t read() {return port::pin() & bits;} static uint8_t read() {return port::pin() & bits;}
static inline void write(bool v) {if (v) set_high(); else set_low();} static void write(bool v) {if (v) set_high(); else set_low();}
}; };
#define MAKE_AVR_PORT_PINS(ID) \ #define MAKE_AVR_PORT_PINS(ID) \
@ -109,13 +109,13 @@
template<uint8_t p> template<uint8_t p>
struct arduino_digital_pin { struct arduino_digital_pin {
static constexpr uint8_t pin = p; static constexpr uint8_t pin = p;
static inline void set_high() {digitalWrite(p, HIGH);} static void set_high() {digitalWrite(p, HIGH);}
static inline void set_low() {digitalWrite(p, LOW);} static void set_low() {digitalWrite(p, LOW);}
static inline void set_input() {pinMode(p, INPUT);} static void set_input() {pinMode(p, INPUT);}
static inline void set_input_pullup() {pinMode(p, INPUT_PULLUP);} static void set_input_pullup() {pinMode(p, INPUT_PULLUP);}
static inline void set_output() {pinMode(p, OUTPUT);} static void set_output() {pinMode(p, OUTPUT);}
static inline uint8_t read() {return digitalRead(p);} static uint8_t read() {return digitalRead(p);}
static inline void write(bool v) {digitalWrite(p, v ? HIGH : LOW);} static void write(bool v) {digitalWrite(p, v ? HIGH : LOW);}
}; };
#define MAKE_ARDUINO_PINS(ID) typedef arduino_digital_pin<ID> ARDUINO_DIGITAL_##ID; #define MAKE_ARDUINO_PINS(ID) typedef arduino_digital_pin<ID> ARDUINO_DIGITAL_##ID;

4
Marlin/src/lcd/extui/ftdi_eve_touch_ui/ftdi_eve_lib/extended/sound_list.h
View File

@ -29,10 +29,10 @@ class SoundList {
} list[]; } list[];
public: public:
static const uint8_t n; static const uint8_t n;
static inline const char* name(uint8_t val) { static const char* name(uint8_t val) {
return (const char* ) pgm_read_ptr_far(&list[val].name); return (const char* ) pgm_read_ptr_far(&list[val].name);
} }
static inline FTDI::SoundPlayer::sound_t* data(uint8_t val) { static FTDI::SoundPlayer::sound_t* data(uint8_t val) {
return (FTDI::SoundPlayer::sound_t*) pgm_read_ptr_far(&list[val].data); return (FTDI::SoundPlayer::sound_t*) pgm_read_ptr_far(&list[val].data);
} }
}; };

4
Marlin/src/lcd/extui/mks_ui/SPIFlashStorage.h
View File

@ -96,12 +96,12 @@ private:
static uint8_t m_pageData[SPI_FLASH_PageSize]; static uint8_t m_pageData[SPI_FLASH_PageSize];
static uint32_t m_currentPage; static uint32_t m_currentPage;
static uint16_t m_pageDataUsed; static uint16_t m_pageDataUsed;
static inline uint16_t pageDataFree() { return SPI_FLASH_PageSize - m_pageDataUsed; } static uint16_t pageDataFree() { return SPI_FLASH_PageSize - m_pageDataUsed; }
static uint32_t m_startAddress; static uint32_t m_startAddress;
#if HAS_SPI_FLASH_COMPRESSION #if HAS_SPI_FLASH_COMPRESSION
static uint8_t m_compressedData[SPI_FLASH_PageSize]; static uint8_t m_compressedData[SPI_FLASH_PageSize];
static uint16_t m_compressedDataUsed; static uint16_t m_compressedDataUsed;
static inline uint16_t compressedDataFree() { return SPI_FLASH_PageSize - m_compressedDataUsed; } static uint16_t compressedDataFree() { return SPI_FLASH_PageSize - m_compressedDataUsed; }
#endif #endif
}; };

62
Marlin/src/lcd/marlinui.h
View File

@ -274,8 +274,8 @@ public:
static bool detected(); static bool detected();
static void init_lcd(); static void init_lcd();
#else #else
static inline bool detected() { return true; } static bool detected() { return true; }
static inline void init_lcd() {} static void init_lcd() {}
#endif #endif
#if HAS_PRINT_PROGRESS #if HAS_PRINT_PROGRESS
@ -294,7 +294,7 @@ public:
static void set_progress_done() { progress_override = (PROGRESS_MASK + 1U) + 100U * (PROGRESS_SCALE); } static void set_progress_done() { progress_override = (PROGRESS_MASK + 1U) + 100U * (PROGRESS_SCALE); }
static void progress_reset() { if (progress_override & (PROGRESS_MASK + 1U)) set_progress(0); } static void progress_reset() { if (progress_override & (PROGRESS_MASK + 1U)) set_progress(0); }
#if ENABLED(SHOW_REMAINING_TIME) #if ENABLED(SHOW_REMAINING_TIME)
static inline uint32_t _calculated_remaining_time() { static uint32_t _calculated_remaining_time() {
const duration_t elapsed = print_job_timer.duration(); const duration_t elapsed = print_job_timer.duration();
const progress_t progress = _get_progress(); const progress_t progress = _get_progress();
return progress ? elapsed.value * (100 * (PROGRESS_SCALE) - progress) / progress : 0; return progress ? elapsed.value * (100 * (PROGRESS_SCALE) - progress) / progress : 0;
@ -342,12 +342,12 @@ public:
static bool has_status(); static bool has_status();
static void reset_status(const bool no_welcome=false); static void reset_status(const bool no_welcome=false);
static void set_alert_status(FSTR_P const fstr); static void set_alert_status(FSTR_P const fstr);
static inline void reset_alert_level() { alert_level = 0; } static void reset_alert_level() { alert_level = 0; }
#else #else
static constexpr bool has_status() { return false; } static constexpr bool has_status() { return false; }
static inline void reset_status(const bool=false) {} static void reset_status(const bool=false) {}
static inline void set_alert_status(FSTR_P const) {} static void set_alert_status(FSTR_P const) {}
static inline void reset_alert_level() {} static void reset_alert_level() {}
#endif #endif
static void set_status(const char * const cstr, const bool persist=false); static void set_status(const char * const cstr, const bool persist=false);
@ -360,7 +360,7 @@ public:
static void draw_status_message(const bool blink); static void draw_status_message(const bool blink);
#endif #endif
#else #else
static inline void kill_screen(FSTR_P const, FSTR_P const) {} static void kill_screen(FSTR_P const, FSTR_P const) {}
#endif #endif
#if HAS_DISPLAY #if HAS_DISPLAY
@ -444,7 +444,7 @@ public:
#if HAS_BUZZER #if HAS_BUZZER
static void completion_feedback(const bool good=true); static void completion_feedback(const bool good=true);
#else #else
static inline void completion_feedback(const bool=true) { TERN_(HAS_TOUCH_SLEEP, wakeup_screen()); } static void completion_feedback(const bool=true) { TERN_(HAS_TOUCH_SLEEP, wakeup_screen()); }
#endif #endif
#if ENABLED(ADVANCED_PAUSE_FEATURE) #if ENABLED(ADVANCED_PAUSE_FEATURE)
@ -479,9 +479,9 @@ public:
#else // No LCD #else // No LCD
static inline void init() {} static void init() {}
static inline void update() {} static void update() {}
static inline void return_to_status() {} static void return_to_status() {}
#endif #endif
@ -500,17 +500,17 @@ public:
static preheat_t material_preset[PREHEAT_COUNT]; static preheat_t material_preset[PREHEAT_COUNT];
static PGM_P get_preheat_label(const uint8_t m); static PGM_P get_preheat_label(const uint8_t m);
static void apply_preheat(const uint8_t m, const uint8_t pmask, const uint8_t e=active_extruder); static void apply_preheat(const uint8_t m, const uint8_t pmask, const uint8_t e=active_extruder);
static inline void preheat_set_fan(const uint8_t m) { TERN_(HAS_FAN, apply_preheat(m, PM_FAN)); } static void preheat_set_fan(const uint8_t m) { TERN_(HAS_FAN, apply_preheat(m, PM_FAN)); }
static inline void preheat_hotend(const uint8_t m, const uint8_t e=active_extruder) { TERN_(HAS_HOTEND, apply_preheat(m, PM_HOTEND)); } static void preheat_hotend(const uint8_t m, const uint8_t e=active_extruder) { TERN_(HAS_HOTEND, apply_preheat(m, PM_HOTEND)); }
static inline void preheat_hotend_and_fan(const uint8_t m, const uint8_t e=active_extruder) { preheat_hotend(m, e); preheat_set_fan(m); } static void preheat_hotend_and_fan(const uint8_t m, const uint8_t e=active_extruder) { preheat_hotend(m, e); preheat_set_fan(m); }
static inline void preheat_bed(const uint8_t m) { TERN_(HAS_HEATED_BED, apply_preheat(m, PM_BED)); } static void preheat_bed(const uint8_t m) { TERN_(HAS_HEATED_BED, apply_preheat(m, PM_BED)); }
static inline void preheat_all(const uint8_t m) { apply_preheat(m, 0xFF); } static void preheat_all(const uint8_t m) { apply_preheat(m, 0xFF); }
#endif #endif
#if SCREENS_CAN_TIME_OUT #if SCREENS_CAN_TIME_OUT
static inline void reset_status_timeout(const millis_t ms) { return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS; } static void reset_status_timeout(const millis_t ms) { return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS; }
#else #else
static inline void reset_status_timeout(const millis_t) {} static void reset_status_timeout(const millis_t) {}
#endif #endif
#if HAS_LCD_MENU #if HAS_LCD_MENU
@ -548,11 +548,11 @@ public:
// goto_previous_screen and go_back may also be used as menu item callbacks // goto_previous_screen and go_back may also be used as menu item callbacks
static void _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, const bool is_back)); static void _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, const bool is_back));
static inline void goto_previous_screen() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, false)); } static void goto_previous_screen() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, false)); }
static inline void go_back() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, true)); } static void go_back() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, true)); }
static void return_to_status(); static void return_to_status();
static inline bool on_status_screen() { return currentScreen == status_screen; } static bool on_status_screen() { return currentScreen == status_screen; }
FORCE_INLINE static void run_current_screen() { (*currentScreen)(); } FORCE_INLINE static void run_current_screen() { (*currentScreen)(); }
#if ENABLED(LIGHTWEIGHT_UI) #if ENABLED(LIGHTWEIGHT_UI)
@ -567,7 +567,7 @@ public:
TERN(SCREENS_CAN_TIME_OUT, defer_return_to_status = defer, UNUSED(defer)); TERN(SCREENS_CAN_TIME_OUT, defer_return_to_status = defer, UNUSED(defer));
} }
static inline void goto_previous_screen_no_defer() { static void goto_previous_screen_no_defer() {
defer_status_screen(false); defer_status_screen(false);
goto_previous_screen(); goto_previous_screen();
} }
@ -599,20 +599,20 @@ public:
#if EITHER(HAS_LCD_MENU, EXTENSIBLE_UI) #if EITHER(HAS_LCD_MENU, EXTENSIBLE_UI)
static bool lcd_clicked; static bool lcd_clicked;
static inline bool use_click() { static bool use_click() {
const bool click = lcd_clicked; const bool click = lcd_clicked;
lcd_clicked = false; lcd_clicked = false;
return click; return click;
} }
#else #else
static constexpr bool lcd_clicked = false; static constexpr bool lcd_clicked = false;
static inline bool use_click() { return false; } static bool use_click() { return false; }
#endif #endif
#if ENABLED(ADVANCED_PAUSE_FEATURE) && ANY(HAS_LCD_MENU, EXTENSIBLE_UI, DWIN_CREALITY_LCD_ENHANCED, DWIN_CREALITY_LCD_JYERSUI) #if ENABLED(ADVANCED_PAUSE_FEATURE) && ANY(HAS_LCD_MENU, EXTENSIBLE_UI, DWIN_CREALITY_LCD_ENHANCED, DWIN_CREALITY_LCD_JYERSUI)
static void pause_show_message(const PauseMessage message, const PauseMode mode=PAUSE_MODE_SAME, const uint8_t extruder=active_extruder); static void pause_show_message(const PauseMessage message, const PauseMode mode=PAUSE_MODE_SAME, const uint8_t extruder=active_extruder);
#else #else
static inline void _pause_show_message() {} static void _pause_show_message() {}
#define pause_show_message(...) _pause_show_message() #define pause_show_message(...) _pause_show_message()
#endif #endif
@ -631,9 +631,9 @@ public:
#endif #endif
#if DISABLED(EEPROM_AUTO_INIT) #if DISABLED(EEPROM_AUTO_INIT)
static void eeprom_alert(const uint8_t msgid); static void eeprom_alert(const uint8_t msgid);
static inline void eeprom_alert_crc() { eeprom_alert(0); } static void eeprom_alert_crc() { eeprom_alert(0); }
static inline void eeprom_alert_index() { eeprom_alert(1); } static void eeprom_alert_index() { eeprom_alert(1); }
static inline void eeprom_alert_version() { eeprom_alert(2); } static void eeprom_alert_version() { eeprom_alert(2); }
#endif #endif
#endif #endif
@ -674,7 +674,7 @@ public:
#endif #endif
static void update_buttons(); static void update_buttons();
static inline bool button_pressed() { return BUTTON_CLICK() || TERN(TOUCH_SCREEN, touch_pressed(), false); } static bool button_pressed() { return BUTTON_CLICK() || TERN(TOUCH_SCREEN, touch_pressed(), false); }
#if EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION) #if EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION)
static void wait_for_release(); static void wait_for_release();
#endif #endif
@ -705,7 +705,7 @@ public:
#else #else
static inline void update_buttons() {} static void update_buttons() {}
#endif #endif

4
Marlin/src/lcd/menu/menu.h
View File

@ -109,7 +109,7 @@ class MenuItem_confirm : public MenuItemBase {
selectFunc_t yesFunc, selectFunc_t noFunc, selectFunc_t yesFunc, selectFunc_t noFunc,
PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr
); );
static inline void select_screen( static void select_screen(
PGM_P const yes, PGM_P const no, PGM_P const yes, PGM_P const no,
selectFunc_t yesFunc, selectFunc_t noFunc, selectFunc_t yesFunc, selectFunc_t noFunc,
PGM_P const pref, FSTR_P const string, PGM_P const suff=nullptr PGM_P const pref, FSTR_P const string, PGM_P const suff=nullptr
@ -178,7 +178,7 @@ class MenuEditItemBase : public MenuItemBase {
static void draw_edit_screen(PGM_P const pstr, const char * const value); static void draw_edit_screen(PGM_P const pstr, const char * const value);
// This method is for the current menu item // This method is for the current menu item
static inline void draw_edit_screen(const char * const value) { draw_edit_screen(editLabel, value); } static void draw_edit_screen(const char * const value) { draw_edit_screen(editLabel, value); }
}; };
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)

26
Marlin/src/lcd/menu/menu_item.h
View File

@ -39,14 +39,14 @@ class MenuItem_submenu : public MenuItemBase {
FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) { FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) {
_draw(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0]); _draw(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0]);
} }
static inline void action(PGM_P const, const screenFunc_t func) { ui.push_current_screen(); ui.goto_screen(func); } static void action(PGM_P const, const screenFunc_t func) { ui.push_current_screen(); ui.goto_screen(func); }
}; };
// Any menu item that invokes an immediate action // Any menu item that invokes an immediate action
class MenuItem_button : public MenuItemBase { class MenuItem_button : public MenuItemBase {
public: public:
// Button-y Items are selectable lines with no other indicator // Button-y Items are selectable lines with no other indicator
static inline void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) { static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) {
_draw(sel, row, pstr, '>', ' '); _draw(sel, row, pstr, '>', ' ');
} }
}; };
@ -54,8 +54,8 @@ class MenuItem_button : public MenuItemBase {
// ACTION_ITEM(LABEL, FUNC) // ACTION_ITEM(LABEL, FUNC)
class MenuItem_function : public MenuItem_button { class MenuItem_function : public MenuItem_button {
public: public:
//static inline void action(PGM_P const, const uint8_t, const menuAction_t func) { (*func)(); }; //static void action(PGM_P const, const uint8_t, const menuAction_t func) { (*func)(); };
static inline void action(PGM_P const, const menuAction_t func) { if (func) (*func)(); }; static void action(PGM_P const, const menuAction_t func) { if (func) (*func)(); };
}; };
// GCODES_ITEM(LABEL, GCODES) // GCODES_ITEM(LABEL, GCODES)
@ -65,7 +65,7 @@ class MenuItem_gcode : public MenuItem_button {
_draw(sel, row, pstr, '>', ' '); _draw(sel, row, pstr, '>', ' ');
} }
static void action(PGM_P const, PGM_P const pgcode) { queue.inject(FPSTR(pgcode)); } static void action(PGM_P const, PGM_P const pgcode) { queue.inject(FPSTR(pgcode)); }
static inline void action(PGM_P const pstr, const uint8_t, PGM_P const pgcode) { action(pstr, pgcode); } static void action(PGM_P const pstr, const uint8_t, PGM_P const pgcode) { action(pstr, pgcode); }
}; };
//////////////////////////////////////////// ////////////////////////////////////////////
@ -77,8 +77,8 @@ template<typename NAME>
class TMenuEditItem : MenuEditItemBase { class TMenuEditItem : MenuEditItemBase {
private: private:
typedef typename NAME::type_t type_t; typedef typename NAME::type_t type_t;
static inline float scale(const_float_t value) { return NAME::scale(value); } static float scale(const_float_t value) { return NAME::scale(value); }
static inline float unscale(const_float_t value) { return NAME::unscale(value); } static float unscale(const_float_t value) { return NAME::unscale(value); }
static const char* to_string(const int32_t value) { return NAME::strfunc(unscale(value)); } static const char* to_string(const int32_t value) { return NAME::strfunc(unscale(value)); }
static void load(void *ptr, const int32_t value) { *((type_t*)ptr) = unscale(value); } static void load(void *ptr, const int32_t value) { *((type_t*)ptr) = unscale(value); }
public: public:
@ -117,9 +117,9 @@ class TMenuEditItem : MenuEditItemBase {
* *
* struct MenuEditItemInfo_percent { * struct MenuEditItemInfo_percent {
* typedef uint8_t type_t; * typedef uint8_t type_t;
* static inline float scale(const_float_t value) { return value * (100.f/255.f) +0.5f; } * static float scale(const_float_t value) { return value * (100.f/255.f) +0.5f; }
* static inline float unscale(const_float_t value) { return value / (100.f/255.f) +0.5f; } * static float unscale(const_float_t value) { return value / (100.f/255.f) +0.5f; }
* static inline const char* strfunc(const_float_t value) { return ui8tostr4pctrj(_DOFIX(uint8_t,value)); } * static const char* strfunc(const_float_t value) { return ui8tostr4pctrj(_DOFIX(uint8_t,value)); }
* }; * };
* typedef TMenuEditItem<MenuEditItemInfo_percent> MenuItem_percent * typedef TMenuEditItem<MenuEditItemInfo_percent> MenuItem_percent
*/ */
@ -128,9 +128,9 @@ class TMenuEditItem : MenuEditItemBase {
#define DEFINE_MENU_EDIT_ITEM_TYPE(NAME, TYPE, STRFUNC, SCALE, ETC...) \ #define DEFINE_MENU_EDIT_ITEM_TYPE(NAME, TYPE, STRFUNC, SCALE, ETC...) \
struct MenuEditItemInfo_##NAME { \ struct MenuEditItemInfo_##NAME { \
typedef TYPE type_t; \ typedef TYPE type_t; \
static inline float scale(const_float_t value) { return value * (SCALE) ETC; } \ static float scale(const_float_t value) { return value * (SCALE) ETC; } \
static inline float unscale(const_float_t value) { return value / (SCALE) ETC; } \ static float unscale(const_float_t value) { return value / (SCALE) ETC; } \
static inline const char* strfunc(const_float_t value) { return STRFUNC(_DOFIX(TYPE,value)); } \ static const char* strfunc(const_float_t value) { return STRFUNC(_DOFIX(TYPE,value)); } \
}; \ }; \
typedef TMenuEditItem<MenuEditItemInfo_##NAME> MenuItem_##NAME typedef TMenuEditItem<MenuEditItemInfo_##NAME> MenuItem_##NAME

32
Marlin/src/lcd/tft/tft.h
View File

@ -81,24 +81,24 @@ class TFT {
static uint16_t buffer[TFT_BUFFER_SIZE]; static uint16_t buffer[TFT_BUFFER_SIZE];
static void init(); static void init();
static inline void set_font(const uint8_t *Font) { string.set_font(Font); } static void set_font(const uint8_t *Font) { string.set_font(Font); }
static inline void add_glyphs(const uint8_t *Font) { string.add_glyphs(Font); } static void add_glyphs(const uint8_t *Font) { string.add_glyphs(Font); }
static inline bool is_busy() { return io.isBusy(); } static bool is_busy() { return io.isBusy(); }
static inline void abort() { io.Abort(); } static void abort() { io.Abort(); }
static inline void write_multiple(uint16_t Data, uint16_t Count) { io.WriteMultiple(Data, Count); } static void write_multiple(uint16_t Data, uint16_t Count) { io.WriteMultiple(Data, Count); }
static inline void write_sequence(uint16_t *Data, uint16_t Count) { io.WriteSequence(Data, Count); } static void write_sequence(uint16_t *Data, uint16_t Count) { io.WriteSequence(Data, Count); }
static inline void set_window(uint16_t Xmin, uint16_t Ymin, uint16_t Xmax, uint16_t Ymax) { io.set_window(Xmin, Ymin, Xmax, Ymax); } static void set_window(uint16_t Xmin, uint16_t Ymin, uint16_t Xmax, uint16_t Ymax) { io.set_window(Xmin, Ymin, Xmax, Ymax); }
static inline void fill(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t color) { queue.fill(x, y, width, height, color); } static void fill(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t color) { queue.fill(x, y, width, height, color); }
static inline void canvas(uint16_t x, uint16_t y, uint16_t width, uint16_t height) { queue.canvas(x, y, width, height); } static void canvas(uint16_t x, uint16_t y, uint16_t width, uint16_t height) { queue.canvas(x, y, width, height); }
static inline void set_background(uint16_t color) { queue.set_background(color); } static void set_background(uint16_t color) { queue.set_background(color); }
static inline void add_text(uint16_t x, uint16_t y, uint16_t color, TFT_String tft_string, uint16_t maxWidth = 0) { queue.add_text(x, y, color, tft_string.string(), maxWidth); } static void add_text(uint16_t x, uint16_t y, uint16_t color, TFT_String tft_string, uint16_t maxWidth = 0) { queue.add_text(x, y, color, tft_string.string(), maxWidth); }
static inline void add_text(uint16_t x, uint16_t y, uint16_t color, const char *string, uint16_t maxWidth = 0) { queue.add_text(x, y, color, (uint8_t *)string, maxWidth); } static void add_text(uint16_t x, uint16_t y, uint16_t color, const char *string, uint16_t maxWidth = 0) { queue.add_text(x, y, color, (uint8_t *)string, maxWidth); }
static inline void add_image(int16_t x, int16_t y, MarlinImage image, uint16_t *colors) { queue.add_image(x, y, image, colors); } static void add_image(int16_t x, int16_t y, MarlinImage image, uint16_t *colors) { queue.add_image(x, y, image, colors); }
static inline void add_image(int16_t x, int16_t y, MarlinImage image, uint16_t color_main = COLOR_WHITE, uint16_t color_background = COLOR_BACKGROUND, uint16_t color_shadow = COLOR_BLACK) { queue.add_image(x, y, image, color_main, color_background, color_shadow); } static void add_image(int16_t x, int16_t y, MarlinImage image, uint16_t color_main = COLOR_WHITE, uint16_t color_background = COLOR_BACKGROUND, uint16_t color_shadow = COLOR_BLACK) { queue.add_image(x, y, image, color_main, color_background, color_shadow); }
static inline void add_bar(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t color) { queue.add_bar(x, y, width, height, color); } static void add_bar(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t color) { queue.add_bar(x, y, width, height, color); }
static inline void add_rectangle(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t color) { queue.add_rectangle(x, y, width, height, color); } static void add_rectangle(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t color) { queue.add_rectangle(x, y, width, height, color); }
static void draw_edit_screen_buttons(); static void draw_edit_screen_buttons();
}; };

8
Marlin/src/lcd/tft/tft_string.h
View File

@ -81,7 +81,7 @@ class TFT_String {
static font_t *font() { return font_header; }; static font_t *font() { return font_header; };
static uint16_t font_height() { return font_header->FontAscent - font_header->FontDescent; } static uint16_t font_height() { return font_header->FontAscent - font_header->FontDescent; }
static glyph_t *glyph(uint8_t character) { return glyphs[character] ?: glyphs[0x3F]; } /* Use '?' for unknown glyphs */ static glyph_t *glyph(uint8_t character) { return glyphs[character] ?: glyphs[0x3F]; } /* Use '?' for unknown glyphs */
static inline glyph_t *glyph(uint8_t *character) { return glyph(*character); } static glyph_t *glyph(uint8_t *character) { return glyph(*character); }
static void set(); static void set();
static void add(uint8_t character) { add_character(character); eol(); } static void add(uint8_t character) { add_character(character); eol(); }
@ -89,9 +89,9 @@ class TFT_String {
static void add(uint8_t *string, int8_t index, uint8_t *itemString=nullptr); static void add(uint8_t *string, int8_t index, uint8_t *itemString=nullptr);
static void set(uint8_t *string) { set(); add(string); }; static void set(uint8_t *string) { set(); add(string); };
static void set(uint8_t *string, int8_t index, const char *itemString=nullptr) { set(); add(string, index, (uint8_t *)itemString); }; static void set(uint8_t *string, int8_t index, const char *itemString=nullptr) { set(); add(string, index, (uint8_t *)itemString); };
static inline void set(const char *string) { set((uint8_t *)string); } static void set(const char *string) { set((uint8_t *)string); }
static inline void set(const char *string, int8_t index, const char *itemString=nullptr) { set((uint8_t *)string, index, itemString); } static void set(const char *string, int8_t index, const char *itemString=nullptr) { set((uint8_t *)string, index, itemString); }
static inline void add(const char *string) { add((uint8_t *)string); } static void add(const char *string) { add((uint8_t *)string); }
static void trim(uint8_t character=0x20); static void trim(uint8_t character=0x20);
static void rtrim(uint8_t character=0x20); static void rtrim(uint8_t character=0x20);

4
Marlin/src/lcd/tft/touch.h
View File

@ -106,7 +106,7 @@ class Touch {
static millis_t last_touch_ms, time_to_hold, repeat_delay, touch_time; static millis_t last_touch_ms, time_to_hold, repeat_delay, touch_time;
static TouchControlType touch_control_type; static TouchControlType touch_control_type;
static inline bool get_point(int16_t *x, int16_t *y); static bool get_point(int16_t *x, int16_t *y);
static void touch(touch_control_t *control); static void touch(touch_control_t *control);
static void hold(touch_control_t *control, millis_t delay = 0); static void hold(touch_control_t *control, millis_t delay = 0);
@ -126,7 +126,7 @@ class Touch {
static void enable() { enabled = true; } static void enable() { enabled = true; }
#if HAS_TOUCH_SLEEP #if HAS_TOUCH_SLEEP
static millis_t next_sleep_ms; static millis_t next_sleep_ms;
static inline bool isSleeping() { return next_sleep_ms == TSLP_SLEEPING; } static bool isSleeping() { return next_sleep_ms == TSLP_SLEEPING; }
static void sleepTimeout(); static void sleepTimeout();
static void wakeUp(); static void wakeUp();
#endif #endif

4
Marlin/src/libs/L64XX/L64XX_Marlin.h
View File

@ -118,11 +118,11 @@ public:
#if ENABLED(MONITOR_L6470_DRIVER_STATUS) #if ENABLED(MONITOR_L6470_DRIVER_STATUS)
static bool monitor_paused; static bool monitor_paused;
static inline void pause_monitor(const bool p) { monitor_paused = p; } static void pause_monitor(const bool p) { monitor_paused = p; }
static void monitor_update(L64XX_axis_t stepper_index); static void monitor_update(L64XX_axis_t stepper_index);
static void monitor_driver(); static void monitor_driver();
#else #else
static inline void pause_monitor(const bool) {} static void pause_monitor(const bool) {}
#endif #endif
//protected: //protected:

4
Marlin/src/libs/buzzer.h
View File

@ -77,7 +77,7 @@
* @brief Resets the state of the class * @brief Resets the state of the class
* @details Brings the class state to a known one. * @details Brings the class state to a known one.
*/ */
static inline void reset() { static void reset() {
off(); off();
state.endtime = 0; state.endtime = 0;
} }
@ -86,7 +86,7 @@
/** /**
* @brief Init Buzzer * @brief Init Buzzer
*/ */
static inline void init() { static void init() {
SET_OUTPUT(BEEPER_PIN); SET_OUTPUT(BEEPER_PIN);
reset(); reset();
} }

4
Marlin/src/libs/stopwatch.h
View File

@ -53,7 +53,7 @@ class Stopwatch {
* @return true on success * @return true on success
*/ */
static bool stop(); static bool stop();
static inline bool abort() { return stop(); } // Alias by default static bool abort() { return stop(); } // Alias by default
/** /**
* @brief Pause the stopwatch * @brief Pause the stopwatch
@ -114,7 +114,7 @@ class Stopwatch {
#else #else
static inline void debug(FSTR_P const) {} static void debug(FSTR_P const) {}
#endif #endif
}; };

4
Marlin/src/module/endstops.h
View File

@ -136,7 +136,7 @@ class Endstops {
return enabled || TERN0(HAS_BED_PROBE, z_probe_enabled); return enabled || TERN0(HAS_BED_PROBE, z_probe_enabled);
} }
static inline bool global_enabled() { return enabled_globally; } static bool global_enabled() { return enabled_globally; }
/** /**
* Periodic call to poll endstops if required. Called from temperature ISR * Periodic call to poll endstops if required. Called from temperature ISR
@ -168,7 +168,7 @@ class Endstops {
; ;
} }
static inline bool probe_switch_activated() { static bool probe_switch_activated() {
return (true return (true
#if ENABLED(PROBE_ACTIVATION_SWITCH) #if ENABLED(PROBE_ACTIVATION_SWITCH)
&& READ(PROBE_ACTIVATION_SWITCH_PIN) == PROBE_ACTIVATION_SWITCH_STATE && READ(PROBE_ACTIVATION_SWITCH_PIN) == PROBE_ACTIVATION_SWITCH_STATE

20
Marlin/src/module/planner.h
View File

@ -431,15 +431,15 @@ class Planner {
static int8_t xy_freq_limit_hz; // Minimum XY frequency setting static int8_t xy_freq_limit_hz; // Minimum XY frequency setting
static float xy_freq_min_speed_factor; // Minimum speed factor setting static float xy_freq_min_speed_factor; // Minimum speed factor setting
static int32_t xy_freq_min_interval_us; // Minimum segment time based on xy_freq_limit_hz static int32_t xy_freq_min_interval_us; // Minimum segment time based on xy_freq_limit_hz
static inline void refresh_frequency_limit() { static void refresh_frequency_limit() {
//xy_freq_min_interval_us = xy_freq_limit_hz ?: LROUND(1000000.0f / xy_freq_limit_hz); //xy_freq_min_interval_us = xy_freq_limit_hz ?: LROUND(1000000.0f / xy_freq_limit_hz);
if (xy_freq_limit_hz) if (xy_freq_limit_hz)
xy_freq_min_interval_us = LROUND(1000000.0f / xy_freq_limit_hz); xy_freq_min_interval_us = LROUND(1000000.0f / xy_freq_limit_hz);
} }
static inline void set_min_speed_factor_u8(const uint8_t v255) { static void set_min_speed_factor_u8(const uint8_t v255) {
xy_freq_min_speed_factor = float(ui8_to_percent(v255)) / 100; xy_freq_min_speed_factor = float(ui8_to_percent(v255)) / 100;
} }
static inline void set_frequency_limit(const uint8_t hz) { static void set_frequency_limit(const uint8_t hz) {
xy_freq_limit_hz = constrain(hz, 0, 100); xy_freq_limit_hz = constrain(hz, 0, 100);
refresh_frequency_limit(); refresh_frequency_limit();
} }
@ -508,7 +508,7 @@ class Planner {
#if HAS_CLASSIC_JERK #if HAS_CLASSIC_JERK
static void set_max_jerk(const AxisEnum axis, float inMaxJerkMMS); static void set_max_jerk(const AxisEnum axis, float inMaxJerkMMS);
#else #else
static inline void set_max_jerk(const AxisEnum, const_float_t) {} static void set_max_jerk(const AxisEnum, const_float_t) {}
#endif #endif
#if HAS_EXTRUDERS #if HAS_EXTRUDERS
@ -516,7 +516,7 @@ class Planner {
e_factor[e] = flow_percentage[e] * 0.01f * TERN(NO_VOLUMETRICS, 1.0f, volumetric_multiplier[e]); e_factor[e] = flow_percentage[e] * 0.01f * TERN(NO_VOLUMETRICS, 1.0f, volumetric_multiplier[e]);
} }
static inline void set_flow(const uint8_t e, const int16_t flow) { static void set_flow(const uint8_t e, const int16_t flow) {
flow_percentage[e] = flow; flow_percentage[e] = flow;
refresh_e_factor(e); refresh_e_factor(e);
} }
@ -539,7 +539,7 @@ class Planner {
#if ENABLED(FILAMENT_WIDTH_SENSOR) #if ENABLED(FILAMENT_WIDTH_SENSOR)
void apply_filament_width_sensor(const int8_t encoded_ratio); void apply_filament_width_sensor(const int8_t encoded_ratio);
static inline float volumetric_percent(const bool vol) { static float volumetric_percent(const bool vol) {
return 100.0f * (vol return 100.0f * (vol
? volumetric_area_nominal / volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM] ? volumetric_area_nominal / volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM]
: volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM] : volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM]
@ -588,7 +588,7 @@ class Planner {
* Returns 1.0 if planner.z_fade_height is 0.0. * Returns 1.0 if planner.z_fade_height is 0.0.
* Returns 0.0 if Z is past the specified 'Fade Height'. * Returns 0.0 if Z is past the specified 'Fade Height'.
*/ */
static inline float fade_scaling_factor_for_z(const_float_t rz) { static float fade_scaling_factor_for_z(const_float_t rz) {
static float z_fade_factor = 1; static float z_fade_factor = 1;
if (!z_fade_height) return 1; if (!z_fade_height) return 1;
if (rz >= z_fade_height) return 0; if (rz >= z_fade_height) return 0;
@ -838,7 +838,7 @@ class Planner {
*/ */
static float get_axis_position_mm(const AxisEnum axis); static float get_axis_position_mm(const AxisEnum axis);
static inline abce_pos_t get_axis_positions_mm() { static abce_pos_t get_axis_positions_mm() {
const abce_pos_t out = LOGICAL_AXIS_ARRAY( const abce_pos_t out = LOGICAL_AXIS_ARRAY(
get_axis_position_mm(E_AXIS), get_axis_position_mm(E_AXIS),
get_axis_position_mm(A_AXIS), get_axis_position_mm(B_AXIS), get_axis_position_mm(C_AXIS), get_axis_position_mm(A_AXIS), get_axis_position_mm(B_AXIS), get_axis_position_mm(C_AXIS),
@ -870,7 +870,7 @@ class Planner {
static float triggered_position_mm(const AxisEnum axis); static float triggered_position_mm(const AxisEnum axis);
// Blocks are queued, or we're running out moves, or the closed loop controller is waiting // Blocks are queued, or we're running out moves, or the closed loop controller is waiting
static inline bool busy() { static bool busy() {
return (has_blocks_queued() || cleaning_buffer_counter return (has_blocks_queued() || cleaning_buffer_counter
|| TERN0(EXTERNAL_CLOSED_LOOP_CONTROLLER, CLOSED_LOOP_WAITING()) || TERN0(EXTERNAL_CLOSED_LOOP_CONTROLLER, CLOSED_LOOP_WAITING())
); );
@ -938,7 +938,7 @@ class Planner {
#if ENABLED(AUTOTEMP_PROPORTIONAL) #if ENABLED(AUTOTEMP_PROPORTIONAL)
static void _autotemp_update_from_hotend(); static void _autotemp_update_from_hotend();
#else #else
static inline void _autotemp_update_from_hotend() {} static void _autotemp_update_from_hotend() {}
#endif #endif
#endif #endif

6
Marlin/src/module/printcounter.h
View File

@ -112,7 +112,7 @@ class PrintCounter: public Stopwatch {
/** /**
* @brief Initialize the print counter * @brief Initialize the print counter
*/ */
static inline void init() { static void init() {
super::init(); super::init();
loadStats(); loadStats();
} }
@ -176,8 +176,8 @@ class PrintCounter: public Stopwatch {
*/ */
static bool start(); static bool start();
static bool _stop(const bool completed); static bool _stop(const bool completed);
static inline bool stop() { return _stop(true); } static bool stop() { return _stop(true); }
static inline bool abort() { return _stop(false); } static bool abort() { return _stop(false); }
static void reset(); static void reset();

2
Marlin/src/module/settings.h
View File

@ -59,7 +59,7 @@ class MarlinSettings {
static bool load(); // Return 'true' if data was loaded ok static bool load(); // Return 'true' if data was loaded ok
static bool validate(); // Return 'true' if EEPROM data is ok static bool validate(); // Return 'true' if EEPROM data is ok
static inline void first_load() { static void first_load() {
static bool loaded = false; static bool loaded = false;
if (!loaded && load()) loaded = true; if (!loaded && load()) loaded = true;
} }

24
Marlin/src/module/stepper.h
View File

@ -457,11 +457,11 @@ class Stepper {
// The stepper subsystem goes to sleep when it runs out of things to execute. // The stepper subsystem goes to sleep when it runs out of things to execute.
// Call this to notify the subsystem that it is time to go to work. // Call this to notify the subsystem that it is time to go to work.
static inline void wake_up() { ENABLE_STEPPER_DRIVER_INTERRUPT(); } static void wake_up() { ENABLE_STEPPER_DRIVER_INTERRUPT(); }
static inline bool is_awake() { return STEPPER_ISR_ENABLED(); } static bool is_awake() { return STEPPER_ISR_ENABLED(); }
static inline bool suspend() { static bool suspend() {
const bool awake = is_awake(); const bool awake = is_awake();
if (awake) DISABLE_STEPPER_DRIVER_INTERRUPT(); if (awake) DISABLE_STEPPER_DRIVER_INTERRUPT();
return awake; return awake;
@ -564,7 +564,7 @@ class Stepper {
FORCE_INLINE static void set_z4_lock(const bool state) { locked_Z4_motor = state; } FORCE_INLINE static void set_z4_lock(const bool state) { locked_Z4_motor = state; }
#endif #endif
#endif #endif
static inline void set_all_z_lock(const bool lock, const int8_t except=-1) { static void set_all_z_lock(const bool lock, const int8_t except=-1) {
set_z1_lock(lock ^ (except == 0)); set_z1_lock(lock ^ (except == 0));
set_z2_lock(lock ^ (except == 1)); set_z2_lock(lock ^ (except == 1));
#if NUM_Z_STEPPER_DRIVERS >= 3 #if NUM_Z_STEPPER_DRIVERS >= 3
@ -586,16 +586,16 @@ class Stepper {
static axis_flags_t axis_enabled; // Axis stepper(s) ENABLED states static axis_flags_t axis_enabled; // Axis stepper(s) ENABLED states
static inline bool axis_is_enabled(const AxisEnum axis E_OPTARG(const uint8_t eindex=0)) { static bool axis_is_enabled(const AxisEnum axis E_OPTARG(const uint8_t eindex=0)) {
return TEST(axis_enabled.bits, INDEX_OF_AXIS(axis, eindex)); return TEST(axis_enabled.bits, INDEX_OF_AXIS(axis, eindex));
} }
static inline void mark_axis_enabled(const AxisEnum axis E_OPTARG(const uint8_t eindex=0)) { static void mark_axis_enabled(const AxisEnum axis E_OPTARG(const uint8_t eindex=0)) {
SBI(axis_enabled.bits, INDEX_OF_AXIS(axis, eindex)); SBI(axis_enabled.bits, INDEX_OF_AXIS(axis, eindex));
} }
static inline void mark_axis_disabled(const AxisEnum axis E_OPTARG(const uint8_t eindex=0)) { static void mark_axis_disabled(const AxisEnum axis E_OPTARG(const uint8_t eindex=0)) {
CBI(axis_enabled.bits, INDEX_OF_AXIS(axis, eindex)); CBI(axis_enabled.bits, INDEX_OF_AXIS(axis, eindex));
} }
static inline bool can_axis_disable(const AxisEnum axis E_OPTARG(const uint8_t eindex=0)) { static bool can_axis_disable(const AxisEnum axis E_OPTARG(const uint8_t eindex=0)) {
return !any_enable_overlap() || !(axis_enabled.bits & enable_overlap[INDEX_OF_AXIS(axis, eindex)]); return !any_enable_overlap() || !(axis_enabled.bits & enable_overlap[INDEX_OF_AXIS(axis, eindex)]);
} }
@ -608,10 +608,10 @@ class Stepper {
static void enable_e_steppers(); static void enable_e_steppers();
static void disable_e_steppers(); static void disable_e_steppers();
#else #else
static inline void enable_extruder() {} static void enable_extruder() {}
static inline bool disable_extruder() { return true; } static bool disable_extruder() { return true; }
static inline void enable_e_steppers() {} static void enable_e_steppers() {}
static inline void disable_e_steppers() {} static void disable_e_steppers() {}
#endif #endif
#define ENABLE_EXTRUDER(N) enable_extruder(E_TERN_(N)) #define ENABLE_EXTRUDER(N) enable_extruder(E_TERN_(N))

150
Marlin/src/module/temperature.h
View File

@ -359,7 +359,7 @@ class Temperature {
#if HAS_HOTEND #if HAS_HOTEND
static hotend_info_t temp_hotend[HOTENDS]; static hotend_info_t temp_hotend[HOTENDS];
static const celsius_t hotend_maxtemp[HOTENDS]; static const celsius_t hotend_maxtemp[HOTENDS];
static inline celsius_t hotend_max_target(const uint8_t e) { return hotend_maxtemp[e] - (HOTEND_OVERSHOOT); } static celsius_t hotend_max_target(const uint8_t e) { return hotend_maxtemp[e] - (HOTEND_OVERSHOOT); }
#endif #endif
#if HAS_HEATED_BED #if HAS_HEATED_BED
static bed_info_t temp_bed; static bed_info_t temp_bed;
@ -402,16 +402,16 @@ class Temperature {
#if ENABLED(PREVENT_COLD_EXTRUSION) #if ENABLED(PREVENT_COLD_EXTRUSION)
static bool allow_cold_extrude; static bool allow_cold_extrude;
static celsius_t extrude_min_temp; static celsius_t extrude_min_temp;
static inline bool tooCold(const celsius_t temp) { return allow_cold_extrude ? false : temp < extrude_min_temp - (TEMP_WINDOW); } static bool tooCold(const celsius_t temp) { return allow_cold_extrude ? false : temp < extrude_min_temp - (TEMP_WINDOW); }
static inline bool tooColdToExtrude(const uint8_t E_NAME) { return tooCold(wholeDegHotend(HOTEND_INDEX)); } static bool tooColdToExtrude(const uint8_t E_NAME) { return tooCold(wholeDegHotend(HOTEND_INDEX)); }
static inline bool targetTooColdToExtrude(const uint8_t E_NAME) { return tooCold(degTargetHotend(HOTEND_INDEX)); } static bool targetTooColdToExtrude(const uint8_t E_NAME) { return tooCold(degTargetHotend(HOTEND_INDEX)); }
#else #else
static inline bool tooColdToExtrude(const uint8_t) { return false; } static bool tooColdToExtrude(const uint8_t) { return false; }
static inline bool targetTooColdToExtrude(const uint8_t) { return false; } static bool targetTooColdToExtrude(const uint8_t) { return false; }
#endif #endif
static inline bool hotEnoughToExtrude(const uint8_t e) { return !tooColdToExtrude(e); } static bool hotEnoughToExtrude(const uint8_t e) { return !tooColdToExtrude(e); }
static inline bool targetHotEnoughToExtrude(const uint8_t e) { return !targetTooColdToExtrude(e); } static bool targetHotEnoughToExtrude(const uint8_t e) { return !targetTooColdToExtrude(e); }
#if EITHER(SINGLENOZZLE_STANDBY_TEMP, SINGLENOZZLE_STANDBY_FAN) #if EITHER(SINGLENOZZLE_STANDBY_TEMP, SINGLENOZZLE_STANDBY_FAN)
#if ENABLED(SINGLENOZZLE_STANDBY_TEMP) #if ENABLED(SINGLENOZZLE_STANDBY_TEMP)
@ -449,7 +449,7 @@ class Temperature {
}; };
// Convert the given heater_id_t to idle array index // Convert the given heater_id_t to idle array index
static inline IdleIndex idle_index_for_id(const int8_t heater_id) { static IdleIndex idle_index_for_id(const int8_t heater_id) {
TERN_(HAS_HEATED_BED, if (heater_id == H_BED) return IDLE_INDEX_BED); TERN_(HAS_HEATED_BED, if (heater_id == H_BED) return IDLE_INDEX_BED);
return (IdleIndex)_MAX(heater_id, 0); return (IdleIndex)_MAX(heater_id, 0);
} }
@ -525,7 +525,7 @@ class Temperature {
#if HAS_FAN_LOGIC #if HAS_FAN_LOGIC
static millis_t fan_update_ms; static millis_t fan_update_ms;
static inline void manage_extruder_fans(millis_t ms) { static void manage_extruder_fans(millis_t ms) {
if (ELAPSED(ms, fan_update_ms)) { // only need to check fan state very infrequently if (ELAPSED(ms, fan_update_ms)) { // only need to check fan state very infrequently
const millis_t next_ms = ms + fan_update_interval_ms; const millis_t next_ms = ms + fan_update_interval_ms;
#if HAS_PWMFANCHECK #if HAS_PWMFANCHECK
@ -566,25 +566,25 @@ class Temperature {
static void M305_report(const uint8_t t_index, const bool forReplay=true); static void M305_report(const uint8_t t_index, const bool forReplay=true);
static void reset_user_thermistors(); static void reset_user_thermistors();
static celsius_float_t user_thermistor_to_deg_c(const uint8_t t_index, const int16_t raw); static celsius_float_t user_thermistor_to_deg_c(const uint8_t t_index, const int16_t raw);
static inline bool set_pull_up_res(int8_t t_index, float value) { static bool set_pull_up_res(int8_t t_index, float value) {
//if (!WITHIN(t_index, 0, USER_THERMISTORS - 1)) return false; //if (!WITHIN(t_index, 0, USER_THERMISTORS - 1)) return false;
if (!WITHIN(value, 1, 1000000)) return false; if (!WITHIN(value, 1, 1000000)) return false;
user_thermistor[t_index].series_res = value; user_thermistor[t_index].series_res = value;
return true; return true;
} }
static inline bool set_res25(int8_t t_index, float value) { static bool set_res25(int8_t t_index, float value) {
if (!WITHIN(value, 1, 10000000)) return false; if (!WITHIN(value, 1, 10000000)) return false;
user_thermistor[t_index].res_25 = value; user_thermistor[t_index].res_25 = value;
user_thermistor[t_index].pre_calc = true; user_thermistor[t_index].pre_calc = true;
return true; return true;
} }
static inline bool set_beta(int8_t t_index, float value) { static bool set_beta(int8_t t_index, float value) {
if (!WITHIN(value, 1, 1000000)) return false; if (!WITHIN(value, 1, 1000000)) return false;
user_thermistor[t_index].beta = value; user_thermistor[t_index].beta = value;
user_thermistor[t_index].pre_calc = true; user_thermistor[t_index].pre_calc = true;
return true; return true;
} }
static inline bool set_sh_coeff(int8_t t_index, float value) { static bool set_sh_coeff(int8_t t_index, float value) {
if (!WITHIN(value, -0.01f, 0.01f)) return false; if (!WITHIN(value, -0.01f, 0.01f)) return false;
user_thermistor[t_index].sh_c_coeff = value; user_thermistor[t_index].sh_c_coeff = value;
user_thermistor[t_index].pre_calc = true; user_thermistor[t_index].pre_calc = true;
@ -634,18 +634,18 @@ class Temperature {
static uint8_t fan_speed_scaler[FAN_COUNT]; static uint8_t fan_speed_scaler[FAN_COUNT];
#endif #endif
static inline uint8_t scaledFanSpeed(const uint8_t fan, const uint8_t fs) { static uint8_t scaledFanSpeed(const uint8_t fan, const uint8_t fs) {
UNUSED(fan); // Potentially unused! UNUSED(fan); // Potentially unused!
return (fs * uint16_t(TERN(ADAPTIVE_FAN_SLOWING, fan_speed_scaler[fan], 128))) >> 7; return (fs * uint16_t(TERN(ADAPTIVE_FAN_SLOWING, fan_speed_scaler[fan], 128))) >> 7;
} }
static inline uint8_t scaledFanSpeed(const uint8_t fan) { static uint8_t scaledFanSpeed(const uint8_t fan) {
return scaledFanSpeed(fan, fan_speed[fan]); return scaledFanSpeed(fan, fan_speed[fan]);
} }
static constexpr inline uint8_t pwmToPercent(const uint8_t speed) { return ui8_to_percent(speed); } static constexpr inline uint8_t pwmToPercent(const uint8_t speed) { return ui8_to_percent(speed); }
static inline uint8_t fanSpeedPercent(const uint8_t fan) { return ui8_to_percent(fan_speed[fan]); } static uint8_t fanSpeedPercent(const uint8_t fan) { return ui8_to_percent(fan_speed[fan]); }
static inline uint8_t scaledFanSpeedPercent(const uint8_t fan) { return ui8_to_percent(scaledFanSpeed(fan)); } static uint8_t scaledFanSpeedPercent(const uint8_t fan) { return ui8_to_percent(scaledFanSpeed(fan)); }
#if ENABLED(EXTRA_FAN_SPEED) #if ENABLED(EXTRA_FAN_SPEED)
typedef struct { uint8_t saved, speed; } extra_fan_t; typedef struct { uint8_t saved, speed; } extra_fan_t;
@ -659,7 +659,7 @@ class Temperature {
#endif // HAS_FAN #endif // HAS_FAN
static inline void zero_fan_speeds() { static void zero_fan_speeds() {
#if HAS_FAN #if HAS_FAN
FANS_LOOP(i) set_fan_speed(i, 0); FANS_LOOP(i) set_fan_speed(i, 0);
#endif #endif
@ -680,13 +680,13 @@ class Temperature {
* Preheating hotends * Preheating hotends
*/ */
#if MILLISECONDS_PREHEAT_TIME > 0 #if MILLISECONDS_PREHEAT_TIME > 0
static inline bool is_preheating(const uint8_t E_NAME) { static bool is_preheating(const uint8_t E_NAME) {
return preheat_end_time[HOTEND_INDEX] && PENDING(millis(), preheat_end_time[HOTEND_INDEX]); return preheat_end_time[HOTEND_INDEX] && PENDING(millis(), preheat_end_time[HOTEND_INDEX]);
} }
static inline void start_preheat_time(const uint8_t E_NAME) { static void start_preheat_time(const uint8_t E_NAME) {
preheat_end_time[HOTEND_INDEX] = millis() + MILLISECONDS_PREHEAT_TIME; preheat_end_time[HOTEND_INDEX] = millis() + MILLISECONDS_PREHEAT_TIME;
} }
static inline void reset_preheat_time(const uint8_t E_NAME) { static void reset_preheat_time(const uint8_t E_NAME) {
preheat_end_time[HOTEND_INDEX] = 0; preheat_end_time[HOTEND_INDEX] = 0;
} }
#else #else
@ -697,21 +697,21 @@ class Temperature {
//inline so that there is no performance decrease. //inline so that there is no performance decrease.
//deg=degreeCelsius //deg=degreeCelsius
static inline celsius_float_t degHotend(const uint8_t E_NAME) { static celsius_float_t degHotend(const uint8_t E_NAME) {
return TERN0(HAS_HOTEND, temp_hotend[HOTEND_INDEX].celsius); return TERN0(HAS_HOTEND, temp_hotend[HOTEND_INDEX].celsius);
} }
static inline celsius_t wholeDegHotend(const uint8_t E_NAME) { static celsius_t wholeDegHotend(const uint8_t E_NAME) {
return TERN0(HAS_HOTEND, static_cast<celsius_t>(temp_hotend[HOTEND_INDEX].celsius + 0.5f)); return TERN0(HAS_HOTEND, static_cast<celsius_t>(temp_hotend[HOTEND_INDEX].celsius + 0.5f));
} }
#if ENABLED(SHOW_TEMP_ADC_VALUES) #if ENABLED(SHOW_TEMP_ADC_VALUES)
static inline int16_t rawHotendTemp(const uint8_t E_NAME) { static int16_t rawHotendTemp(const uint8_t E_NAME) {
return TERN0(HAS_HOTEND, temp_hotend[HOTEND_INDEX].raw); return TERN0(HAS_HOTEND, temp_hotend[HOTEND_INDEX].raw);
} }
#endif #endif
static inline celsius_t degTargetHotend(const uint8_t E_NAME) { static celsius_t degTargetHotend(const uint8_t E_NAME) {
return TERN0(HAS_HOTEND, temp_hotend[HOTEND_INDEX].target); return TERN0(HAS_HOTEND, temp_hotend[HOTEND_INDEX].target);
} }
@ -730,11 +730,11 @@ class Temperature {
start_watching_hotend(ee); start_watching_hotend(ee);
} }
static inline bool isHeatingHotend(const uint8_t E_NAME) { static bool isHeatingHotend(const uint8_t E_NAME) {
return temp_hotend[HOTEND_INDEX].target > temp_hotend[HOTEND_INDEX].celsius; return temp_hotend[HOTEND_INDEX].target > temp_hotend[HOTEND_INDEX].celsius;
} }
static inline bool isCoolingHotend(const uint8_t E_NAME) { static bool isCoolingHotend(const uint8_t E_NAME) {
return temp_hotend[HOTEND_INDEX].target < temp_hotend[HOTEND_INDEX].celsius; return temp_hotend[HOTEND_INDEX].target < temp_hotend[HOTEND_INDEX].celsius;
} }
@ -748,16 +748,16 @@ class Temperature {
#endif #endif
#endif #endif
static inline bool still_heating(const uint8_t e) { static bool still_heating(const uint8_t e) {
return degTargetHotend(e) > TEMP_HYSTERESIS && ABS(wholeDegHotend(e) - degTargetHotend(e)) > TEMP_HYSTERESIS; return degTargetHotend(e) > TEMP_HYSTERESIS && ABS(wholeDegHotend(e) - degTargetHotend(e)) > TEMP_HYSTERESIS;
} }
static inline bool degHotendNear(const uint8_t e, const celsius_t temp) { static bool degHotendNear(const uint8_t e, const celsius_t temp) {
return ABS(wholeDegHotend(e) - temp) < (TEMP_HYSTERESIS); return ABS(wholeDegHotend(e) - temp) < (TEMP_HYSTERESIS);
} }
// Start watching a Hotend to make sure it's really heating up // Start watching a Hotend to make sure it's really heating up
static inline void start_watching_hotend(const uint8_t E_NAME) { static void start_watching_hotend(const uint8_t E_NAME) {
UNUSED(HOTEND_INDEX); UNUSED(HOTEND_INDEX);
#if WATCH_HOTENDS #if WATCH_HOTENDS
watch_hotend[HOTEND_INDEX].restart(degHotend(HOTEND_INDEX), degTargetHotend(HOTEND_INDEX)); watch_hotend[HOTEND_INDEX].restart(degHotend(HOTEND_INDEX), degTargetHotend(HOTEND_INDEX));
@ -769,16 +769,16 @@ class Temperature {
#if HAS_HEATED_BED #if HAS_HEATED_BED
#if ENABLED(SHOW_TEMP_ADC_VALUES) #if ENABLED(SHOW_TEMP_ADC_VALUES)
static inline int16_t rawBedTemp() { return temp_bed.raw; } static int16_t rawBedTemp() { return temp_bed.raw; }
#endif #endif
static inline celsius_float_t degBed() { return temp_bed.celsius; } static celsius_float_t degBed() { return temp_bed.celsius; }
static inline celsius_t wholeDegBed() { return static_cast<celsius_t>(degBed() + 0.5f); } static celsius_t wholeDegBed() { return static_cast<celsius_t>(degBed() + 0.5f); }
static inline celsius_t degTargetBed() { return temp_bed.target; } static celsius_t degTargetBed() { return temp_bed.target; }
static inline bool isHeatingBed() { return temp_bed.target > temp_bed.celsius; } static bool isHeatingBed() { return temp_bed.target > temp_bed.celsius; }
static inline bool isCoolingBed() { return temp_bed.target < temp_bed.celsius; } static bool isCoolingBed() { return temp_bed.target < temp_bed.celsius; }
// Start watching the Bed to make sure it's really heating up // Start watching the Bed to make sure it's really heating up
static inline void start_watching_bed() { TERN_(WATCH_BED, watch_bed.restart(degBed(), degTargetBed())); } static void start_watching_bed() { TERN_(WATCH_BED, watch_bed.restart(degBed(), degTargetBed())); }
static void setTargetBed(const celsius_t celsius) { static void setTargetBed(const celsius_t celsius) {
TERN_(AUTO_POWER_CONTROL, if (celsius) powerManager.power_on()); TERN_(AUTO_POWER_CONTROL, if (celsius) powerManager.power_on());
@ -792,7 +792,7 @@ class Temperature {
static void wait_for_bed_heating(); static void wait_for_bed_heating();
static inline bool degBedNear(const celsius_t temp) { static bool degBedNear(const celsius_t temp) {
return ABS(wholeDegBed() - temp) < (TEMP_BED_HYSTERESIS); return ABS(wholeDegBed() - temp) < (TEMP_BED_HYSTERESIS);
} }
@ -800,25 +800,25 @@ class Temperature {
#if HAS_TEMP_PROBE #if HAS_TEMP_PROBE
#if ENABLED(SHOW_TEMP_ADC_VALUES) #if ENABLED(SHOW_TEMP_ADC_VALUES)
static inline int16_t rawProbeTemp() { return temp_probe.raw; } static int16_t rawProbeTemp() { return temp_probe.raw; }
#endif #endif
static inline celsius_float_t degProbe() { return temp_probe.celsius; } static celsius_float_t degProbe() { return temp_probe.celsius; }
static inline celsius_t wholeDegProbe() { return static_cast<celsius_t>(degProbe() + 0.5f); } static celsius_t wholeDegProbe() { return static_cast<celsius_t>(degProbe() + 0.5f); }
static inline bool isProbeBelowTemp(const celsius_t target_temp) { return wholeDegProbe() < target_temp; } static bool isProbeBelowTemp(const celsius_t target_temp) { return wholeDegProbe() < target_temp; }
static inline bool isProbeAboveTemp(const celsius_t target_temp) { return wholeDegProbe() > target_temp; } static bool isProbeAboveTemp(const celsius_t target_temp) { return wholeDegProbe() > target_temp; }
static bool wait_for_probe(const celsius_t target_temp, bool no_wait_for_cooling=true); static bool wait_for_probe(const celsius_t target_temp, bool no_wait_for_cooling=true);
#endif #endif
#if HAS_TEMP_CHAMBER #if HAS_TEMP_CHAMBER
#if ENABLED(SHOW_TEMP_ADC_VALUES) #if ENABLED(SHOW_TEMP_ADC_VALUES)
static inline int16_t rawChamberTemp() { return temp_chamber.raw; } static int16_t rawChamberTemp() { return temp_chamber.raw; }
#endif #endif
static inline celsius_float_t degChamber() { return temp_chamber.celsius; } static celsius_float_t degChamber() { return temp_chamber.celsius; }
static inline celsius_t wholeDegChamber() { return static_cast<celsius_t>(degChamber() + 0.5f); } static celsius_t wholeDegChamber() { return static_cast<celsius_t>(degChamber() + 0.5f); }
#if HAS_HEATED_CHAMBER #if HAS_HEATED_CHAMBER
static inline celsius_t degTargetChamber() { return temp_chamber.target; } static celsius_t degTargetChamber() { return temp_chamber.target; }
static inline bool isHeatingChamber() { return temp_chamber.target > temp_chamber.celsius; } static bool isHeatingChamber() { return temp_chamber.target > temp_chamber.celsius; }
static inline bool isCoolingChamber() { return temp_chamber.target < temp_chamber.celsius; } static bool isCoolingChamber() { return temp_chamber.target < temp_chamber.celsius; }
static bool wait_for_chamber(const bool no_wait_for_cooling=true); static bool wait_for_chamber(const bool no_wait_for_cooling=true);
#endif #endif
#endif #endif
@ -829,49 +829,49 @@ class Temperature {
start_watching_chamber(); start_watching_chamber();
} }
// Start watching the Chamber to make sure it's really heating up // Start watching the Chamber to make sure it's really heating up
static inline void start_watching_chamber() { TERN_(WATCH_CHAMBER, watch_chamber.restart(degChamber(), degTargetChamber())); } static void start_watching_chamber() { TERN_(WATCH_CHAMBER, watch_chamber.restart(degChamber(), degTargetChamber())); }
#endif #endif
#if HAS_TEMP_COOLER #if HAS_TEMP_COOLER
#if ENABLED(SHOW_TEMP_ADC_VALUES) #if ENABLED(SHOW_TEMP_ADC_VALUES)
static inline int16_t rawCoolerTemp() { return temp_cooler.raw; } static int16_t rawCoolerTemp() { return temp_cooler.raw; }
#endif #endif
static inline celsius_float_t degCooler() { return temp_cooler.celsius; } static celsius_float_t degCooler() { return temp_cooler.celsius; }
static inline celsius_t wholeDegCooler() { return static_cast<celsius_t>(temp_cooler.celsius + 0.5f); } static celsius_t wholeDegCooler() { return static_cast<celsius_t>(temp_cooler.celsius + 0.5f); }
#if HAS_COOLER #if HAS_COOLER
static inline celsius_t degTargetCooler() { return temp_cooler.target; } static celsius_t degTargetCooler() { return temp_cooler.target; }
static inline bool isLaserHeating() { return temp_cooler.target > temp_cooler.celsius; } static bool isLaserHeating() { return temp_cooler.target > temp_cooler.celsius; }
static inline bool isLaserCooling() { return temp_cooler.target < temp_cooler.celsius; } static bool isLaserCooling() { return temp_cooler.target < temp_cooler.celsius; }
static bool wait_for_cooler(const bool no_wait_for_cooling=true); static bool wait_for_cooler(const bool no_wait_for_cooling=true);
#endif #endif
#endif #endif
#if HAS_TEMP_BOARD #if HAS_TEMP_BOARD
#if ENABLED(SHOW_TEMP_ADC_VALUES) #if ENABLED(SHOW_TEMP_ADC_VALUES)
static inline int16_t rawBoardTemp() { return temp_board.raw; } static int16_t rawBoardTemp() { return temp_board.raw; }
#endif #endif
static inline celsius_float_t degBoard() { return temp_board.celsius; } static celsius_float_t degBoard() { return temp_board.celsius; }
static inline celsius_t wholeDegBoard() { return static_cast<celsius_t>(temp_board.celsius + 0.5f); } static celsius_t wholeDegBoard() { return static_cast<celsius_t>(temp_board.celsius + 0.5f); }
#endif #endif
#if HAS_TEMP_REDUNDANT #if HAS_TEMP_REDUNDANT
#if ENABLED(SHOW_TEMP_ADC_VALUES) #if ENABLED(SHOW_TEMP_ADC_VALUES)
static inline int16_t rawRedundantTemp() { return temp_redundant.raw; } static int16_t rawRedundantTemp() { return temp_redundant.raw; }
static inline int16_t rawRedundanTargetTemp() { return (*temp_redundant.target).raw; } static int16_t rawRedundanTargetTemp() { return (*temp_redundant.target).raw; }
#endif #endif
static inline celsius_float_t degRedundant() { return temp_redundant.celsius; } static celsius_float_t degRedundant() { return temp_redundant.celsius; }
static inline celsius_float_t degRedundantTarget() { return (*temp_redundant.target).celsius; } static celsius_float_t degRedundantTarget() { return (*temp_redundant.target).celsius; }
static inline celsius_t wholeDegRedundant() { return static_cast<celsius_t>(temp_redundant.celsius + 0.5f); } static celsius_t wholeDegRedundant() { return static_cast<celsius_t>(temp_redundant.celsius + 0.5f); }
static inline celsius_t wholeDegRedundantTarget() { return static_cast<celsius_t>((*temp_redundant.target).celsius + 0.5f); } static celsius_t wholeDegRedundantTarget() { return static_cast<celsius_t>((*temp_redundant.target).celsius + 0.5f); }
#endif #endif
#if HAS_COOLER #if HAS_COOLER
static inline void setTargetCooler(const celsius_t celsius) { static void setTargetCooler(const celsius_t celsius) {
temp_cooler.target = constrain(celsius, COOLER_MIN_TARGET, COOLER_MAX_TARGET); temp_cooler.target = constrain(celsius, COOLER_MIN_TARGET, COOLER_MAX_TARGET);
start_watching_cooler(); start_watching_cooler();
} }
// Start watching the Cooler to make sure it's really cooling down // Start watching the Cooler to make sure it's really cooling down
static inline void start_watching_cooler() { TERN_(WATCH_COOLER, watch_cooler.restart(degCooler(), degTargetCooler())); } static void start_watching_cooler() { TERN_(WATCH_COOLER, watch_cooler.restart(degCooler(), degTargetCooler())); }
#endif #endif
/** /**
@ -887,7 +887,7 @@ class Temperature {
/** /**
* Cooldown, as from the LCD. Disables all heaters and fans. * Cooldown, as from the LCD. Disables all heaters and fans.
*/ */
static inline void cooldown() { static void cooldown() {
zero_fan_speeds(); zero_fan_speeds();
disable_all_heaters(); disable_all_heaters();
} }
@ -921,7 +921,7 @@ class Temperature {
* Update the temp manager when PID values change * Update the temp manager when PID values change
*/ */
#if ENABLED(PIDTEMP) #if ENABLED(PIDTEMP)
static inline void updatePID() { static void updatePID() {
TERN_(PID_EXTRUSION_SCALING, last_e_position = 0); TERN_(PID_EXTRUSION_SCALING, last_e_position = 0);
} }
#endif #endif
@ -934,13 +934,13 @@ class Temperature {
#if HEATER_IDLE_HANDLER #if HEATER_IDLE_HANDLER
static inline void reset_hotend_idle_timer(const uint8_t E_NAME) { static void reset_hotend_idle_timer(const uint8_t E_NAME) {
heater_idle[HOTEND_INDEX].reset(); heater_idle[HOTEND_INDEX].reset();
start_watching_hotend(HOTEND_INDEX); start_watching_hotend(HOTEND_INDEX);
} }
#if HAS_HEATED_BED #if HAS_HEATED_BED
static inline void reset_bed_idle_timer() { static void reset_bed_idle_timer() {
heater_idle[IDLE_INDEX_BED].reset(); heater_idle[IDLE_INDEX_BED].reset();
start_watching_bed(); start_watching_bed();
} }
@ -961,7 +961,7 @@ class Temperature {
#if HAS_HOTEND && HAS_STATUS_MESSAGE #if HAS_HOTEND && HAS_STATUS_MESSAGE
static void set_heating_message(const uint8_t e); static void set_heating_message(const uint8_t e);
#else #else
static inline void set_heating_message(const uint8_t) {} static void set_heating_message(const uint8_t) {}
#endif #endif
#if HAS_LCD_MENU && HAS_TEMPERATURE #if HAS_LCD_MENU && HAS_TEMPERATURE
@ -974,7 +974,7 @@ class Temperature {
static volatile bool raw_temps_ready; static volatile bool raw_temps_ready;
static void update_raw_temperatures(); static void update_raw_temperatures();
static void updateTemperaturesFromRawValues(); static void updateTemperaturesFromRawValues();
static inline bool updateTemperaturesIfReady() { static bool updateTemperaturesIfReady() {
if (!raw_temps_ready) return false; if (!raw_temps_ready) return false;
updateTemperaturesFromRawValues(); updateTemperaturesFromRawValues();
raw_temps_ready = false; raw_temps_ready = false;
@ -1028,7 +1028,7 @@ class Temperature {
}; };
// Convert the given heater_id_t to runaway state array index // Convert the given heater_id_t to runaway state array index
static inline RunawayIndex runaway_index_for_id(const int8_t heater_id) { static RunawayIndex runaway_index_for_id(const int8_t heater_id) {
TERN_(HAS_THERMALLY_PROTECTED_CHAMBER, if (heater_id == H_CHAMBER) return RUNAWAY_IND_CHAMBER); TERN_(HAS_THERMALLY_PROTECTED_CHAMBER, if (heater_id == H_CHAMBER) return RUNAWAY_IND_CHAMBER);
TERN_(HAS_THERMALLY_PROTECTED_CHAMBER, if (heater_id == H_COOLER) return RUNAWAY_IND_COOLER); TERN_(HAS_THERMALLY_PROTECTED_CHAMBER, if (heater_id == H_COOLER) return RUNAWAY_IND_COOLER);
TERN_(HAS_THERMALLY_PROTECTED_BED, if (heater_id == H_BED) return RUNAWAY_IND_BED); TERN_(HAS_THERMALLY_PROTECTED_BED, if (heater_id == H_BED) return RUNAWAY_IND_BED);

38
Marlin/src/sd/cardreader.h
View File

@ -115,7 +115,7 @@ public:
static void mount(); static void mount();
static void release(); static void release();
static inline bool isMounted() { return flag.mounted; } static bool isMounted() { return flag.mounted; }
// Handle media insert/remove // Handle media insert/remove
static void manage_media(); static void manage_media();
@ -128,7 +128,7 @@ public:
static uint8_t autofile_index; // Next auto#.g index to run, plus one. Ignored by autofile_check when zero. static uint8_t autofile_index; // Next auto#.g index to run, plus one. Ignored by autofile_check when zero.
static void autofile_begin(); // Begin check. Called automatically after boot-up. static void autofile_begin(); // Begin check. Called automatically after boot-up.
static bool autofile_check(); // Check for the next auto-start file and run it. static bool autofile_check(); // Check for the next auto-start file and run it.
static inline void autofile_cancel() { autofile_index = 0; } static void autofile_cancel() { autofile_index = 0; }
#endif #endif
// Basic file ops // Basic file ops
@ -138,7 +138,7 @@ public:
static bool fileExists(const char * const name); static bool fileExists(const char * const name);
static void removeFile(const char * const name); static void removeFile(const char * const name);
static inline char* longest_filename() { return longFilename[0] ? longFilename : filename; } static char* longest_filename() { return longFilename[0] ? longFilename : filename; }
#if ENABLED(LONG_FILENAME_HOST_SUPPORT) #if ENABLED(LONG_FILENAME_HOST_SUPPORT)
static void printLongPath(char * const path); // Used by M33 static void printLongPath(char * const path); // Used by M33
#endif #endif
@ -163,18 +163,18 @@ public:
static void endFilePrintNow(TERN_(SD_RESORT, const bool re_sort=false)); static void endFilePrintNow(TERN_(SD_RESORT, const bool re_sort=false));
static void abortFilePrintNow(TERN_(SD_RESORT, const bool re_sort=false)); static void abortFilePrintNow(TERN_(SD_RESORT, const bool re_sort=false));
static void fileHasFinished(); static void fileHasFinished();
static inline void abortFilePrintSoon() { flag.abort_sd_printing = isFileOpen(); } static void abortFilePrintSoon() { flag.abort_sd_printing = isFileOpen(); }
static inline void pauseSDPrint() { flag.sdprinting = false; } static void pauseSDPrint() { flag.sdprinting = false; }
static inline bool isPrinting() { return flag.sdprinting; } static bool isPrinting() { return flag.sdprinting; }
static inline bool isPaused() { return isFileOpen() && !isPrinting(); } static bool isPaused() { return isFileOpen() && !isPrinting(); }
#if HAS_PRINT_PROGRESS_PERMYRIAD #if HAS_PRINT_PROGRESS_PERMYRIAD
static inline uint16_t permyriadDone() { static uint16_t permyriadDone() {
if (flag.sdprintdone) return 10000; if (flag.sdprintdone) return 10000;
if (isFileOpen() && filesize) return sdpos / ((filesize + 9999) / 10000); if (isFileOpen() && filesize) return sdpos / ((filesize + 9999) / 10000);
return 0; return 0;
} }
#endif #endif
static inline uint8_t percentDone() { static uint8_t percentDone() {
if (flag.sdprintdone) return 100; if (flag.sdprintdone) return 100;
if (isFileOpen() && filesize) return sdpos / ((filesize + 99) / 100); if (isFileOpen() && filesize) return sdpos / ((filesize + 99) / 100);
return 0; return 0;
@ -213,20 +213,20 @@ public:
#endif #endif
// Current Working Dir - Set by cd, cdup, cdroot, and diveToFile(true, ...) // Current Working Dir - Set by cd, cdup, cdroot, and diveToFile(true, ...)
static inline char* getWorkDirName() { workDir.getDosName(filename); return filename; } static char* getWorkDirName() { workDir.getDosName(filename); return filename; }
static inline SdFile& getWorkDir() { return workDir.isOpen() ? workDir : root; } static SdFile& getWorkDir() { return workDir.isOpen() ? workDir : root; }
// Print File stats // Print File stats
static inline uint32_t getFileSize() { return filesize; } static uint32_t getFileSize() { return filesize; }
static inline uint32_t getIndex() { return sdpos; } static uint32_t getIndex() { return sdpos; }
static inline bool isFileOpen() { return isMounted() && file.isOpen(); } static bool isFileOpen() { return isMounted() && file.isOpen(); }
static inline bool eof() { return getIndex() >= getFileSize(); } static bool eof() { return getIndex() >= getFileSize(); }
// File data operations // File data operations
static inline int16_t get() { int16_t out = (int16_t)file.read(); sdpos = file.curPosition(); return out; } static int16_t get() { int16_t out = (int16_t)file.read(); sdpos = file.curPosition(); return out; }
static inline int16_t read(void *buf, uint16_t nbyte) { return file.isOpen() ? file.read(buf, nbyte) : -1; } static int16_t read(void *buf, uint16_t nbyte) { return file.isOpen() ? file.read(buf, nbyte) : -1; }
static inline int16_t write(void *buf, uint16_t nbyte) { return file.isOpen() ? file.write(buf, nbyte) : -1; } static int16_t write(void *buf, uint16_t nbyte) { return file.isOpen() ? file.write(buf, nbyte) : -1; }
static inline void setIndex(const uint32_t index) { file.seekSet((sdpos = index)); } static void setIndex(const uint32_t index) { file.seekSet((sdpos = index)); }
// TODO: rename to diskIODriver() // TODO: rename to diskIODriver()
static DiskIODriver* diskIODriver() { return driver; } static DiskIODriver* diskIODriver() { return driver; }