zaubentrucker/muele-marlin
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Merge pull request #7722 from tcm0116/2.0.x-warnings

Browse source 
Cleanup 2.0.x compiler warnings
This commit is contained in:
Scott Lahteine 2017-10-01 21:56:54 -05:00 committed by GitHub
parent c0b365fdb4 0cb00f52d9
commit ac41eb5871
22 changed files with 238 additions and 224 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.travis.yml
View file

@ -352,8 +352,8 @@ script:
- opt_enable FILAMENT_WIDTH_SENSOR FILAMENT_LCD_DISPLAY - opt_enable FILAMENT_WIDTH_SENSOR FILAMENT_LCD_DISPLAY
- opt_enable FIX_MOUNTED_PROBE Z_SAFE_HOMING AUTO_BED_LEVELING_BILINEAR Z_MIN_PROBE_REPEATABILITY_TEST DEBUG_LEVELING_FEATURE - opt_enable FIX_MOUNTED_PROBE Z_SAFE_HOMING AUTO_BED_LEVELING_BILINEAR Z_MIN_PROBE_REPEATABILITY_TEST DEBUG_LEVELING_FEATURE
- opt_enable BABYSTEPPING BABYSTEP_XY BABYSTEP_ZPROBE_OFFSET BABYSTEP_ZPROBE_GFX_OVERLAY - opt_enable BABYSTEPPING BABYSTEP_XY BABYSTEP_ZPROBE_OFFSET BABYSTEP_ZPROBE_GFX_OVERLAY
- opt_enable PRINTCOUNTER NOZZLE_PARK_FEATURE NOZZLE_CLEAN_FEATURE PIDTEMPBED EEPROM_SETTINGS INCH_MODE_SUPPORT TEMPERATURE_UNITS_SUPPORT M100_FREE_MEMORY_WATCHER - opt_enable PRINTCOUNTER NOZZLE_PARK_FEATURE NOZZLE_CLEAN_FEATURE SLOW_PWM_HEATERS PIDTEMPBED EEPROM_SETTINGS INCH_MODE_SUPPORT TEMPERATURE_UNITS_SUPPORT M100_FREE_MEMORY_WATCHER
- opt_enable_adv ADVANCED_PAUSE_FEATURE LCD_INFO_MENU ARC_SUPPORT BEZIER_CURVE_SUPPORT EXPERIMENTAL_I2CBUS EXTENDED_CAPABILITIES_REPORT AUTO_REPORT_TEMPERATURES SDCARD_SORT_ALPHA - opt_enable_adv ADVANCED_PAUSE_FEATURE LCD_INFO_MENU ARC_SUPPORT BEZIER_CURVE_SUPPORT EXPERIMENTAL_I2CBUS EXTENDED_CAPABILITIES_REPORT AUTO_REPORT_TEMPERATURES SDCARD_SORT_ALPHA PARK_HEAD_ON_PAUSE
- opt_set_adv I2C_SLAVE_ADDRESS 63 - opt_set_adv I2C_SLAVE_ADDRESS 63
- opt_set ABL_GRID_POINTS_X 16 - opt_set ABL_GRID_POINTS_X 16
- opt_set ABL_GRID_POINTS_Y 16 - opt_set ABL_GRID_POINTS_Y 16
@ -388,7 +388,7 @@ script:
# Mixing Extruder # Mixing Extruder
# #
- restore_configs - restore_configs
- opt_enable MIXING_EXTRUDER - opt_enable MIXING_EXTRUDER DIRECT_MIXING_IN_G1
- opt_set MIXING_STEPPERS 2 - opt_set MIXING_STEPPERS 2
- build_marlin_pio ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM} - build_marlin_pio ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM}
# #

2
Marlin/src/HAL/HAL_LPC1768/HAL_spi.cpp
View file

@ -171,7 +171,7 @@
UNUSED(response); UNUSED(response);
} }
static void spiSend(const uint8_t* buf, size_t n) { void spiSend(const uint8_t* buf, size_t n) {
uint8_t response; uint8_t response;
if (n == 0) return; if (n == 0) return;
for (uint16_t i = 0; i < n; i++) { for (uint16_t i = 0; i < n; i++) {

307
Marlin/src/HAL/HAL_LPC1768/HardwareSerial.cpp
View file

@ -346,7 +346,6 @@ extern "C" {
void UART0_IRQHandler (void) void UART0_IRQHandler (void)
{ {
uint8_t IIRValue, LSRValue; uint8_t IIRValue, LSRValue;
uint8_t Dummy = Dummy;
IIRValue = LPC_UART0->IIR; IIRValue = LPC_UART0->IIR;
@ -354,59 +353,59 @@ void UART0_IRQHandler (void)
IIRValue &= 0x07; /* check bit 1~3, interrupt identification */ IIRValue &= 0x07; /* check bit 1~3, interrupt identification */
if ( IIRValue == IIR_RLS ) /* Receive Line Status */ if ( IIRValue == IIR_RLS ) /* Receive Line Status */
{ {
LSRValue = LPC_UART0->LSR; LSRValue = LPC_UART0->LSR;
/* Receive Line Status */ /* Receive Line Status */
if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) ) if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) )
{ {
/* There are errors or break interrupt */ /* There are errors or break interrupt */
/* Read LSR will clear the interrupt */ /* Read LSR will clear the interrupt */
UART0Status = LSRValue; UART0Status = LSRValue;
Dummy = LPC_UART0->RBR; /* Dummy read on RX to clear dummy = LPC_UART0->RBR; /* Dummy read on RX to clear
interrupt, then bail out */ interrupt, then bail out */
return; return;
} }
if ( LSRValue & LSR_RDR ) /* Receive Data Ready */ if ( LSRValue & LSR_RDR ) /* Receive Data Ready */
{ {
/* If no error on RLS, normal ready, save into the data buffer. */ /* If no error on RLS, normal ready, save into the data buffer. */
/* Note: read RBR will clear the interrupt */ /* Note: read RBR will clear the interrupt */
if ((UART0RxQueueWritePos+1) % UARTRXQUEUESIZE != UART0RxQueueReadPos) if ((UART0RxQueueWritePos+1) % UARTRXQUEUESIZE != UART0RxQueueReadPos)
{ {
UART0Buffer[UART0RxQueueWritePos] = LPC_UART0->RBR; UART0Buffer[UART0RxQueueWritePos] = LPC_UART0->RBR;
UART0RxQueueWritePos = (UART0RxQueueWritePos+1) % UARTRXQUEUESIZE; UART0RxQueueWritePos = (UART0RxQueueWritePos+1) % UARTRXQUEUESIZE;
} }
else else
dummy = LPC_UART0->RBR;; dummy = LPC_UART0->RBR;
} }
} }
else if ( IIRValue == IIR_RDA ) /* Receive Data Available */ else if ( IIRValue == IIR_RDA ) /* Receive Data Available */
{ {
/* Receive Data Available */ /* Receive Data Available */
if ((UART0RxQueueWritePos+1) % UARTRXQUEUESIZE != UART0RxQueueReadPos) if ((UART0RxQueueWritePos+1) % UARTRXQUEUESIZE != UART0RxQueueReadPos)
{ {
UART0Buffer[UART0RxQueueWritePos] = LPC_UART0->RBR; UART0Buffer[UART0RxQueueWritePos] = LPC_UART0->RBR;
UART0RxQueueWritePos = (UART0RxQueueWritePos+1) % UARTRXQUEUESIZE; UART0RxQueueWritePos = (UART0RxQueueWritePos+1) % UARTRXQUEUESIZE;
} }
else else
dummy = LPC_UART1->RBR;; dummy = LPC_UART1->RBR;
} }
else if ( IIRValue == IIR_CTI ) /* Character timeout indicator */ else if ( IIRValue == IIR_CTI ) /* Character timeout indicator */
{ {
/* Character Time-out indicator */ /* Character Time-out indicator */
UART0Status |= 0x100; /* Bit 9 as the CTI error */ UART0Status |= 0x100; /* Bit 9 as the CTI error */
} }
else if ( IIRValue == IIR_THRE ) /* THRE, transmit holding register empty */ else if ( IIRValue == IIR_THRE ) /* THRE, transmit holding register empty */
{ {
/* THRE interrupt */ /* THRE interrupt */
LSRValue = LPC_UART0->LSR; /* Check status in the LSR to see if LSRValue = LPC_UART0->LSR; /* Check status in the LSR to see if
valid data in U0THR or not */ valid data in U0THR or not */
if ( LSRValue & LSR_THRE ) if ( LSRValue & LSR_THRE )
{ {
UART0TxEmpty = 1; UART0TxEmpty = 1;
} }
else else
{ {
UART0TxEmpty = 0; UART0TxEmpty = 0;
} }
} }
} }
@ -422,7 +421,6 @@ void UART0_IRQHandler (void)
void UART1_IRQHandler (void) void UART1_IRQHandler (void)
{ {
uint8_t IIRValue, LSRValue; uint8_t IIRValue, LSRValue;
uint8_t Dummy = Dummy;
IIRValue = LPC_UART1->IIR; IIRValue = LPC_UART1->IIR;
@ -430,61 +428,60 @@ void UART1_IRQHandler (void)
IIRValue &= 0x07; /* check bit 1~3, interrupt identification */ IIRValue &= 0x07; /* check bit 1~3, interrupt identification */
if ( IIRValue == IIR_RLS ) /* Receive Line Status */ if ( IIRValue == IIR_RLS ) /* Receive Line Status */
{ {
LSRValue = LPC_UART1->LSR; LSRValue = LPC_UART1->LSR;
/* Receive Line Status */ /* Receive Line Status */
if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) ) if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) )
{ {
/* There are errors or break interrupt */ /* There are errors or break interrupt */
/* Read LSR will clear the interrupt */ /* Read LSR will clear the interrupt */
UART1Status = LSRValue; UART1Status = LSRValue;
Dummy = LPC_UART1->RBR; /* Dummy read on RX to clear dummy = LPC_UART1->RBR; /* Dummy read on RX to clear
interrupt, then bail out */ interrupt, then bail out */
return; return;
} }
if ( LSRValue & LSR_RDR ) /* Receive Data Ready */ if ( LSRValue & LSR_RDR ) /* Receive Data Ready */
{ {
/* If no error on RLS, normal ready, save into the data buffer. */ /* If no error on RLS, normal ready, save into the data buffer. */
/* Note: read RBR will clear the interrupt */ /* Note: read RBR will clear the interrupt */
if ((UART1RxQueueWritePos+1) % UARTRXQUEUESIZE != UART1RxQueueReadPos) if ((UART1RxQueueWritePos+1) % UARTRXQUEUESIZE != UART1RxQueueReadPos)
{ {
UART1Buffer[UART1RxQueueWritePos] = LPC_UART1->RBR; UART1Buffer[UART1RxQueueWritePos] = LPC_UART1->RBR;
UART1RxQueueWritePos =(UART1RxQueueWritePos+1) % UARTRXQUEUESIZE; UART1RxQueueWritePos =(UART1RxQueueWritePos+1) % UARTRXQUEUESIZE;
} }
else else
dummy = LPC_UART1->RBR;; dummy = LPC_UART1->RBR;
} }
} }
else if ( IIRValue == IIR_RDA ) /* Receive Data Available */ else if ( IIRValue == IIR_RDA ) /* Receive Data Available */
{ {
/* Receive Data Available */ /* Receive Data Available */
if ((UART1RxQueueWritePos+1) % UARTRXQUEUESIZE != UART1RxQueueReadPos) if ((UART1RxQueueWritePos+1) % UARTRXQUEUESIZE != UART1RxQueueReadPos)
{ {
UART1Buffer[UART1RxQueueWritePos] = LPC_UART1->RBR; UART1Buffer[UART1RxQueueWritePos] = LPC_UART1->RBR;
UART1RxQueueWritePos = (UART1RxQueueWritePos+1) % UARTRXQUEUESIZE; UART1RxQueueWritePos = (UART1RxQueueWritePos+1) % UARTRXQUEUESIZE;
} }
else else
dummy = LPC_UART1->RBR;; dummy = LPC_UART1->RBR;
} }
else if ( IIRValue == IIR_CTI ) /* Character timeout indicator */ else if ( IIRValue == IIR_CTI ) /* Character timeout indicator */
{ {
/* Character Time-out indicator */ /* Character Time-out indicator */
UART1Status |= 0x100; /* Bit 9 as the CTI error */ UART1Status |= 0x100; /* Bit 9 as the CTI error */
}
else if ( IIRValue == IIR_THRE ) /* THRE, transmit holding register empty */
{
/* THRE interrupt */
LSRValue = LPC_UART1->LSR; /* Check status in the LSR to see if
valid data in U0THR or not */
if ( LSRValue & LSR_THRE )
{
UART1TxEmpty = 1;
}
else
{
UART1TxEmpty = 0;
}
} }
else if ( IIRValue == IIR_THRE ) /* THRE, transmit holding register empty */
{
/* THRE interrupt */
LSRValue = LPC_UART1->LSR; /* Check status in the LSR to see if
valid data in U0THR or not */
if ( LSRValue & LSR_THRE )
{
UART1TxEmpty = 1;
}
else
{
UART1TxEmpty = 0;
}
}
} }
/***************************************************************************** /*****************************************************************************
** Function name: UART2_IRQHandler ** Function name: UART2_IRQHandler
@ -498,7 +495,6 @@ void UART1_IRQHandler (void)
void UART2_IRQHandler (void) void UART2_IRQHandler (void)
{ {
uint8_t IIRValue, LSRValue; uint8_t IIRValue, LSRValue;
uint8_t Dummy = Dummy;
IIRValue = LPC_UART2->IIR; IIRValue = LPC_UART2->IIR;
@ -506,57 +502,57 @@ void UART2_IRQHandler (void)
IIRValue &= 0x07; /* check bit 1~3, interrupt identification */ IIRValue &= 0x07; /* check bit 1~3, interrupt identification */
if ( IIRValue == IIR_RLS ) /* Receive Line Status */ if ( IIRValue == IIR_RLS ) /* Receive Line Status */
{ {
LSRValue = LPC_UART2->LSR; LSRValue = LPC_UART2->LSR;
/* Receive Line Status */ /* Receive Line Status */
if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) ) if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) )
{ {
/* There are errors or break interrupt */ /* There are errors or break interrupt */
/* Read LSR will clear the interrupt */ /* Read LSR will clear the interrupt */
UART2Status = LSRValue; UART2Status = LSRValue;
Dummy = LPC_UART2->RBR; /* Dummy read on RX to clear dummy = LPC_UART2->RBR; /* Dummy read on RX to clear
interrupt, then bail out */ interrupt, then bail out */
return; return;
} }
if ( LSRValue & LSR_RDR ) /* Receive Data Ready */ if ( LSRValue & LSR_RDR ) /* Receive Data Ready */
{ {
/* If no error on RLS, normal ready, save into the data buffer. */ /* If no error on RLS, normal ready, save into the data buffer. */
/* Note: read RBR will clear the interrupt */ /* Note: read RBR will clear the interrupt */
if ((UART2RxQueueWritePos+1) % UARTRXQUEUESIZE != UART2RxQueueReadPos) if ((UART2RxQueueWritePos+1) % UARTRXQUEUESIZE != UART2RxQueueReadPos)
{ {
UART2Buffer[UART2RxQueueWritePos] = LPC_UART2->RBR; UART2Buffer[UART2RxQueueWritePos] = LPC_UART2->RBR;
UART2RxQueueWritePos = (UART2RxQueueWritePos+1) % UARTRXQUEUESIZE; UART2RxQueueWritePos = (UART2RxQueueWritePos+1) % UARTRXQUEUESIZE;
} }
} }
} }
else if ( IIRValue == IIR_RDA ) /* Receive Data Available */ else if ( IIRValue == IIR_RDA ) /* Receive Data Available */
{ {
/* Receive Data Available */ /* Receive Data Available */
if ((UART2RxQueueWritePos+1) % UARTRXQUEUESIZE != UART2RxQueueReadPos) if ((UART2RxQueueWritePos+1) % UARTRXQUEUESIZE != UART2RxQueueReadPos)
{ {
UART2Buffer[UART2RxQueueWritePos] = LPC_UART2->RBR; UART2Buffer[UART2RxQueueWritePos] = LPC_UART2->RBR;
UART2RxQueueWritePos = (UART2RxQueueWritePos+1) % UARTRXQUEUESIZE; UART2RxQueueWritePos = (UART2RxQueueWritePos+1) % UARTRXQUEUESIZE;
} }
else else
dummy = LPC_UART2->RBR;; dummy = LPC_UART2->RBR;
} }
else if ( IIRValue == IIR_CTI ) /* Character timeout indicator */ else if ( IIRValue == IIR_CTI ) /* Character timeout indicator */
{ {
/* Character Time-out indicator */ /* Character Time-out indicator */
UART2Status |= 0x100; /* Bit 9 as the CTI error */ UART2Status |= 0x100; /* Bit 9 as the CTI error */
} }
else if ( IIRValue == IIR_THRE ) /* THRE, transmit holding register empty */ else if ( IIRValue == IIR_THRE ) /* THRE, transmit holding register empty */
{ {
/* THRE interrupt */ /* THRE interrupt */
LSRValue = LPC_UART2->LSR; /* Check status in the LSR to see if LSRValue = LPC_UART2->LSR; /* Check status in the LSR to see if
valid data in U0THR or not */ valid data in U0THR or not */
if ( LSRValue & LSR_THRE ) if ( LSRValue & LSR_THRE )
{ {
UART2TxEmpty = 1; UART2TxEmpty = 1;
} }
else else
{ {
UART2TxEmpty = 0; UART2TxEmpty = 0;
} }
} }
} }
/***************************************************************************** /*****************************************************************************
@ -571,7 +567,6 @@ void UART2_IRQHandler (void)
void UART3_IRQHandler (void) void UART3_IRQHandler (void)
{ {
uint8_t IIRValue, LSRValue; uint8_t IIRValue, LSRValue;
uint8_t Dummy = Dummy;
IIRValue = LPC_UART3->IIR; IIRValue = LPC_UART3->IIR;
@ -579,57 +574,57 @@ void UART3_IRQHandler (void)
IIRValue &= 0x07; /* check bit 1~3, interrupt identification */ IIRValue &= 0x07; /* check bit 1~3, interrupt identification */
if ( IIRValue == IIR_RLS ) /* Receive Line Status */ if ( IIRValue == IIR_RLS ) /* Receive Line Status */
{ {
LSRValue = LPC_UART3->LSR; LSRValue = LPC_UART3->LSR;
/* Receive Line Status */ /* Receive Line Status */
if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) ) if ( LSRValue & (LSR_OE|LSR_PE|LSR_FE|LSR_RXFE|LSR_BI) )
{ {
/* There are errors or break interrupt */ /* There are errors or break interrupt */
/* Read LSR will clear the interrupt */ /* Read LSR will clear the interrupt */
UART3Status = LSRValue; UART3Status = LSRValue;
Dummy = LPC_UART3->RBR; /* Dummy read on RX to clear dummy = LPC_UART3->RBR; /* Dummy read on RX to clear
interrupt, then bail out */ interrupt, then bail out */
return; return;
} }
if ( LSRValue & LSR_RDR ) /* Receive Data Ready */ if ( LSRValue & LSR_RDR ) /* Receive Data Ready */
{ {
/* If no error on RLS, normal ready, save into the data buffer. */ /* If no error on RLS, normal ready, save into the data buffer. */
/* Note: read RBR will clear the interrupt */ /* Note: read RBR will clear the interrupt */
if ((UART3RxQueueWritePos+1) % UARTRXQUEUESIZE != UART3RxQueueReadPos) if ((UART3RxQueueWritePos+1) % UARTRXQUEUESIZE != UART3RxQueueReadPos)
{ {
UART3Buffer[UART3RxQueueWritePos] = LPC_UART3->RBR; UART3Buffer[UART3RxQueueWritePos] = LPC_UART3->RBR;
UART3RxQueueWritePos = (UART3RxQueueWritePos+1) % UARTRXQUEUESIZE; UART3RxQueueWritePos = (UART3RxQueueWritePos+1) % UARTRXQUEUESIZE;
} }
} }
} }
else if ( IIRValue == IIR_RDA ) /* Receive Data Available */ else if ( IIRValue == IIR_RDA ) /* Receive Data Available */
{ {
/* Receive Data Available */ /* Receive Data Available */
if ((UART3RxQueueWritePos+1) % UARTRXQUEUESIZE != UART3RxQueueReadPos) if ((UART3RxQueueWritePos+1) % UARTRXQUEUESIZE != UART3RxQueueReadPos)
{ {
UART3Buffer[UART3RxQueueWritePos] = LPC_UART3->RBR; UART3Buffer[UART3RxQueueWritePos] = LPC_UART3->RBR;
UART3RxQueueWritePos = (UART3RxQueueWritePos+1) % UARTRXQUEUESIZE; UART3RxQueueWritePos = (UART3RxQueueWritePos+1) % UARTRXQUEUESIZE;
} }
else else
dummy = LPC_UART3->RBR;; dummy = LPC_UART3->RBR;
} }
else if ( IIRValue == IIR_CTI ) /* Character timeout indicator */ else if ( IIRValue == IIR_CTI ) /* Character timeout indicator */
{ {
/* Character Time-out indicator */ /* Character Time-out indicator */
UART3Status |= 0x100; /* Bit 9 as the CTI error */ UART3Status |= 0x100; /* Bit 9 as the CTI error */
} }
else if ( IIRValue == IIR_THRE ) /* THRE, transmit holding register empty */ else if ( IIRValue == IIR_THRE ) /* THRE, transmit holding register empty */
{ {
/* THRE interrupt */ /* THRE interrupt */
LSRValue = LPC_UART3->LSR; /* Check status in the LSR to see if LSRValue = LPC_UART3->LSR; /* Check status in the LSR to see if
valid data in U0THR or not */ valid data in U0THR or not */
if ( LSRValue & LSR_THRE ) if ( LSRValue & LSR_THRE )
{ {
UART3TxEmpty = 1; UART3TxEmpty = 1;
} }
else else
{ {
UART3TxEmpty = 0; UART3TxEmpty = 0;
} }
} }
} }

4
Marlin/src/HAL/HAL_LPC1768/LPC1768_Servo.cpp
View file

@ -147,9 +147,11 @@
bool Servo::attached() { return servo_info[this->servoIndex].Pin.isActive; } bool Servo::attached() { return servo_info[this->servoIndex].Pin.isActive; }
void Servo::move(const int value) { void Servo::move(const int value) {
constexpr uint16_t servo_delay[] = SERVO_DELAY;
static_assert(COUNT(servo_delay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");
if (this->attach(0) >= 0) { // notice the pin number is zero here if (this->attach(0) >= 0) { // notice the pin number is zero here
this->write(value); this->write(value);
delay(SERVO_DELAY); delay(servo_delay[this->servoIndex]);
#if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE) #if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE)
this->detach(); this->detach();
LPC1768_PWM_detach_pin(servo_info[this->servoIndex].Pin.nbr); // shut down the PWM signal LPC1768_PWM_detach_pin(servo_info[this->servoIndex].Pin.nbr); // shut down the PWM signal

8
Marlin/src/HAL/HAL_LPC1768/SoftwareSerial.cpp
View file

@ -292,10 +292,10 @@ void SoftwareSerial::begin(long speed)
void SoftwareSerial::setRxIntMsk(bool enable) void SoftwareSerial::setRxIntMsk(bool enable)
{ {
if (enable) if (enable)
GpioEnableInt(_receivePort,_receivePin,CHANGE); GpioEnableInt(_receivePort,_receivePin,CHANGE);
else else
GpioDisableInt(_receivePort,_receivePin); GpioDisableInt(_receivePort,_receivePin);
} }
void SoftwareSerial::end() void SoftwareSerial::end()

6
Marlin/src/HAL/HAL_LPC1768/SoftwareSerial.h
View file

@ -71,12 +71,12 @@ private:
static SoftwareSerial *active_object; static SoftwareSerial *active_object;
// private methods // private methods
void recv() __attribute__((__always_inline__)); void recv();
uint32_t rx_pin_read(); uint32_t rx_pin_read();
void tx_pin_write(uint8_t pin_state) __attribute__((__always_inline__)); void tx_pin_write(uint8_t pin_state);
void setTX(uint8_t transmitPin); void setTX(uint8_t transmitPin);
void setRX(uint8_t receivePin); void setRX(uint8_t receivePin);
void setRxIntMsk(bool enable) __attribute__((__always_inline__)); void setRxIntMsk(bool enable);
// private static method for timing // private static method for timing
static inline void tunedDelay(uint32_t delay); static inline void tunedDelay(uint32_t delay);

6
Marlin/src/HAL/HAL_LPC1768/arduino.cpp
View file

@ -62,9 +62,9 @@ void delayMicroseconds(uint32_t us) {
while (loops > 0) --loops; while (loops > 0) --loops;
} }
else { // poll systick, more accurate through interrupts else { // poll systick, more accurate through interrupts
int32_t start = SysTick->VAL; uint32_t start = SysTick->VAL;
int32_t load = SysTick->LOAD; uint32_t load = SysTick->LOAD;
int32_t end = start - (load / 1000) * us; uint32_t end = start - (load / 1000) * us;
if (end >> 31) if (end >> 31)
while (!(SysTick->VAL > start && SysTick->VAL < (load + end))) __NOP(); while (!(SysTick->VAL > start && SysTick->VAL < (load + end))) __NOP();

4
Marlin/src/feature/mixing.cpp
View file

@ -24,6 +24,10 @@
#if ENABLED(MIXING_EXTRUDER) #if ENABLED(MIXING_EXTRUDER)
#if ENABLED(DIRECT_MIXING_IN_G1)
#include "../gcode/parser.h"
#endif
float mixing_factor[MIXING_STEPPERS]; // Reciprocal of mix proportion. 0.0 = off, otherwise >= 1.0. float mixing_factor[MIXING_STEPPERS]; // Reciprocal of mix proportion. 0.0 = off, otherwise >= 1.0.
#if MIXING_VIRTUAL_TOOLS > 1 #if MIXING_VIRTUAL_TOOLS > 1

24
Marlin/src/feature/pause.cpp
View file

@ -52,21 +52,23 @@ static float resume_position[XYZE];
static bool sd_print_paused = false; static bool sd_print_paused = false;
#endif #endif
static void filament_change_beep(const int8_t max_beep_count, const bool init=false) { #if HAS_BUZZER
static millis_t next_buzz = 0; static void filament_change_beep(const int8_t max_beep_count, const bool init=false) {
static int8_t runout_beep = 0; static millis_t next_buzz = 0;
static int8_t runout_beep = 0;
if (init) next_buzz = runout_beep = 0; if (init) next_buzz = runout_beep = 0;
const millis_t ms = millis(); const millis_t ms = millis();
if (ELAPSED(ms, next_buzz)) { if (ELAPSED(ms, next_buzz)) {
if (max_beep_count < 0 || runout_beep < max_beep_count + 5) { // Only beep as long as we're supposed to if (max_beep_count < 0 || runout_beep < max_beep_count + 5) { // Only beep as long as we're supposed to
next_buzz = ms + ((max_beep_count < 0 || runout_beep < max_beep_count) ? 2500 : 400); next_buzz = ms + ((max_beep_count < 0 || runout_beep < max_beep_count) ? 2500 : 400);
BUZZ(300, 2000); BUZZ(300, 2000);
runout_beep++; runout_beep++;
}
} }
} }
} #endif
static void ensure_safe_temperature() { static void ensure_safe_temperature() {
bool heaters_heating = true; bool heaters_heating = true;

24
Marlin/src/gcode/calibrate/M100.cpp
View file

@ -79,8 +79,8 @@ char* top_of_stack() {
} }
// Count the number of test bytes at the specified location. // Count the number of test bytes at the specified location.
inline int16_t count_test_bytes(const char * const ptr) { inline int32_t count_test_bytes(const char * const ptr) {
for (uint16_t i = 0; i < 32000; i++) for (uint32_t i = 0; i < 32000; i++)
if (((char) ptr[i]) != TEST_BYTE) if (((char) ptr[i]) != TEST_BYTE)
return i - 1; return i - 1;
@ -180,7 +180,7 @@ inline int check_for_free_memory_corruption(const char * const title) {
int block_cnt = 0; int block_cnt = 0;
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
if (ptr[i] == TEST_BYTE) { if (ptr[i] == TEST_BYTE) {
int16_t j = count_test_bytes(ptr + i); int32_t j = count_test_bytes(ptr + i);
if (j > 8) { if (j > 8) {
// SERIAL_ECHOPAIR("Found ", j); // SERIAL_ECHOPAIR("Found ", j);
// SERIAL_ECHOLNPAIR(" bytes free at ", hex_address(ptr + i)); // SERIAL_ECHOLNPAIR(" bytes free at ", hex_address(ptr + i));
@ -215,14 +215,14 @@ inline int check_for_free_memory_corruption(const char * const title) {
* Return the number of free bytes in the memory pool, * Return the number of free bytes in the memory pool,
* with other vital statistics defining the pool. * with other vital statistics defining the pool.
*/ */
inline void free_memory_pool_report(char * const ptr, const int16_t size) { inline void free_memory_pool_report(char * const ptr, const int32_t size) {
int16_t max_cnt = -1, block_cnt = 0; int32_t max_cnt = -1, block_cnt = 0;
char *max_addr = NULL; char *max_addr = NULL;
// Find the longest block of test bytes in the buffer // Find the longest block of test bytes in the buffer
for (int16_t i = 0; i < size; i++) { for (int32_t i = 0; i < size; i++) {
char *addr = ptr + i; char *addr = ptr + i;
if (*addr == TEST_BYTE) { if (*addr == TEST_BYTE) {
const int16_t j = count_test_bytes(addr); const int32_t j = count_test_bytes(addr);
if (j > 8) { if (j > 8) {
SERIAL_ECHOPAIR("Found ", j); SERIAL_ECHOPAIR("Found ", j);
SERIAL_ECHOLNPAIR(" bytes free at ", hex_address(addr)); SERIAL_ECHOLNPAIR(" bytes free at ", hex_address(addr));
@ -249,13 +249,13 @@ inline void free_memory_pool_report(char * const ptr, const int16_t size) {
* Corrupt <num> locations in the free memory pool and report the corrupt addresses. * Corrupt <num> locations in the free memory pool and report the corrupt addresses.
* This is useful to check the correctness of the M100 D and the M100 F commands. * This is useful to check the correctness of the M100 D and the M100 F commands.
*/ */
inline void corrupt_free_memory(char *ptr, const uint16_t size) { inline void corrupt_free_memory(char *ptr, const uint32_t size) {
ptr += 8; ptr += 8;
const uint16_t near_top = top_of_stack() - ptr - 250, // -250 to avoid interrupt activity that's altered the stack. const uint32_t near_top = top_of_stack() - ptr - 250, // -250 to avoid interrupt activity that's altered the stack.
j = near_top / (size + 1); j = near_top / (size + 1);
SERIAL_ECHOLNPGM("Corrupting free memory block.\n"); SERIAL_ECHOLNPGM("Corrupting free memory block.\n");
for (uint16_t i = 1; i <= size; i++) { for (uint32_t i = 1; i <= size; i++) {
char * const addr = ptr + i * j; char * const addr = ptr + i * j;
*addr = i; *addr = i;
SERIAL_ECHOPAIR("\nCorrupting address: ", hex_address(addr)); SERIAL_ECHOPAIR("\nCorrupting address: ", hex_address(addr));
@ -268,7 +268,7 @@ inline void free_memory_pool_report(char * const ptr, const int16_t size) {
* M100 I * M100 I
* Init memory for the M100 tests. (Automatically applied on the first M100.) * Init memory for the M100 tests. (Automatically applied on the first M100.)
*/ */
inline void init_free_memory(char *ptr, int16_t size) { inline void init_free_memory(char *ptr, int32_t size) {
SERIAL_ECHOLNPGM("Initializing free memory block.\n\n"); SERIAL_ECHOLNPGM("Initializing free memory block.\n\n");
size -= 250; // -250 to avoid interrupt activity that's altered the stack. size -= 250; // -250 to avoid interrupt activity that's altered the stack.
@ -284,7 +284,7 @@ inline void init_free_memory(char *ptr, int16_t size) {
SERIAL_ECHO(size); SERIAL_ECHO(size);
SERIAL_ECHOLNPGM(" bytes of memory initialized.\n"); SERIAL_ECHOLNPGM(" bytes of memory initialized.\n");
for (int16_t i = 0; i < size; i++) { for (int32_t i = 0; i < size; i++) {
if (ptr[i] != TEST_BYTE) { if (ptr[i] != TEST_BYTE) {
SERIAL_ECHOPAIR("? address : ", hex_address(ptr + i)); SERIAL_ECHOPAIR("? address : ", hex_address(ptr + i));
SERIAL_ECHOLNPAIR("=", hex_byte(ptr[i])); SERIAL_ECHOLNPAIR("=", hex_byte(ptr[i]));

6
Marlin/src/gcode/config/M43.cpp
View file

@ -141,15 +141,16 @@ inline void servo_probe_test() {
SERIAL_PROTOCOLLNPGM(". deploy & stow 4 times"); SERIAL_PROTOCOLLNPGM(". deploy & stow 4 times");
SET_INPUT_PULLUP(PROBE_TEST_PIN); SET_INPUT_PULLUP(PROBE_TEST_PIN);
uint8_t i = 0;
bool deploy_state, stow_state; bool deploy_state, stow_state;
for (uint8_t i = 0; i < 4; i++) { do {
MOVE_SERVO(probe_index, z_servo_angle[0]); //deploy MOVE_SERVO(probe_index, z_servo_angle[0]); //deploy
safe_delay(500); safe_delay(500);
deploy_state = READ(PROBE_TEST_PIN); deploy_state = READ(PROBE_TEST_PIN);
MOVE_SERVO(probe_index, z_servo_angle[1]); //stow MOVE_SERVO(probe_index, z_servo_angle[1]); //stow
safe_delay(500); safe_delay(500);
stow_state = READ(PROBE_TEST_PIN); stow_state = READ(PROBE_TEST_PIN);
} } while (++i < 4);
if (probe_inverting != deploy_state) SERIAL_PROTOCOLLNPGM("WARNING - INVERTING setting probably backwards"); if (probe_inverting != deploy_state) SERIAL_PROTOCOLLNPGM("WARNING - INVERTING setting probably backwards");
gcode.refresh_cmd_timeout(); gcode.refresh_cmd_timeout();
@ -167,7 +168,6 @@ inline void servo_probe_test() {
#if ENABLED(BLTOUCH) #if ENABLED(BLTOUCH)
SERIAL_PROTOCOLLNPGM("ERROR: BLTOUCH enabled - set this device up as a Z Servo Probe with inverting as true."); SERIAL_PROTOCOLLNPGM("ERROR: BLTOUCH enabled - set this device up as a Z Servo Probe with inverting as true.");
#endif #endif
} }
else { // measure active signal length else { // measure active signal length
MOVE_SERVO(probe_index, z_servo_angle[0]); // deploy MOVE_SERVO(probe_index, z_servo_angle[0]); // deploy

1
Marlin/src/gcode/feature/pause/M125.cpp
View file

@ -27,6 +27,7 @@
#include "../../gcode.h" #include "../../gcode.h"
#include "../../parser.h" #include "../../parser.h"
#include "../../../feature/pause.h" #include "../../../feature/pause.h"
#include "../../../module/motion.h"
/** /**
* M125: Store current position and move to filament change position. * M125: Store current position and move to filament change position.

4
Marlin/src/gcode/gcode.cpp
View file

@ -36,6 +36,10 @@ GcodeSuite gcode;
#include "../module/printcounter.h" #include "../module/printcounter.h"
#endif #endif
#if ENABLED(DIRECT_MIXING_IN_G1)
#include "../feature/mixing.h"
#endif
#include "../Marlin.h" // for idle() #include "../Marlin.h" // for idle()
uint8_t GcodeSuite::target_extruder; uint8_t GcodeSuite::target_extruder;

2
Marlin/src/gcode/parser.cpp
View file

@ -29,7 +29,7 @@
#include "../Marlin.h" #include "../Marlin.h"
#if ENABLED(DEBUG_GCODE_PARSER) #if ENABLED(DEBUG_GCODE_PARSER)
#include "../../libs/hex_print_routines.h" #include "../libs/hex_print_routines.h"
#endif #endif
// Must be declared for allocation and to satisfy the linker // Must be declared for allocation and to satisfy the linker

1
Marlin/src/lcd/ultralcd.cpp
View file

@ -2693,7 +2693,6 @@ void kill_screen(const char* lcd_msg) {
void lcd_delta_settings() { void lcd_delta_settings() {
START_MENU(); START_MENU();
MENU_BACK(MSG_DELTA_CALIBRATE); MENU_BACK(MSG_DELTA_CALIBRATE);
float Tz = 0.00;
MENU_ITEM_EDIT(float52, MSG_DELTA_DIAG_ROG, &delta_diagonal_rod, DELTA_DIAGONAL_ROD - 5.0, DELTA_DIAGONAL_ROD + 5.0); MENU_ITEM_EDIT(float52, MSG_DELTA_DIAG_ROG, &delta_diagonal_rod, DELTA_DIAGONAL_ROD - 5.0, DELTA_DIAGONAL_ROD + 5.0);
_delta_height = DELTA_HEIGHT + home_offset[Z_AXIS]; _delta_height = DELTA_HEIGHT + home_offset[Z_AXIS];
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float52, MSG_DELTA_HEIGHT, &_delta_height, _delta_height - 10.0, _delta_height + 10.0, _lcd_set_delta_height); MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float52, MSG_DELTA_HEIGHT, &_delta_height, _delta_height - 10.0, _delta_height + 10.0, _lcd_set_delta_height);

31
Marlin/src/libs/hex_print_routines.cpp
View file

@ -21,41 +21,46 @@
*/ */
#include "../inc/MarlinConfig.h" #include "../inc/MarlinConfig.h"
#include "../gcode/parser.h"
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER) || ENABLED(DEBUG_GCODE_PARSER) #if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER) || ENABLED(DEBUG_GCODE_PARSER)
#include "hex_print_routines.h" #include "hex_print_routines.h"
#ifdef CPU_32_BIT #ifdef CPU_32_BIT
constexpr int byte_start = 0;
static char _hex[] = "0x0000";
#else
constexpr int byte_start = 4; constexpr int byte_start = 4;
static char _hex[] = "0x00000000"; static char _hex[] = "0x00000000";
#else
constexpr int byte_start = 0;
static char _hex[] = "0x0000";
#endif #endif
char* hex_byte(const uint8_t b) { char* hex_byte(const uint8_t b) {
_hex[byte_start + 4] = hex_nybble(b >> 4); _hex[byte_start + 4] = hex_nybble(b >> 4);
_hex[byte_start + 5] = hex_nybble(b); _hex[byte_start + 5] = hex_nybble(b);
return &_hex[byte_start]; return &_hex[byte_start + 4];
} }
char* hex_word(const uint16_t w) { inline void _hex_word(const uint16_t w) {
_hex[byte_start + 2] = hex_nybble(w >> 12); _hex[byte_start + 2] = hex_nybble(w >> 12);
_hex[byte_start + 3] = hex_nybble(w >> 8); _hex[byte_start + 3] = hex_nybble(w >> 8);
_hex[byte_start + 4] = hex_nybble(w >> 4); _hex[byte_start + 4] = hex_nybble(w >> 4);
_hex[byte_start + 5] = hex_nybble(w); _hex[byte_start + 5] = hex_nybble(w);
return &_hex[byte_start - 2]; }
char* hex_word(const uint16_t w) {
_hex_word(w);
return &_hex[byte_start + 2];
} }
#ifdef CPU_32_BIT #ifdef CPU_32_BIT
char* hex_long(const uint32_t w) { char* hex_long(const uint32_t l) {
_hex[byte_start - 2] = hex_nybble(w >> 28); _hex[2] = hex_nybble(l >> 28);
_hex[byte_start - 1] = hex_nybble(w >> 24); _hex[3] = hex_nybble(l >> 24);
_hex[byte_start + 0] = hex_nybble(w >> 20); _hex[4] = hex_nybble(l >> 20);
_hex[byte_start + 1] = hex_nybble(w >> 16); _hex[5] = hex_nybble(l >> 16);
(void)hex_word((uint16_t)(w & 0xFFFF)); _hex_word((uint16_t)(l & 0xFFFF));
return &_hex[byte_start - 6]; return &_hex[2];
} }
#endif #endif

4
Marlin/src/libs/nozzle.cpp
View file

@ -26,6 +26,10 @@
#include "../module/motion.h" #include "../module/motion.h"
#include "point_t.h" #include "point_t.h"
#if ENABLED(DELTA)
#include "../module/delta.h"
#endif
/** /**
* @brief Stroke clean pattern * @brief Stroke clean pattern
* @details Wipes the nozzle back and forth in a linear movement * @details Wipes the nozzle back and forth in a linear movement

8
Marlin/src/module/stepper.cpp
View file

@ -135,9 +135,9 @@ volatile uint32_t Stepper::step_events_completed = 0; // The number of step even
* This fix isn't perfect and may lose steps - but better than locking up completely * This fix isn't perfect and may lose steps - but better than locking up completely
* in future the planner should slow down if advance stepping rate would be too high * in future the planner should slow down if advance stepping rate would be too high
*/ */
FORCE_INLINE uint16_t adv_rate(const int steps, const uint16_t timer, const uint8_t loops) { FORCE_INLINE HAL_TIMER_TYPE adv_rate(const int steps, const HAL_TIMER_TYPE timer, const uint8_t loops) {
if (steps) { if (steps) {
const uint16_t rate = (timer * loops) / abs(steps); const HAL_TIMER_TYPE rate = (timer * loops) / abs(steps);
//return constrain(rate, 1, ADV_NEVER - 1) //return constrain(rate, 1, ADV_NEVER - 1)
return rate ? rate : 1; return rate ? rate : 1;
} }
@ -815,8 +815,8 @@ void Stepper::isr() {
#if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE) #if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
#ifdef CPU_32_BIT #ifdef CPU_32_BIT
// Make sure stepper interrupt does not monopolise CPU by adjusting count to give about 8 us room // Make sure stepper interrupt does not monopolise CPU by adjusting count to give about 8 us room
uint32_t stepper_timer_count = HAL_timer_get_count(STEP_TIMER_NUM), HAL_TIMER_TYPE stepper_timer_count = HAL_timer_get_count(STEP_TIMER_NUM),
stepper_timer_current_count = HAL_timer_get_current_count(STEP_TIMER_NUM) + 8 * HAL_TICKS_PER_US; stepper_timer_current_count = HAL_timer_get_current_count(STEP_TIMER_NUM) + 8 * HAL_TICKS_PER_US;
HAL_timer_set_count(STEP_TIMER_NUM, max(stepper_timer_count, stepper_timer_current_count)); HAL_timer_set_count(STEP_TIMER_NUM, max(stepper_timer_count, stepper_timer_current_count));
#else #else
NOLESS(OCR1A, TCNT1 + 16); NOLESS(OCR1A, TCNT1 + 16);

6
Marlin/src/module/temperature.cpp
View file

@ -1744,8 +1744,8 @@ void Temperature::isr() {
// Macros for Slow PWM timer logic // Macros for Slow PWM timer logic
#define _SLOW_PWM_ROUTINE(NR, src) \ #define _SLOW_PWM_ROUTINE(NR, src) \
soft_pwm_ ##NR = src; \ soft_pwm_count_ ##NR = src; \
if (soft_pwm_ ##NR > 0) { \ if (soft_pwm_count_ ##NR > 0) { \
if (state_timer_heater_ ##NR == 0) { \ if (state_timer_heater_ ##NR == 0) { \
if (state_heater_ ##NR == 0) state_timer_heater_ ##NR = MIN_STATE_TIME; \ if (state_heater_ ##NR == 0) state_timer_heater_ ##NR = MIN_STATE_TIME; \
state_heater_ ##NR = 1; \ state_heater_ ##NR = 1; \
@ -1762,7 +1762,7 @@ void Temperature::isr() {
#define SLOW_PWM_ROUTINE(n) _SLOW_PWM_ROUTINE(n, soft_pwm_amount[n]) #define SLOW_PWM_ROUTINE(n) _SLOW_PWM_ROUTINE(n, soft_pwm_amount[n])
#define PWM_OFF_ROUTINE(NR) \ #define PWM_OFF_ROUTINE(NR) \
if (soft_pwm_ ##NR < slow_pwm_count) { \ if (soft_pwm_count_ ##NR < slow_pwm_count) { \
if (state_timer_heater_ ##NR == 0) { \ if (state_timer_heater_ ##NR == 0) { \
if (state_heater_ ##NR == 1) state_timer_heater_ ##NR = MIN_STATE_TIME; \ if (state_heater_ ##NR == 1) state_timer_heater_ ##NR = MIN_STATE_TIME; \
state_heater_ ##NR = 0; \ state_heater_ ##NR = 0; \

4
Marlin/src/module/tool_change.cpp
View file

@ -286,8 +286,7 @@ void tool_change(const uint8_t tmp_extruder, const float fr_mm_s/*=0.0*/, bool n
#else // !DUAL_X_CARRIAGE #else // !DUAL_X_CARRIAGE
#if ENABLED(PARKING_EXTRUDER) // Dual Parking extruder #if ENABLED(PARKING_EXTRUDER) // Dual Parking extruder
const float z_diff = hotend_offset[Z_AXIS][active_extruder] - hotend_offset[Z_AXIS][tmp_extruder]; float z_raise = PARKING_EXTRUDER_SECURITY_RAISE;
float z_raise = 0;
if (!no_move) { if (!no_move) {
const float parkingposx[] = PARKING_EXTRUDER_PARKING_X, const float parkingposx[] = PARKING_EXTRUDER_PARKING_X,
@ -310,7 +309,6 @@ void tool_change(const uint8_t tmp_extruder, const float fr_mm_s/*=0.0*/, bool n
SERIAL_ECHOLNPGM("Starting Autopark"); SERIAL_ECHOLNPGM("Starting Autopark");
if (DEBUGGING(LEVELING)) DEBUG_POS("current position:", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("current position:", current_position);
#endif #endif
z_raise = PARKING_EXTRUDER_SECURITY_RAISE;
current_position[Z_AXIS] += z_raise; current_position[Z_AXIS] += z_raise;
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
SERIAL_ECHOLNPGM("(1) Raise Z-Axis "); SERIAL_ECHOLNPGM("(1) Raise Z-Axis ");

2
Marlin/src/sd/SdBaseFile.cpp
View file

@ -1388,7 +1388,7 @@ bool SdBaseFile::rmdir() {
* the value zero, false, is returned for failure. * the value zero, false, is returned for failure.
*/ */
bool SdBaseFile::rmRfStar() { bool SdBaseFile::rmRfStar() {
uint16_t index; uint32_t index;
SdBaseFile f; SdBaseFile f;
rewind(); rewind();
while (curPosition_ < fileSize_) { while (curPosition_ < fileSize_) {

2
frameworks/CMSIS/LPC1768/driver/lpc17xx_nvic.c
View file

@ -115,7 +115,7 @@ void NVIC_SCBDeInit(void)
SCB->SCR = 0x00000000; SCB->SCR = 0x00000000;
SCB->CCR = 0x00000000; SCB->CCR = 0x00000000;
for (tmp = 0; tmp < 32; tmp++) { for (tmp = 0; tmp < (sizeof(SCB->SHP) / sizeof(SCB->SHP[0])); tmp++) {
SCB->SHP[tmp] = 0x00; SCB->SHP[tmp] = 0x00;
} }