diff options
30 files changed, 525 insertions, 528 deletions
diff --git a/src/CAN/CanInterface.cpp b/src/CAN/CanInterface.cpp index f3891738..932ccdfe 100644 --- a/src/CAN/CanInterface.cpp +++ b/src/CAN/CanInterface.cpp @@ -260,7 +260,7 @@ static status_code mcan_fd_send_ext_message(uint32_t id_value, const uint8_t *da } // Interrupt handler for MCAN, including RX,TX,ERROR and so on processes -void MCAN_INT0_Handler(void) +extern "C" void MCAN_INT0_Handler() noexcept { const uint32_t status = mcan_read_interrupt_status(&mcan_instance); diff --git a/src/Duet3_V06/Pins_Duet3_V06.cpp b/src/Duet3_V06/Pins_Duet3_V06.cpp index d7f5325b..a96f3508 100644 --- a/src/Duet3_V06/Pins_Duet3_V06.cpp +++ b/src/Duet3_V06/Pins_Duet3_V06.cpp @@ -11,7 +11,7 @@ // Function to look up a pin name pass back the corresponding index into the pin table // On this platform, the mapping from pin names to pins is fixed, so this is a simple lookup -bool LookupPinName(const char*pn, LogicalPin& lpin, bool& hardwareInverted) +bool LookupPinName(const char*pn, LogicalPin& lpin, bool& hardwareInverted) noexcept { if (StringEqualsIgnoreCase(pn, NoPinName)) { diff --git a/src/Duet3_V06/Pins_Duet3_V06.h b/src/Duet3_V06/Pins_Duet3_V06.h index 85305476..414d06a0 100644 --- a/src/Duet3_V06/Pins_Duet3_V06.h +++ b/src/Duet3_V06/Pins_Duet3_V06.h @@ -193,7 +193,7 @@ enum class PinCapability: uint8_t ainrwpwm = 1|2|4|8 }; -constexpr inline PinCapability operator|(PinCapability a, PinCapability b) +constexpr inline PinCapability operator|(PinCapability a, PinCapability b) noexcept { return (PinCapability)((uint8_t)a | (uint8_t)b); } @@ -202,9 +202,9 @@ constexpr inline PinCapability operator|(PinCapability a, PinCapability b) // This can be varied to suit the hardware. It is a struct not a class so that it can be direct initialised in read-only memory. struct PinEntry { - Pin GetPin() const { return pin; } - PinCapability GetCapability() const { return cap; } - const char* GetNames() const { return names; } + Pin GetPin() const noexcept { return pin; } + PinCapability GetCapability() const noexcept { return cap; } + const char* GetNames() const noexcept { return names; } Pin pin; PinCapability cap; @@ -275,7 +275,7 @@ constexpr PinEntry PinTable[] = constexpr unsigned int NumNamedPins = ARRAY_SIZE(PinTable); // Function to look up a pin name pass back the corresponding index into the pin table -bool LookupPinName(const char *pn, LogicalPin& lpin, bool& hardwareInverted); +bool LookupPinName(const char *pn, LogicalPin& lpin, bool& hardwareInverted) noexcept; // Duet pin numbers for the Linux interface constexpr Pin LinuxTfrReadyPin = PortEPin(2); @@ -323,7 +323,7 @@ namespace StepPins // All our step pins are on port C, so the bitmap is just the map of step bits in port C. // Calculate the step bit for a driver. This doesn't need to be fast. It must return 0 if the driver is remote. - static inline uint32_t CalcDriverBitmap(size_t driver) + static inline uint32_t CalcDriverBitmap(size_t driver) noexcept { return (driver < NumDirectDrivers) ? g_APinDescription[STEP_PINS[driver]].ulPin @@ -333,7 +333,7 @@ namespace StepPins // Set the specified step pins high // This needs to be as fast as possible, so we do a parallel write to the port(s). // We rely on only those port bits that are step pins being set in the PIO_OWSR register of each port - static inline void StepDriversHigh(uint32_t driverMap) + static inline void StepDriversHigh(uint32_t driverMap) noexcept { PIOC->PIO_ODSR = driverMap; // on Duet 3 all step pins are on port C } @@ -341,7 +341,7 @@ namespace StepPins // Set all step pins low // This needs to be as fast as possible, so we do a parallel write to the port(s). // We rely on only those port bits that are step pins being set in the PIO_OWSR register of each port - static inline void StepDriversLow() + static inline void StepDriversLow() noexcept { PIOC->PIO_ODSR = 0; // on Duet 3 all step pins are on port C } diff --git a/src/DuetM/Pins_DuetM.cpp b/src/DuetM/Pins_DuetM.cpp index 6f0034e2..07461c6e 100644 --- a/src/DuetM/Pins_DuetM.cpp +++ b/src/DuetM/Pins_DuetM.cpp @@ -11,7 +11,7 @@ // Function to look up a pin name pass back the corresponding index into the pin table // On this platform, the mapping from pin names to pins is fixed, so this is a simple lookup -bool LookupPinName(const char*pn, LogicalPin& lpin, bool& hardwareInverted) +bool LookupPinName(const char*pn, LogicalPin& lpin, bool& hardwareInverted) noexcept { if (StringEqualsIgnoreCase(pn, NoPinName)) { diff --git a/src/DuetM/Pins_DuetM.h b/src/DuetM/Pins_DuetM.h index 8215914e..232c3c81 100644 --- a/src/DuetM/Pins_DuetM.h +++ b/src/DuetM/Pins_DuetM.h @@ -200,7 +200,7 @@ enum class PinCapability: uint8_t ainrwpwm = 1|2|4|8 }; -constexpr inline PinCapability operator|(PinCapability a, PinCapability b) +constexpr inline PinCapability operator|(PinCapability a, PinCapability b) noexcept { return (PinCapability)((uint8_t)a | (uint8_t)b); } @@ -209,9 +209,9 @@ constexpr inline PinCapability operator|(PinCapability a, PinCapability b) // This can be varied to suit the hardware. It is a struct not a class so that it can be direct initialised in read-only memory. struct PinEntry { - Pin GetPin() const { return pin; } - PinCapability GetCapability() const { return cap; } - const char* GetNames() const { return names; } + Pin GetPin() const noexcept { return pin; } + PinCapability GetCapability() const noexcept { return cap; } + const char* GetNames() const noexcept { return names; } Pin pin; PinCapability cap; @@ -265,7 +265,7 @@ constexpr PinEntry PinTable[] = constexpr unsigned int NumNamedPins = ARRAY_SIZE(PinTable); // Function to look up a pin name pass back the corresponding index into the pin table -bool LookupPinName(const char *pn, LogicalPin& lpin, bool& hardwareInverted); +bool LookupPinName(const char *pn, LogicalPin& lpin, bool& hardwareInverted) noexcept; // Default pin allocations constexpr const char *DefaultEndstopPinNames[] = { "xstop", "ystop", "zstop" }; @@ -298,7 +298,7 @@ namespace StepPins // All our step pins are on port C, so the bitmap is just the map of step bits in port C. // Calculate the step bit for a driver. This doesn't need to be fast. It must return 0 if the driver is remote. - static inline uint32_t CalcDriverBitmap(size_t driver) + static inline uint32_t CalcDriverBitmap(size_t driver) noexcept { return (driver < NumDirectDrivers) ? g_APinDescription[STEP_PINS[driver]].ulPin @@ -308,7 +308,7 @@ namespace StepPins // Set the specified step pins high // This needs to be as fast as possible, so we do a parallel write to the port(s). // We rely on only those port bits that are step pins being set in the PIO_OWSR register of each port - static inline void StepDriversHigh(uint32_t driverMap) + static inline void StepDriversHigh(uint32_t driverMap) noexcept { PIOC->PIO_ODSR = driverMap; // on Duet Maestro all step pins are on port C } @@ -316,7 +316,7 @@ namespace StepPins // Set all step pins low // This needs to be as fast as possible, so we do a parallel write to the port(s). // We rely on only those port bits that are step pins being set in the PIO_OWSR register of each port - static inline void StepDriversLow() + static inline void StepDriversLow() noexcept { PIOC->PIO_ODSR = 0; // on Duet Maestro all step pins are on port C } diff --git a/src/DuetNG/Pins_DuetNG.cpp b/src/DuetNG/Pins_DuetNG.cpp index d7f5325b..a96f3508 100644 --- a/src/DuetNG/Pins_DuetNG.cpp +++ b/src/DuetNG/Pins_DuetNG.cpp @@ -11,7 +11,7 @@ // Function to look up a pin name pass back the corresponding index into the pin table // On this platform, the mapping from pin names to pins is fixed, so this is a simple lookup -bool LookupPinName(const char*pn, LogicalPin& lpin, bool& hardwareInverted) +bool LookupPinName(const char*pn, LogicalPin& lpin, bool& hardwareInverted) noexcept { if (StringEqualsIgnoreCase(pn, NoPinName)) { diff --git a/src/DuetNG/Pins_DuetNG.h b/src/DuetNG/Pins_DuetNG.h index f183001d..6b90a9f4 100644 --- a/src/DuetNG/Pins_DuetNG.h +++ b/src/DuetNG/Pins_DuetNG.h @@ -205,7 +205,7 @@ enum class PinCapability: uint8_t ainrwpwm = 1|2|4|8 }; -constexpr inline PinCapability operator|(PinCapability a, PinCapability b) +constexpr inline PinCapability operator|(PinCapability a, PinCapability b) noexcept { return (PinCapability)((uint8_t)a | (uint8_t)b); } @@ -214,9 +214,9 @@ constexpr inline PinCapability operator|(PinCapability a, PinCapability b) // This can be varied to suit the hardware. It is a struct not a class so that it can be direct initialised in read-only memory. struct PinEntry { - Pin GetPin() const { return pin; } - PinCapability GetCapability() const { return cap; } - const char* GetNames() const { return names; } + Pin GetPin() const noexcept { return pin; } + PinCapability GetCapability() const noexcept { return cap; } + const char* GetNames() const noexcept { return names; } Pin pin; PinCapability cap; @@ -318,7 +318,7 @@ constexpr PinEntry PinTable[] = constexpr unsigned int NumNamedPins = ARRAY_SIZE(PinTable); // Function to look up a pin name pass back the corresponding index into the pin table -bool LookupPinName(const char *pn, LogicalPin& lpin, bool& hardwareInverted); +bool LookupPinName(const char *pn, LogicalPin& lpin, bool& hardwareInverted) noexcept; // Default pin allocations constexpr const char *DefaultEndstopPinNames[] = { "xstop", "ystop", "zstop" }; @@ -357,7 +357,7 @@ namespace StepPins // All our step pins are on port D, so the bitmap is just the map of step bits in port D. // Calculate the step bit for a driver. This doesn't need to be fast. It must return 0 if the driver is remote. - static inline uint32_t CalcDriverBitmap(size_t driver) + static inline uint32_t CalcDriverBitmap(size_t driver) noexcept { return (driver < NumDirectDrivers) ? g_APinDescription[STEP_PINS[driver]].ulPin @@ -367,7 +367,7 @@ namespace StepPins // Set the specified step pins high // This needs to be as fast as possible, so we do a parallel write to the port(s). // We rely on only those port bits that are step pins being set in the PIO_OWSR register of each port - static inline void StepDriversHigh(uint32_t driverMap) + static inline void StepDriversHigh(uint32_t driverMap) noexcept { PIOD->PIO_ODSR = driverMap; // on Duet WiFi/Ethernet all step pins are on port D } @@ -375,7 +375,7 @@ namespace StepPins // Set all step pins low // This needs to be as fast as possible, so we do a parallel write to the port(s). // We rely on only those port bits that are step pins being set in the PIO_OWSR register of each port - static inline void StepDriversLow() + static inline void StepDriversLow() noexcept { PIOD->PIO_ODSR = 0; // on Duet WiFi/Ethernet all step pins are on port D } diff --git a/src/Linux/DataTransfer.cpp b/src/Linux/DataTransfer.cpp index f7e93f60..2604202d 100644 --- a/src/Linux/DataTransfer.cpp +++ b/src/Linux/DataTransfer.cpp @@ -118,7 +118,7 @@ void disable_spi() # error SBC_SPI_HANDLER undefined #endif -extern "C" void SBC_SPI_HANDLER(void) +extern "C" void SBC_SPI_HANDLER() noexcept { const uint32_t status = SBC_SPI->SPI_SR; // read status and clear interrupt SBC_SPI->SPI_IDR = SPI_IER_NSSR; // disable the interrupt diff --git a/src/Movement/DDA.cpp b/src/Movement/DDA.cpp index 2cdb258a..955685e6 100644 --- a/src/Movement/DDA.cpp +++ b/src/Movement/DDA.cpp @@ -2072,7 +2072,7 @@ void DDA::LimitSpeedAndAcceleration(float maxSpeed, float maxAcceleration) noexc // Prepare a remote extruder, returning the number of steps we are going to do before allowing for pressure advance. // This replicates some of the functionality that DriveMovement::PrepareExtruder does for local extruder drives. -int32_t DDA::PrepareRemoteExtruder(size_t drive, float& extrusionPending, float speedChange) const +int32_t DDA::PrepareRemoteExtruder(size_t drive, float& extrusionPending, float speedChange) const noexcept { // Calculate the requested extrusion amount and a few other things float extrusionRequired = totalDistance * directionVector[drive]; diff --git a/src/Movement/StepTimer.cpp b/src/Movement/StepTimer.cpp index 25082096..5c0fd23d 100644 --- a/src/Movement/StepTimer.cpp +++ b/src/Movement/StepTimer.cpp @@ -99,7 +99,7 @@ void StepTimer::Init() noexcept #if SAM4S || SAME70 // Get the interrupt clock count. The TCs on the SAM4S and SAME70 are only 16 bits wide, so we maintain the upper 16 bits in a chained counter. -/*static*/ uint32_t StepTimer::GetTimerTicks() +/*static*/ uint32_t StepTimer::GetTimerTicks() noexcept { uint16_t highWord = STEP_TC->TC_CHANNEL[STEP_TC_CHAN_UPPER].TC_CV; // get the timer high word do diff --git a/src/Movement/StepperDrivers/DriverMode.cpp b/src/Movement/StepperDrivers/DriverMode.cpp index f4d06df5..14242212 100644 --- a/src/Movement/StepperDrivers/DriverMode.cpp +++ b/src/Movement/StepperDrivers/DriverMode.cpp @@ -20,7 +20,7 @@ static const char * const DriverModeStrings[] = static_assert(ARRAY_SIZE(DriverModeStrings) == (unsigned int)DriverMode::unknown + 1, "bad driver mode string table"); -const char* TranslateDriverMode(unsigned int mode) +const char* TranslateDriverMode(unsigned int mode) noexcept { const unsigned int imode = min<unsigned int>(mode, (unsigned int)DriverMode::unknown); return DriverModeStrings[imode]; diff --git a/src/Movement/StepperDrivers/DriverMode.h b/src/Movement/StepperDrivers/DriverMode.h index 692872a3..1594a192 100644 --- a/src/Movement/StepperDrivers/DriverMode.h +++ b/src/Movement/StepperDrivers/DriverMode.h @@ -17,9 +17,9 @@ enum class DriverMode : unsigned int unknown // must be last! }; -const char* TranslateDriverMode(unsigned int mode); +const char* TranslateDriverMode(unsigned int mode) noexcept; -inline const char* TranslateDriverMode(DriverMode mode) +inline const char* TranslateDriverMode(DriverMode mode) noexcept { return TranslateDriverMode((unsigned int)mode); } diff --git a/src/Movement/StepperDrivers/TMC22xx.cpp b/src/Movement/StepperDrivers/TMC22xx.cpp index f14cd25c..3af1c715 100644 --- a/src/Movement/StepperDrivers/TMC22xx.cpp +++ b/src/Movement/StepperDrivers/TMC22xx.cpp @@ -209,7 +209,7 @@ constexpr uint8_t REGNUM_PWM_AUTO = 0x72; // Byte 7 8-bit CRC // Add 1 bit to a CRC -static inline constexpr uint8_t CRCAddBit(uint8_t crc, uint8_t currentByte, uint8_t bit) +static inline constexpr uint8_t CRCAddBit(uint8_t crc, uint8_t currentByte, uint8_t bit) noexcept { return (((crc ^ (currentByte << (7 - bit))) & 0x80) != 0) ? (crc << 1) ^ 0x07 @@ -217,7 +217,7 @@ static inline constexpr uint8_t CRCAddBit(uint8_t crc, uint8_t currentByte, uint } // Add a byte to a CRC -static inline constexpr uint8_t CRCAddByte(uint8_t crc, uint8_t currentByte) +static inline constexpr uint8_t CRCAddByte(uint8_t crc, uint8_t currentByte) noexcept { crc = CRCAddBit(crc, currentByte, 0); crc = CRCAddBit(crc, currentByte, 1); @@ -242,55 +242,55 @@ static constexpr uint8_t ReadIfcountCRC = CRCAddByte(InitialSendCRC, REGNUM_IFCO class TmcDriverState { public: - void Init(uint32_t p_driverNumber, Pin p_pin); - void SetAxisNumber(size_t p_axisNumber); - uint32_t GetAxisNumber() const { return axisNumber; } - void WriteAll(); - bool SetMicrostepping(uint32_t shift, bool interpolate); - unsigned int GetMicrostepping(bool& interpolation) const; // Get microstepping - bool SetDriverMode(unsigned int mode); - DriverMode GetDriverMode() const; - void SetCurrent(float current); - void Enable(bool en); - void AppendDriverStatus(const StringRef& reply); - uint8_t GetDriverNumber() const { return driverNumber; } - bool UpdatePending() const { return registersToUpdate != 0; } - bool UsesGlobalEnable() const { return enablePin == NoPin; } - - bool SetRegister(SmartDriverRegister reg, uint32_t regVal); - uint32_t GetRegister(SmartDriverRegister reg) const; - - float GetStandstillCurrentPercent() const; - void SetStandstillCurrentPercent(float percent); - - void TransferDone() __attribute__ ((hot)); // called by the ISR when the SPI transfer has completed - void StartTransfer() __attribute__ ((hot)); // called to start a transfer - void TransferTimedOut() { ++numTimeouts; } - void AbortTransfer(); - - uint32_t ReadLiveStatus() const; - uint32_t ReadAccumulatedStatus(uint32_t bitsToKeep); + void Init(uint32_t p_driverNumber, Pin p_pin) noexcept; + void SetAxisNumber(size_t p_axisNumber) noexcept; + uint32_t GetAxisNumber() const noexcept { return axisNumber; } + void WriteAll() noexcept; + bool SetMicrostepping(uint32_t shift, bool interpolate) noexcept; + unsigned int GetMicrostepping(bool& interpolation) const noexcept; + bool SetDriverMode(unsigned int mode) noexcept; + DriverMode GetDriverMode() const noexcept; + void SetCurrent(float current) noexcept; + void Enable(bool en) noexcept; + void AppendDriverStatus(const StringRef& reply) noexcept; + uint8_t GetDriverNumber() const noexcept { return driverNumber; } + bool UpdatePending() const noexcept { return registersToUpdate != 0; } + bool UsesGlobalEnable() const noexcept { return enablePin == NoPin; } + + bool SetRegister(SmartDriverRegister reg, uint32_t regVal) noexcept; + uint32_t GetRegister(SmartDriverRegister reg) const noexcept; + + float GetStandstillCurrentPercent() const noexcept; + void SetStandstillCurrentPercent(float percent) noexcept; + + void TransferDone() noexcept __attribute__ ((hot)); // called by the ISR when the SPI transfer has completed + void StartTransfer() noexcept __attribute__ ((hot)); // called to start a transfer + void TransferTimedOut() noexcept { ++numTimeouts; } + void AbortTransfer() noexcept; + + uint32_t ReadLiveStatus() const noexcept; + uint32_t ReadAccumulatedStatus(uint32_t bitsToKeep) noexcept; // Variables used by the ISR static TmcDriverState * volatile currentDriver; // volatile because the ISR changes it static uint32_t transferStartedTime; - void UartTmcHandler(); // core of the ISR for this driver + void UartTmcHandler() noexcept; // core of the ISR for this driver private: - bool SetChopConf(uint32_t newVal); - void UpdateRegister(size_t regIndex, uint32_t regVal); - void UpdateChopConfRegister(); // calculate the chopper control register and flag it for sending - void UpdateCurrent(); - void UpdateMaxOpenLoadStepInterval(); + bool SetChopConf(uint32_t newVal) noexcept; + void UpdateRegister(size_t regIndex, uint32_t regVal) noexcept; + void UpdateChopConfRegister() noexcept; // calculate the chopper control register and flag it for sending + void UpdateCurrent() noexcept; + void UpdateMaxOpenLoadStepInterval() noexcept; #if TMC22xx_HAS_MUX - void SetUartMux(); - static void SetupDMASend(uint8_t regnum, uint32_t outVal, uint8_t crc) __attribute__ ((hot)); // set up the PDC to send a register - static void SetupDMAReceive(uint8_t regnum, uint8_t crc) __attribute__ ((hot)); // set up the PDC to receive a register + void SetUartMux() noexcept; + static void SetupDMASend(uint8_t regnum, uint32_t outVal, uint8_t crc) noexcept __attribute__ ((hot)); // set up the PDC to send a register + static void SetupDMAReceive(uint8_t regnum, uint8_t crc) noexcept __attribute__ ((hot)); // set up the PDC to receive a register #else - void SetupDMASend(uint8_t regnum, uint32_t outVal, uint8_t crc) __attribute__ ((hot)); // set up the PDC to send a register - void SetupDMAReceive(uint8_t regnum, uint8_t crc) __attribute__ ((hot)); // set up the PDC to receive a register + void SetupDMASend(uint8_t regnum, uint32_t outVal, uint8_t crc) noexcept __attribute__ ((hot)); // set up the PDC to send a register + void SetupDMAReceive(uint8_t regnum, uint8_t crc) noexcept __attribute__ ((hot)); // set up the PDC to receive a register #endif static constexpr unsigned int NumWriteRegisters = 6; // the number of registers that we write to @@ -409,7 +409,7 @@ const uint8_t TmcDriverState::ReadRegCRCs[NumReadRegisters] = static TmcDriverState driverStates[MaxSmartDrivers]; // Set up the PDC to send a register -inline void TmcDriverState::SetupDMASend(uint8_t regNum, uint32_t regVal, uint8_t crc) +inline void TmcDriverState::SetupDMASend(uint8_t regNum, uint32_t regVal, uint8_t crc) noexcept { // Faster code, not using the ASF Pdc * const pdc = uart_get_pdc_base(uart); @@ -435,7 +435,7 @@ inline void TmcDriverState::SetupDMASend(uint8_t regNum, uint32_t regVal, uint8_ } // Set up the PDC to send a register and receive the status -inline void TmcDriverState::SetupDMAReceive(uint8_t regNum, uint8_t crc) +inline void TmcDriverState::SetupDMAReceive(uint8_t regNum, uint8_t crc) noexcept { // Faster code, not using the ASF Pdc * const pdc = uart_get_pdc_base(uart); @@ -457,7 +457,7 @@ inline void TmcDriverState::SetupDMAReceive(uint8_t regNum, uint8_t crc) } // Update the maximum step pulse interval at wich we consider open load detection to be reliable -void TmcDriverState::UpdateMaxOpenLoadStepInterval() +void TmcDriverState::UpdateMaxOpenLoadStepInterval() noexcept { const uint32_t defaultMaxInterval = StepTimer::StepClockRate/MinimumOpenLoadFullStepsPerSec; if ((writeRegisters[WriteGConf] & GCONF_SPREAD_CYCLE) != 0) @@ -478,7 +478,7 @@ void TmcDriverState::UpdateMaxOpenLoadStepInterval() } // Set a register value and flag it for updating -void TmcDriverState::UpdateRegister(size_t regIndex, uint32_t regVal) +void TmcDriverState::UpdateRegister(size_t regIndex, uint32_t regVal) noexcept { registersToUpdate &= ~(1u << regIndex); // make sure it is not updated while we are changing it uint8_t crc = InitialSendCRC; @@ -499,13 +499,13 @@ void TmcDriverState::UpdateRegister(size_t regIndex, uint32_t regVal) } // Calculate the chopper control register and flag it for sending -void TmcDriverState::UpdateChopConfRegister() +void TmcDriverState::UpdateChopConfRegister() noexcept { UpdateRegister(WriteChopConf, (enabled) ? configuredChopConfReg : configuredChopConfReg & ~CHOPCONF_TOFF_MASK); } // Initialise the state of the driver and its CS pin -void TmcDriverState::Init(uint32_t p_driverNumber, Pin p_pin) +void TmcDriverState::Init(uint32_t p_driverNumber, Pin p_pin) noexcept pre(!driversPowered) { driverNumber = p_driverNumber; @@ -542,30 +542,30 @@ pre(!driversPowered) readErrors = writeErrors = numReads = numTimeouts = 0; } -inline void TmcDriverState::SetAxisNumber(size_t p_axisNumber) +inline void TmcDriverState::SetAxisNumber(size_t p_axisNumber) noexcept { axisNumber = p_axisNumber; } // Write all registers. This is called when the drivers are known to be powered up. -inline void TmcDriverState::WriteAll() +inline void TmcDriverState::WriteAll() noexcept { registersToUpdate = (1u << NumWriteRegisters) - 1; } -float TmcDriverState::GetStandstillCurrentPercent() const +float TmcDriverState::GetStandstillCurrentPercent() const noexcept { return (float)(standstillCurrentFraction * 100)/256; } -void TmcDriverState::SetStandstillCurrentPercent(float percent) +void TmcDriverState::SetStandstillCurrentPercent(float percent) noexcept { standstillCurrentFraction = (uint8_t)constrain<long>(lrintf((percent * 256)/100), 0, 255); UpdateCurrent(); } // Set the microstepping and microstep interpolation. The desired microstepping is (1 << shift). -bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) +bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) noexcept { microstepShiftFactor = shift; configuredChopConfReg = (configuredChopConfReg & ~(CHOPCONF_MRES_MASK | CHOPCONF_INTPOL)) | ((8 - shift) << CHOPCONF_MRES_SHIFT); @@ -578,13 +578,13 @@ bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) } // Get microstepping or chopper control register -unsigned int TmcDriverState::GetMicrostepping(bool& interpolation) const +unsigned int TmcDriverState::GetMicrostepping(bool& interpolation) const noexcept { interpolation = (writeRegisters[WriteChopConf] & CHOPCONF_INTPOL) != 0; return 1u << microstepShiftFactor; } -bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) +bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) noexcept { switch(reg) { @@ -614,7 +614,7 @@ bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) } } -uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const +uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const noexcept { switch(reg) { @@ -650,7 +650,7 @@ uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const } // Set the chopper control register to the settings provided by the user. We allow only the lowest 17 bits to be set. -bool TmcDriverState::SetChopConf(uint32_t newVal) +bool TmcDriverState::SetChopConf(uint32_t newVal) noexcept { const uint32_t offTime = (newVal & CHOPCONF_TOFF_MASK) >> CHOPCONF_TOFF_SHIFT; if (offTime == 0 || (offTime == 1 && (newVal & CHOPCONF_TBL_MASK) < (2 << CHOPCONF_TBL_SHIFT))) @@ -670,7 +670,7 @@ bool TmcDriverState::SetChopConf(uint32_t newVal) } // Set the driver mode -bool TmcDriverState::SetDriverMode(unsigned int mode) +bool TmcDriverState::SetDriverMode(unsigned int mode) noexcept { switch (mode) { @@ -688,19 +688,19 @@ bool TmcDriverState::SetDriverMode(unsigned int mode) } // Get the driver mode -DriverMode TmcDriverState::GetDriverMode() const +DriverMode TmcDriverState::GetDriverMode() const noexcept { return ((writeRegisters[WriteGConf] & GCONF_SPREAD_CYCLE) != 0) ? DriverMode::spreadCycle : DriverMode::stealthChop; } // Set the motor current -void TmcDriverState::SetCurrent(float current) +void TmcDriverState::SetCurrent(float current) noexcept { motorCurrent = static_cast<uint32_t>(constrain<float>(current, 50.0, MaximumMotorCurrent)); UpdateCurrent(); } -void TmcDriverState::UpdateCurrent() +void TmcDriverState::UpdateCurrent() noexcept { // The current sense resistor on the Duet M is 0.082 ohms, to which we must add 0.03 ohms internal resistance. // Full scale peak motor current in the high sensitivity range is give by I = 0.18/(R+0.03) = 0.18/0.105 ~= 1.6A @@ -713,7 +713,7 @@ void TmcDriverState::UpdateCurrent() } // Enable or disable the driver -void TmcDriverState::Enable(bool en) +void TmcDriverState::Enable(bool en) noexcept { if (enabled != en) { @@ -727,14 +727,14 @@ void TmcDriverState::Enable(bool en) } // Read the status -uint32_t TmcDriverState::ReadLiveStatus() const +uint32_t TmcDriverState::ReadLiveStatus() const noexcept { const uint32_t ret = readRegisters[ReadDrvStat] & (TMC_RR_OT | TMC_RR_OTPW | TMC_RR_S2G | TMC_RR_OLA | TMC_RR_OLB | TMC_RR_STST | TMC_RR_TEMPBITS); return (enabled) ? ret : ret & ~(TMC_RR_OLA | TMC_RR_OLB); } // Read the status -uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) +uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) noexcept { const uint32_t mask = (enabled) ? 0xFFFFFFFF : ~(TMC_RR_OLA | TMC_RR_OLB); bitsToKeep &= mask; @@ -746,7 +746,7 @@ uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) } // Append the driver status to a string, and reset the min/max load values -void TmcDriverState::AppendDriverStatus(const StringRef& reply) +void TmcDriverState::AppendDriverStatus(const StringRef& reply) noexcept { const uint32_t lastReadStatus = readRegisters[ReadDrvStat]; if (lastReadStatus & TMC_RR_OT) @@ -783,7 +783,7 @@ void TmcDriverState::AppendDriverStatus(const StringRef& reply) } // This is called by the ISR when the SPI transfer has completed -inline void TmcDriverState::TransferDone() +inline void TmcDriverState::TransferDone() noexcept { Cache::InvalidateAfterDMAReceive(receiveData, sizeof(receiveData)); if (sendData[2] & 0x80) // if we were writing a register @@ -836,7 +836,7 @@ inline void TmcDriverState::TransferDone() } // This is called to abandon the current transfer, if any -void TmcDriverState::AbortTransfer() +void TmcDriverState::AbortTransfer() noexcept { uart->UART_IDR = UART_IDR_ENDRX; // disable end-of-receive interrupt uart_get_pdc_base(uart)->PERIPH_PTCR = (PERIPH_PTCR_RXTDIS | PERIPH_PTCR_TXTDIS); // disable the PDC @@ -846,7 +846,7 @@ void TmcDriverState::AbortTransfer() #if TMC22xx_HAS_MUX // Set up the UART multiplexer to address the selected driver -inline void TmcDriverState::SetUartMux() +inline void TmcDriverState::SetUartMux() noexcept { if ((driverNumber & 0x01) != 0) { @@ -877,7 +877,7 @@ inline void TmcDriverState::SetUartMux() #endif // This is called from the ISR or elsewhere to start a new SPI transfer. Inlined for ISR speed. -inline void TmcDriverState::StartTransfer() +inline void TmcDriverState::StartTransfer() noexcept { currentDriver = this; @@ -918,7 +918,7 @@ inline void TmcDriverState::StartTransfer() // ISR(s) for the UART(s) -inline void TmcDriverState::UartTmcHandler() +inline void TmcDriverState::UartTmcHandler() noexcept { uart->UART_IDR = UART_IDR_ENDRX; // disable the PDC interrupt TransferDone(); // tidy up after the transfer we just completed @@ -946,9 +946,9 @@ inline void TmcDriverState::UartTmcHandler() #endif // ISR for the single UART -extern "C" void TMC22xx_UART_Handler() __attribute__ ((hot)); +extern "C" void TMC22xx_UART_Handler() noexcept __attribute__ ((hot)); -void TMC22xx_UART_Handler() +void TMC22xx_UART_Handler() noexcept { UART_TMC22xx->UART_IDR = UART_IDR_ENDRX; // disable the interrupt TmcDriverState *driver = TmcDriverState::currentDriver; // capture volatile variable @@ -961,14 +961,14 @@ void TMC22xx_UART_Handler() #else // ISRs for the individual UARTs -extern "C" void UART_TMC_DRV0_Handler() __attribute__ ((hot)); -void UART_TMC_DRV0_Handler() +extern "C" void UART_TMC_DRV0_Handler() noexcept __attribute__ ((hot)); +void UART_TMC_DRV0_Handler() noexcept { driverStates[0].UartTmcHandler(); } -extern "C" void UART_TMC_DRV1_Handler() __attribute__ ((hot)); -void UART_TMC_DRV1_Handler() +extern "C" void UART_TMC_DRV1_Handler() noexcept __attribute__ ((hot)); +void UART_TMC_DRV1_Handler() noexcept { driverStates[1].UartTmcHandler(); } @@ -981,7 +981,7 @@ namespace SmartDrivers { // Initialise the driver interface and the drivers, leaving each drive disabled. // It is assumed that the drivers are not powered, so driversPowered(true) must be called after calling this before the motors can be moved. - void Init(const Pin driverSelectPins[NumDirectDrivers], size_t numTmcDrivers) + void Init(const Pin driverSelectPins[NumDirectDrivers], size_t numTmcDrivers) noexcept { numTmc22xxDrivers = min<size_t>(numTmcDrivers, MaxSmartDrivers); @@ -1034,7 +1034,7 @@ namespace SmartDrivers } // Shut down the drivers and stop any related interrupts. Don't call Spin() again after calling this as it may re-enable them. - void Exit() + void Exit() noexcept { pinMode(GlobalTmc22xxEnablePin, OUTPUT_HIGH); #if TMC22xx_HAS_MUX @@ -1048,7 +1048,7 @@ namespace SmartDrivers driversState = DriversState::noPower; } - void SetAxisNumber(size_t drive, uint32_t axisNumber) + void SetAxisNumber(size_t drive, uint32_t axisNumber) noexcept { if (drive < numTmc22xxDrivers) { @@ -1056,12 +1056,12 @@ namespace SmartDrivers } } - uint32_t GetAxisNumber(size_t drive) + uint32_t GetAxisNumber(size_t drive) noexcept { return (drive < numTmc22xxDrivers) ? driverStates[drive].GetAxisNumber() : 0; } - void SetCurrent(size_t drive, float current) + void SetCurrent(size_t drive, float current) noexcept { if (drive < numTmc22xxDrivers) { @@ -1069,7 +1069,7 @@ namespace SmartDrivers } } - void EnableDrive(size_t drive, bool en) + void EnableDrive(size_t drive, bool en) noexcept { if (drive < numTmc22xxDrivers) { @@ -1077,18 +1077,18 @@ namespace SmartDrivers } } - uint32_t GetLiveStatus(size_t drive) + uint32_t GetLiveStatus(size_t drive) noexcept { return (drive < numTmc22xxDrivers) ? driverStates[drive].ReadLiveStatus() : 0; } - uint32_t GetAccumulatedStatus(size_t drive, uint32_t bitsToKeep) + uint32_t GetAccumulatedStatus(size_t drive, uint32_t bitsToKeep) noexcept { return (drive < numTmc22xxDrivers) ? driverStates[drive].ReadAccumulatedStatus(bitsToKeep) : 0; } // Set microstepping or chopper control register - bool SetMicrostepping(size_t drive, unsigned int microsteps, bool interpolate) + bool SetMicrostepping(size_t drive, unsigned int microsteps, bool interpolate) noexcept { if (drive < numTmc22xxDrivers && microsteps > 0) { @@ -1110,24 +1110,24 @@ namespace SmartDrivers } // Get microstepping or chopper control register - unsigned int GetMicrostepping(size_t drive, bool& interpolation) + unsigned int GetMicrostepping(size_t drive, bool& interpolation) noexcept { return (drive < numTmc22xxDrivers) ? driverStates[drive].GetMicrostepping(interpolation) : 1; } - bool SetDriverMode(size_t driver, unsigned int mode) + bool SetDriverMode(size_t driver, unsigned int mode) noexcept { return driver < numTmc22xxDrivers && driverStates[driver].SetDriverMode(mode); } - DriverMode GetDriverMode(size_t driver) + DriverMode GetDriverMode(size_t driver) noexcept { return (driver < numTmc22xxDrivers) ? driverStates[driver].GetDriverMode() : DriverMode::unknown; } // Flag that the the drivers have been powered up or down and handle any timeouts // Before the first call to this function with 'powered' true, you must call Init() - void Spin(bool powered) + void Spin(bool powered) noexcept { if (driversState == DriversState::noPower) { @@ -1204,13 +1204,13 @@ namespace SmartDrivers } // This is called from the tick ISR, possibly while Spin (with powered either true or false) is being executed - void TurnDriversOff() + void TurnDriversOff() noexcept { // When using TMC2660 drivers, this is called when an over-voltage event occurs, so that we can try to protect the drivers by disabling them. // We don't use it with TMC22xx drivers. } - void AppendDriverStatus(size_t drive, const StringRef& reply) + void AppendDriverStatus(size_t drive, const StringRef& reply) noexcept { if (drive < numTmc22xxDrivers) { @@ -1218,12 +1218,12 @@ namespace SmartDrivers } } - float GetStandstillCurrentPercent(size_t drive) + float GetStandstillCurrentPercent(size_t drive) noexcept { return (drive < numTmc22xxDrivers) ? driverStates[drive].GetStandstillCurrentPercent() : 0.0; } - void SetStandstillCurrentPercent(size_t drive, float percent) + void SetStandstillCurrentPercent(size_t drive, float percent) noexcept { if (drive < numTmc22xxDrivers) { @@ -1231,12 +1231,12 @@ namespace SmartDrivers } } - bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) + bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) noexcept { return (driver < numTmc22xxDrivers) && driverStates[driver].SetRegister(reg, regVal); } - uint32_t GetRegister(size_t driver, SmartDriverRegister reg) + uint32_t GetRegister(size_t driver, SmartDriverRegister reg) noexcept { return (driver < numTmc22xxDrivers) ? driverStates[driver].GetRegister(reg) : 0; } diff --git a/src/Movement/StepperDrivers/TMC22xx.h b/src/Movement/StepperDrivers/TMC22xx.h index 566c5806..4c0e753d 100644 --- a/src/Movement/StepperDrivers/TMC22xx.h +++ b/src/Movement/StepperDrivers/TMC22xx.h @@ -36,26 +36,26 @@ const uint32_t TMC_RR_TEMPBITS = 15 << 8; // all temperature threshold bits namespace SmartDrivers { - void Init(const Pin[NumDirectDrivers], size_t numTmcDrivers) + void Init(const Pin[NumDirectDrivers], size_t numTmcDrivers) noexcept pre(numTmcDrivers <= NumDirectDrivers); - void Exit(); - void SetAxisNumber(size_t drive, uint32_t axisNumber); - uint32_t GetAxisNumber(size_t drive); - void SetCurrent(size_t drive, float current); - void EnableDrive(size_t drive, bool en); - uint32_t GetLiveStatus(size_t drive); - uint32_t GetAccumulatedStatus(size_t drive, uint32_t bitsToKeep); - bool SetMicrostepping(size_t drive, unsigned int microsteps, bool interpolation); - unsigned int GetMicrostepping(size_t drive, bool& interpolation); - bool SetDriverMode(size_t driver, unsigned int mode); - DriverMode GetDriverMode(size_t driver); - void Spin(bool powered); - void TurnDriversOff(); - void AppendDriverStatus(size_t drive, const StringRef& reply); - float GetStandstillCurrentPercent(size_t drive); - void SetStandstillCurrentPercent(size_t drive, float percent); - bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal); - uint32_t GetRegister(size_t driver, SmartDriverRegister reg); + void Exit() noexcept; + void SetAxisNumber(size_t drive, uint32_t axisNumber) noexcept; + uint32_t GetAxisNumber(size_t drive) noexcept; + void SetCurrent(size_t drive, float current) noexcept; + void EnableDrive(size_t drive, bool en) noexcept; + uint32_t GetLiveStatus(size_t drive) noexcept; + uint32_t GetAccumulatedStatus(size_t drive, uint32_t bitsToKeep) noexcept; + bool SetMicrostepping(size_t drive, unsigned int microsteps, bool interpolation) noexcept; + unsigned int GetMicrostepping(size_t drive, bool& interpolation) noexcept; + bool SetDriverMode(size_t driver, unsigned int mode) noexcept; + DriverMode GetDriverMode(size_t driver) noexcept; + void Spin(bool powered) noexcept; + void TurnDriversOff() noexcept; + void AppendDriverStatus(size_t drive, const StringRef& reply) noexcept; + float GetStandstillCurrentPercent(size_t drive) noexcept; + void SetStandstillCurrentPercent(size_t drive, float percent) noexcept; + bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) noexcept; + uint32_t GetRegister(size_t driver, SmartDriverRegister reg) noexcept; }; #endif diff --git a/src/Movement/StepperDrivers/TMC2660.cpp b/src/Movement/StepperDrivers/TMC2660.cpp index 9f551ccd..fc85a64d 100644 --- a/src/Movement/StepperDrivers/TMC2660.cpp +++ b/src/Movement/StepperDrivers/TMC2660.cpp @@ -183,7 +183,7 @@ const uint32_t defaultSmartEnReg = // Private types and methods // Convert a required motor current to the CS bits in the SGCSCONF register -static inline constexpr uint32_t CurrentToCsBits(float current) +static inline constexpr uint32_t CurrentToCsBits(float current) noexcept { // The current sense resistor on the production Duet WiFi is 0.051 ohms. // This gives us a range of 101mA to 3.236A in 101mA steps in the high sensitivity range (VSENSE = 1) @@ -196,44 +196,44 @@ constexpr uint32_t MinimumOpenLoadCsBits = CurrentToCsBits(MinimumOpenLoadMotorC class TmcDriverState { public: - void Init(uint32_t driverNumber, uint32_t p_pin); - void SetAxisNumber(size_t p_axisNumber); - void WriteAll(); - - bool SetMicrostepping(uint32_t shift, bool interpolate); - unsigned int GetMicrostepping(bool& interpolation) const; // Get microstepping - bool SetDriverMode(unsigned int mode); - DriverMode GetDriverMode() const; - void SetCurrent(float current); - void Enable(bool en); - void UpdateChopConfRegister(); - void SetStallDetectThreshold(int sgThreshold); - void SetStallDetectFilter(bool sgFilter); - void SetStallMinimumStepsPerSecond(unsigned int stepsPerSecond); - void AppendStallConfig(const StringRef& reply) const; - void AppendDriverStatus(const StringRef& reply); - - bool SetRegister(SmartDriverRegister reg, uint32_t regVal); - uint32_t GetRegister(SmartDriverRegister reg) const; - - void TransferDone() __attribute__ ((hot)); // called by the ISR when the SPI transfer has completed - void StartTransfer() __attribute__ ((hot)); // called to start a transfer - - uint32_t ReadLiveStatus() const; - uint32_t ReadAccumulatedStatus(uint32_t bitsToKeep); - - uint32_t ReadMicrostepPosition() const { return mstepPosition; } + void Init(uint32_t driverNumber, uint32_t p_pin) noexcept; + void SetAxisNumber(size_t p_axisNumber) noexcept; + void WriteAll() noexcept; + + bool SetMicrostepping(uint32_t shift, bool interpolate) noexcept; + unsigned int GetMicrostepping(bool& interpolation) const noexcept; + bool SetDriverMode(unsigned int mode) noexcept; + DriverMode GetDriverMode() const noexcept; + void SetCurrent(float current) noexcept; + void Enable(bool en) noexcept; + void UpdateChopConfRegister() noexcept; + void SetStallDetectThreshold(int sgThreshold) noexcept; + void SetStallDetectFilter(bool sgFilter) noexcept; + void SetStallMinimumStepsPerSecond(unsigned int stepsPerSecond) noexcept; + void AppendStallConfig(const StringRef& reply) const noexcept; + void AppendDriverStatus(const StringRef& reply) noexcept; + + bool SetRegister(SmartDriverRegister reg, uint32_t regVal) noexcept; + uint32_t GetRegister(SmartDriverRegister reg) const noexcept; + + void TransferDone() noexcept __attribute__ ((hot)); // called by the ISR when the SPI transfer has completed + void StartTransfer() noexcept __attribute__ ((hot)); // called to start a transfer + + uint32_t ReadLiveStatus() const noexcept; + uint32_t ReadAccumulatedStatus(uint32_t bitsToKeep) noexcept; + + uint32_t ReadMicrostepPosition() const noexcept { return mstepPosition; } private: - bool SetChopConf(uint32_t newVal); + bool SetChopConf(uint32_t newVal) noexcept; - void ResetLoadRegisters() + void ResetLoadRegisters() noexcept { minSgLoadRegister = 1023; maxSgLoadRegister = 0; } - static void SetupDMA(uint32_t outVal) __attribute__ ((hot)); // set up the PDC to send a register and receive the status + static void SetupDMA(uint32_t outVal) noexcept __attribute__ ((hot)); // set up the PDC to send a register and receive the status static constexpr unsigned int NumRegisters = 5; // the number of registers that we write to volatile uint32_t registers[NumRegisters]; // the values we want the TMC2660 writable registers to have @@ -285,7 +285,7 @@ volatile static uint32_t spiDataIn = 0; // volatile because the PDC writes static TmcDriverState * volatile currentDriver = nullptr; // volatile because the ISR changes it // Set up the PDC to send a register and receive the status -/*static*/ inline void TmcDriverState::SetupDMA(uint32_t outVal) +/*static*/ inline void TmcDriverState::SetupDMA(uint32_t outVal) noexcept { #if SAME70 /* From the data sheet: @@ -397,7 +397,7 @@ static TmcDriverState * volatile currentDriver = nullptr; // volatile because th } // Initialise the state of the driver and its CS pin -void TmcDriverState::Init(uint32_t driverNumber, uint32_t p_pin) +void TmcDriverState::Init(uint32_t driverNumber, uint32_t p_pin) noexcept pre(!driversPowered) { axisNumber = driverNumber; // assume straight through mapping at initialisation @@ -422,18 +422,18 @@ pre(!driversPowered) SetStallMinimumStepsPerSecond(DefaultMinimumStepsPerSecond); } -inline void TmcDriverState::SetAxisNumber(size_t p_axisNumber) +inline void TmcDriverState::SetAxisNumber(size_t p_axisNumber) noexcept { axisNumber = p_axisNumber; } // Write all registers. This is called when the drivers are known to be powered up. -inline void TmcDriverState::WriteAll() +inline void TmcDriverState::WriteAll() noexcept { registersToUpdate = UpdateAllRegisters; } -bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) +bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) noexcept { switch(reg) { @@ -466,7 +466,7 @@ bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) } } -uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const +uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const noexcept { switch(reg) { @@ -501,7 +501,7 @@ uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const } // Check the new chopper control register, update it and return true if it is legal -bool TmcDriverState::SetChopConf(uint32_t newVal) +bool TmcDriverState::SetChopConf(uint32_t newVal) noexcept { // TOFF = 0 turns the driver off so it is not allowed. // TOFF = 1 is not allowed if TBL = 0. @@ -525,7 +525,7 @@ bool TmcDriverState::SetChopConf(uint32_t newVal) } // Set the driver mode -bool TmcDriverState::SetDriverMode(unsigned int mode) +bool TmcDriverState::SetDriverMode(unsigned int mode) noexcept { switch (mode) { @@ -544,7 +544,7 @@ bool TmcDriverState::SetDriverMode(unsigned int mode) } // Get the driver mode -DriverMode TmcDriverState::GetDriverMode() const +DriverMode TmcDriverState::GetDriverMode() const noexcept { return ((configuredChopConfReg & TMC_CHOPCONF_CHM) == 0) ? DriverMode::spreadCycle : ((configuredChopConfReg & TMC_CHOPCONF_RNDTF) == 0) ? DriverMode::constantOffTime @@ -552,7 +552,7 @@ DriverMode TmcDriverState::GetDriverMode() const } // Set the microstepping and microstep interpolation. The desired microstepping is (1 << shift). -bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) +bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) noexcept { microstepShiftFactor = shift; uint32_t drvCtrlReg = registers[DriveControl] & ~TMC_DRVCTRL_MRES_MASK; @@ -571,7 +571,7 @@ bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) } // Set the motor current -void TmcDriverState::SetCurrent(float current) +void TmcDriverState::SetCurrent(float current) noexcept { const uint32_t csBits = CurrentToCsBits(current); registers[StallGuardConfig] = (registers[StallGuardConfig] & ~TMC_SGCSCONF_CS_MASK) | TMC_SGCSCONF_CS(csBits); @@ -579,7 +579,7 @@ void TmcDriverState::SetCurrent(float current) } // Enable or disable the driver -void TmcDriverState::Enable(bool en) +void TmcDriverState::Enable(bool en) noexcept { if (enabled != en) { @@ -606,21 +606,21 @@ void TmcDriverState::Enable(bool en) } } -void TmcDriverState::UpdateChopConfRegister() +void TmcDriverState::UpdateChopConfRegister() noexcept { registers[ChopperControl] = (enabled) ? configuredChopConfReg : (configuredChopConfReg & ~TMC_CHOPCONF_TOFF_MASK); registersToUpdate |= (1u << ChopperControl); } // Read the status -inline uint32_t TmcDriverState::ReadLiveStatus() const +inline uint32_t TmcDriverState::ReadLiveStatus() const noexcept { const uint32_t ret = lastReadStatus & (TMC_RR_SG | TMC_RR_OT | TMC_RR_OTPW | TMC_RR_S2G | TMC_RR_OLA | TMC_RR_OLB | TMC_RR_STST); return (enabled) ? ret : ret & ~(TMC_RR_SG | TMC_RR_OLA | TMC_RR_OLB); } // Read the status -uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) +uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) noexcept { const uint32_t mask = (enabled) ? 0xFFFFFFFF : ~(TMC_RR_SG | TMC_RR_OLA | TMC_RR_OLB); bitsToKeep &= mask; @@ -631,14 +631,14 @@ uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) return status & (TMC_RR_SG | TMC_RR_OT | TMC_RR_OTPW | TMC_RR_S2G | TMC_RR_OLA | TMC_RR_OLB | TMC_RR_STST) & mask; } -void TmcDriverState::SetStallDetectThreshold(int sgThreshold) +void TmcDriverState::SetStallDetectThreshold(int sgThreshold) noexcept { const uint32_t sgVal = ((uint32_t)constrain<int>(sgThreshold, -64, 63)) & 127; registers[StallGuardConfig] = (registers[StallGuardConfig] & ~TMC_SGCSCONF_SGT_MASK) | (sgVal << TMC_SGCSCONF_SGT_SHIFT); registersToUpdate |= 1u << StallGuardConfig; } -void TmcDriverState::SetStallDetectFilter(bool sgFilter) +void TmcDriverState::SetStallDetectFilter(bool sgFilter) noexcept { if (sgFilter) { @@ -651,12 +651,12 @@ void TmcDriverState::SetStallDetectFilter(bool sgFilter) registersToUpdate |= 1u << StallGuardConfig; } -void TmcDriverState::SetStallMinimumStepsPerSecond(unsigned int stepsPerSecond) +void TmcDriverState::SetStallMinimumStepsPerSecond(unsigned int stepsPerSecond) noexcept { maxStallStepInterval = StepTimer::StepClockRate/max<unsigned int>(stepsPerSecond, 1); } -void TmcDriverState::AppendStallConfig(const StringRef& reply) const +void TmcDriverState::AppendStallConfig(const StringRef& reply) const noexcept { const bool filtered = ((registers[StallGuardConfig] & TMC_SGCSCONF_SGT_SFILT) != 0); int threshold = (int)((registers[StallGuardConfig] & TMC_SGCSCONF_SGT_MASK) >> TMC_SGCSCONF_SGT_SHIFT); @@ -669,7 +669,7 @@ void TmcDriverState::AppendStallConfig(const StringRef& reply) const } // Append the driver status to a string, and reset the min/max load values -void TmcDriverState::AppendDriverStatus(const StringRef& reply) +void TmcDriverState::AppendDriverStatus(const StringRef& reply) noexcept { if (lastReadStatus & TMC_RR_OT) { @@ -712,14 +712,14 @@ void TmcDriverState::AppendDriverStatus(const StringRef& reply) } // Get microstepping -unsigned int TmcDriverState::GetMicrostepping(bool& interpolation) const +unsigned int TmcDriverState::GetMicrostepping(bool& interpolation) const noexcept { interpolation = (registers[DriveControl] & TMC_DRVCTRL_INTPOL) != 0; return 1u << microstepShiftFactor; } // This is called by the ISR when the SPI transfer has completed -inline void TmcDriverState::TransferDone() +inline void TmcDriverState::TransferDone() noexcept { fastDigitalWriteHigh(pin); // set the CS pin high for the driver we just polled if (driversPowered) // if the power is still good, update the status @@ -770,7 +770,7 @@ inline void TmcDriverState::TransferDone() } // This is called from the ISR or elsewhere to start a new SPI transfer. Inlined for ISR speed. -inline void TmcDriverState::StartTransfer() +inline void TmcDriverState::StartTransfer() noexcept { currentDriver = this; @@ -865,7 +865,7 @@ namespace SmartDrivers { // Initialise the driver interface and the drivers, leaving each drive disabled. // It is assumed that the drivers are not powered, so driversPowered(true) must be called after calling this before the motors can be moved. - void Init(const Pin driverSelectPins[NumDirectDrivers], size_t numTmcDrivers) + void Init(const Pin driverSelectPins[NumDirectDrivers], size_t numTmcDrivers) noexcept { numTmc2660Drivers = min<size_t>(numTmcDrivers, MaxSmartDrivers); @@ -930,14 +930,14 @@ namespace SmartDrivers } // Shut down the drivers and stop any related interrupts. Don't call Spin() again after calling this as it may re-enable them. - void Exit() + void Exit() noexcept { digitalWrite(GlobalTmc2660EnablePin, HIGH); NVIC_DisableIRQ(TMC2660_SPI_IRQn); driversPowered = false; } - void SetAxisNumber(size_t driver, uint32_t axisNumber) + void SetAxisNumber(size_t driver, uint32_t axisNumber) noexcept { if (driver < numTmc2660Drivers) { @@ -945,7 +945,7 @@ namespace SmartDrivers } } - void SetCurrent(size_t driver, float current) + void SetCurrent(size_t driver, float current) noexcept { if (driver < numTmc2660Drivers) { @@ -953,7 +953,7 @@ namespace SmartDrivers } } - void EnableDrive(size_t driver, bool en) + void EnableDrive(size_t driver, bool en) noexcept { if (driver < numTmc2660Drivers) { @@ -961,18 +961,18 @@ namespace SmartDrivers } } - uint32_t GetLiveStatus(size_t driver) + uint32_t GetLiveStatus(size_t driver) noexcept { return (driver < numTmc2660Drivers) ? driverStates[driver].ReadLiveStatus() : 0; } - uint32_t GetAccumulatedStatus(size_t driver, uint32_t bitsToKeep) + uint32_t GetAccumulatedStatus(size_t driver, uint32_t bitsToKeep) noexcept { return (driver < numTmc2660Drivers) ? driverStates[driver].ReadAccumulatedStatus(bitsToKeep) : 0; } // Set microstepping and microstep interpolation - bool SetMicrostepping(size_t driver, unsigned int microsteps, bool interpolate) + bool SetMicrostepping(size_t driver, unsigned int microsteps, bool interpolate) noexcept { if (driver < numTmc2660Drivers && microsteps > 0) { @@ -994,7 +994,7 @@ namespace SmartDrivers } // Get microstepping and interpolation - unsigned int GetMicrostepping(size_t driver, bool& interpolation) + unsigned int GetMicrostepping(size_t driver, bool& interpolation) noexcept { if (driver < numTmc2660Drivers) { @@ -1004,19 +1004,19 @@ namespace SmartDrivers return 1; } - bool SetDriverMode(size_t driver, unsigned int mode) + bool SetDriverMode(size_t driver, unsigned int mode) noexcept { return driver < numTmc2660Drivers && driverStates[driver].SetDriverMode(mode); } - DriverMode GetDriverMode(size_t driver) + DriverMode GetDriverMode(size_t driver) noexcept { return (driver < numTmc2660Drivers) ? driverStates[driver].GetDriverMode() : DriverMode::unknown; } // Flag the the drivers have been powered up. // Before the first call to this function with powered true, you must call Init(). - void Spin(bool powered) + void Spin(bool powered) noexcept { const bool wasPowered = driversPowered; driversPowered = powered; @@ -1049,14 +1049,14 @@ namespace SmartDrivers } // This is called from the tick ISR, possibly while Spin (with powered either true or false) is being executed - void TurnDriversOff() + void TurnDriversOff() noexcept { digitalWrite(GlobalTmc2660EnablePin, HIGH); // disable the drivers driversPowered = false; EndstopOrZProbe::UpdateStalledDrivers(LowestNBits<DriversBitmap>(MaxSmartDrivers), false); } - void SetStallThreshold(size_t driver, int sgThreshold) + void SetStallThreshold(size_t driver, int sgThreshold) noexcept { if (driver < numTmc2660Drivers) { @@ -1064,7 +1064,7 @@ namespace SmartDrivers } } - void SetStallFilter(size_t driver, bool sgFilter) + void SetStallFilter(size_t driver, bool sgFilter) noexcept { if (driver < numTmc2660Drivers) { @@ -1072,7 +1072,7 @@ namespace SmartDrivers } } - void SetStallMinimumStepsPerSecond(size_t driver, unsigned int stepsPerSecond) + void SetStallMinimumStepsPerSecond(size_t driver, unsigned int stepsPerSecond) noexcept { if (driver < numTmc2660Drivers) { @@ -1080,7 +1080,7 @@ namespace SmartDrivers } } - void AppendStallConfig(size_t driver, const StringRef& reply) + void AppendStallConfig(size_t driver, const StringRef& reply) noexcept { if (driver < numTmc2660Drivers) { @@ -1088,7 +1088,7 @@ namespace SmartDrivers } } - void AppendDriverStatus(size_t driver, const StringRef& reply) + void AppendDriverStatus(size_t driver, const StringRef& reply) noexcept { if (driver < numTmc2660Drivers) { @@ -1096,22 +1096,22 @@ namespace SmartDrivers } } - float GetStandstillCurrentPercent(size_t driver) + float GetStandstillCurrentPercent(size_t driver) noexcept { return 100.0; // not supported } - void SetStandstillCurrentPercent(size_t driver, float percent) + void SetStandstillCurrentPercent(size_t driver, float percent) noexcept { // not supported so nothing to see here } - bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) + bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) noexcept { return (driver < numTmc2660Drivers) && driverStates[driver].SetRegister(reg, regVal); } - uint32_t GetRegister(size_t driver, SmartDriverRegister reg) + uint32_t GetRegister(size_t driver, SmartDriverRegister reg) noexcept { return (driver < numTmc2660Drivers) ? driverStates[driver].GetRegister(reg) : 0; } diff --git a/src/Movement/StepperDrivers/TMC2660.h b/src/Movement/StepperDrivers/TMC2660.h index 4878aa2d..7a51bd07 100644 --- a/src/Movement/StepperDrivers/TMC2660.h +++ b/src/Movement/StepperDrivers/TMC2660.h @@ -26,30 +26,30 @@ const uint32_t TMC_RR_STST = 1 << 7; // standstill detected namespace SmartDrivers { - void Init(const Pin[NumDirectDrivers], size_t numTmcDrivers) + void Init(const Pin[NumDirectDrivers], size_t numTmcDrivers) noexcept pre(numTmcDrivers <= NumDirectDrivers); - void Exit(); - void Spin(bool powered); - void TurnDriversOff(); - - void SetAxisNumber(size_t driver, uint32_t axisNumber); - void SetCurrent(size_t driver, float current); - void EnableDrive(size_t driver, bool en); - uint32_t GetLiveStatus(size_t driver); - uint32_t GetAccumulatedStatus(size_t drive, uint32_t bitsToKeep); - bool SetMicrostepping(size_t drive, unsigned int microsteps, bool interpolation); - unsigned int GetMicrostepping(size_t drive, bool& interpolation); - bool SetDriverMode(size_t driver, unsigned int mode); - DriverMode GetDriverMode(size_t driver); - void SetStallThreshold(size_t driver, int sgThreshold); - void SetStallFilter(size_t driver, bool sgFilter); - void SetStallMinimumStepsPerSecond(size_t driver, unsigned int stepsPerSecond); - void AppendStallConfig(size_t driver, const StringRef& reply); - void AppendDriverStatus(size_t driver, const StringRef& reply); - float GetStandstillCurrentPercent(size_t driver); - void SetStandstillCurrentPercent(size_t driver, float percent); - bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal); - uint32_t GetRegister(size_t driver, SmartDriverRegister reg); + void Exit() noexcept; + void Spin(bool powered) noexcept; + void TurnDriversOff() noexcept; + + void SetAxisNumber(size_t driver, uint32_t axisNumber) noexcept; + void SetCurrent(size_t driver, float current) noexcept; + void EnableDrive(size_t driver, bool en) noexcept; + uint32_t GetLiveStatus(size_t driver) noexcept; + uint32_t GetAccumulatedStatus(size_t drive, uint32_t bitsToKeep) noexcept; + bool SetMicrostepping(size_t drive, unsigned int microsteps, bool interpolation) noexcept; + unsigned int GetMicrostepping(size_t drive, bool& interpolation) noexcept; + bool SetDriverMode(size_t driver, unsigned int mode) noexcept; + DriverMode GetDriverMode(size_t driver) noexcept; + void SetStallThreshold(size_t driver, int sgThreshold) noexcept; + void SetStallFilter(size_t driver, bool sgFilter) noexcept; + void SetStallMinimumStepsPerSecond(size_t driver, unsigned int stepsPerSecond) noexcept; + void AppendStallConfig(size_t driver, const StringRef& reply) noexcept; + void AppendDriverStatus(size_t driver, const StringRef& reply) noexcept; + float GetStandstillCurrentPercent(size_t driver) noexcept; + void SetStandstillCurrentPercent(size_t driver, float percent) noexcept; + bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) noexcept; + uint32_t GetRegister(size_t driver, SmartDriverRegister reg) noexcept; }; #endif diff --git a/src/Movement/StepperDrivers/TMC51xx.cpp b/src/Movement/StepperDrivers/TMC51xx.cpp index 60e0a30c..c60b8c08 100644 --- a/src/Movement/StepperDrivers/TMC51xx.cpp +++ b/src/Movement/StepperDrivers/TMC51xx.cpp @@ -25,12 +25,12 @@ # include <Hardware/Serial.h> # define SAME70 0 -static inline const Move& GetMoveInstance() { return *moveInstance; } +static inline const Move& GetMoveInstance() noexcept { return *moveInstance; } #elif SAME70 # define TMC51xx_USES_SERCOM 0 -static inline const Move& GetMoveInstance() { return reprap.GetMove(); } +static inline const Move& GetMoveInstance() noexcept { return reprap.GetMove(); } #endif @@ -270,45 +270,45 @@ static DriversState driversState = DriversState::noPower; class TmcDriverState { public: - void Init(uint32_t p_driverNumber); - void SetAxisNumber(size_t p_axisNumber); - uint32_t GetAxisNumber() const { return axisNumber; } - void WriteAll(); - bool SetMicrostepping(uint32_t shift, bool interpolate); - unsigned int GetMicrostepping(bool& interpolation) const; // Get microstepping - bool SetDriverMode(unsigned int mode); - DriverMode GetDriverMode() const; - void SetCurrent(float current); - void Enable(bool en); - void AppendDriverStatus(const StringRef& reply, bool clearGlobalStats); - bool UpdatePending() const { return (registersToUpdate | newRegistersToUpdate) != 0; } - void SetStallDetectThreshold(int sgThreshold); - void SetStallDetectFilter(bool sgFilter); - void SetStallMinimumStepsPerSecond(unsigned int stepsPerSecond); - void AppendStallConfig(const StringRef& reply) const; - - bool SetRegister(SmartDriverRegister reg, uint32_t regVal); - uint32_t GetRegister(SmartDriverRegister reg) const; - - float GetStandstillCurrentPercent() const; - void SetStandstillCurrentPercent(float percent); - - static void TransferTimedOut() { ++numTimeouts; } - - uint32_t ReadLiveStatus() const; - uint32_t ReadAccumulatedStatus(uint32_t bitsToKeep); - - void GetSpiCommand(uint8_t *sendDdataBlock); - void TransferSucceeded(const uint8_t *rcvDataBlock); - void TransferFailed(); + void Init(uint32_t p_driverNumber) noexcept; + void SetAxisNumber(size_t p_axisNumber) noexcept; + uint32_t GetAxisNumber() const noexcept { return axisNumber; } + void WriteAll() noexcept; + bool SetMicrostepping(uint32_t shift, bool interpolate) noexcept; + unsigned int GetMicrostepping(bool& interpolation) const noexcept; + bool SetDriverMode(unsigned int mode) noexcept; + DriverMode GetDriverMode() const noexcept; + void SetCurrent(float current) noexcept; + void Enable(bool en) noexcept; + void AppendDriverStatus(const StringRef& reply, bool clearGlobalStats) noexcept; + bool UpdatePending() const noexcept { return (registersToUpdate | newRegistersToUpdate) != 0; } + void SetStallDetectThreshold(int sgThreshold) noexcept; + void SetStallDetectFilter(bool sgFilter) noexcept; + void SetStallMinimumStepsPerSecond(unsigned int stepsPerSecond) noexcept; + void AppendStallConfig(const StringRef& reply) const noexcept; + + bool SetRegister(SmartDriverRegister reg, uint32_t regVal) noexcept; + uint32_t GetRegister(SmartDriverRegister reg) const noexcept; + + float GetStandstillCurrentPercent() const noexcept; + void SetStandstillCurrentPercent(float percent) noexcept; + + static void TransferTimedOut() noexcept { ++numTimeouts; } + + uint32_t ReadLiveStatus() const noexcept; + uint32_t ReadAccumulatedStatus(uint32_t bitsToKeep) noexcept; + + void GetSpiCommand(uint8_t *sendDdataBlock) noexcept; + void TransferSucceeded(const uint8_t *rcvDataBlock) noexcept; + void TransferFailed() noexcept; private: - bool SetChopConf(uint32_t newVal); - void UpdateRegister(size_t regIndex, uint32_t regVal); - void UpdateChopConfRegister(); // calculate the chopper control register and flag it for sending - void UpdateCurrent(); + bool SetChopConf(uint32_t newVal) noexcept; + void UpdateRegister(size_t regIndex, uint32_t regVal) noexcept; + void UpdateChopConfRegister() noexcept; // calculate the chopper control register and flag it for sending + void UpdateCurrent() noexcept; - void ResetLoadRegisters() + void ResetLoadRegisters() noexcept { minSgLoadRegister = 1023; maxSgLoadRegister = 0; @@ -400,7 +400,7 @@ const uint8_t TmcDriverState::ReadRegNumbers[NumReadRegisters] = uint16_t TmcDriverState::numTimeouts = 0; // how many times a transfer timed out // Initialise the state of the driver and its CS pin -void TmcDriverState::Init(uint32_t p_driverNumber) +void TmcDriverState::Init(uint32_t p_driverNumber) noexcept pre(!driversPowered) { axisNumber = p_driverNumber; // axes are mapped straight through to drivers initially @@ -438,49 +438,49 @@ pre(!driversPowered) } // Set a register value and flag it for updating -void TmcDriverState::UpdateRegister(size_t regIndex, uint32_t regVal) +void TmcDriverState::UpdateRegister(size_t regIndex, uint32_t regVal) noexcept { writeRegisters[regIndex] = regVal; newRegistersToUpdate |= (1u << regIndex); // flag it for sending } // Calculate the chopper control register and flag it for sending -void TmcDriverState::UpdateChopConfRegister() +void TmcDriverState::UpdateChopConfRegister() noexcept { UpdateRegister(WriteChopConf, (enabled) ? configuredChopConfReg : configuredChopConfReg & ~CHOPCONF_TOFF_MASK); } -void TmcDriverState::SetStallDetectThreshold(int sgThreshold) +void TmcDriverState::SetStallDetectThreshold(int sgThreshold) noexcept { const uint32_t sgVal = ((uint32_t)constrain<int>(sgThreshold, -64, 63)) & 127u; writeRegisters[WriteCoolConf] = (writeRegisters[WriteCoolConf] & ~COOLCONF_SGT_MASK) | (sgVal << COOLCONF_SGT_SHIFT); newRegistersToUpdate |= 1u << WriteCoolConf; } -inline void TmcDriverState::SetAxisNumber(size_t p_axisNumber) +inline void TmcDriverState::SetAxisNumber(size_t p_axisNumber) noexcept { axisNumber = p_axisNumber; } // Write all registers. This is called when the drivers are known to be powered up. -inline void TmcDriverState::WriteAll() +inline void TmcDriverState::WriteAll() noexcept { newRegistersToUpdate = (1u << NumWriteRegisters) - 1; } -float TmcDriverState::GetStandstillCurrentPercent() const +float TmcDriverState::GetStandstillCurrentPercent() const noexcept { return (float)(standstillCurrentFraction * 100)/256; } -void TmcDriverState::SetStandstillCurrentPercent(float percent) +void TmcDriverState::SetStandstillCurrentPercent(float percent) noexcept { standstillCurrentFraction = (uint8_t)constrain<long>(lrintf((percent * 256)/100), 0, 255); UpdateCurrent(); } // Set the microstepping and microstep interpolation. The desired microstepping is (1 << shift). -bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) +bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) noexcept { microstepShiftFactor = shift; configuredChopConfReg = (configuredChopConfReg & ~(CHOPCONF_MRES_MASK | CHOPCONF_INTPOL)) | ((8 - shift) << CHOPCONF_MRES_SHIFT); @@ -493,13 +493,13 @@ bool TmcDriverState::SetMicrostepping(uint32_t shift, bool interpolate) } // Get microstepping or chopper control register -unsigned int TmcDriverState::GetMicrostepping(bool& interpolation) const +unsigned int TmcDriverState::GetMicrostepping(bool& interpolation) const noexcept { interpolation = (writeRegisters[WriteChopConf] & CHOPCONF_INTPOL) != 0; return 1u << microstepShiftFactor; } -bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) +bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) noexcept { switch(reg) { @@ -536,7 +536,7 @@ bool TmcDriverState::SetRegister(SmartDriverRegister reg, uint32_t regVal) } } -uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const +uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const noexcept { switch(reg) { @@ -577,7 +577,7 @@ uint32_t TmcDriverState::GetRegister(SmartDriverRegister reg) const } // Set the chopper control register to the settings provided by the user. We allow only the lowest 17 bits to be set. -bool TmcDriverState::SetChopConf(uint32_t newVal) +bool TmcDriverState::SetChopConf(uint32_t newVal) noexcept { const uint32_t offTime = (newVal & CHOPCONF_TOFF_MASK) >> CHOPCONF_TOFF_SHIFT; if (offTime == 0 || (offTime == 1 && (newVal & CHOPCONF_TBL_MASK) < (2 << CHOPCONF_TBL_SHIFT))) @@ -597,7 +597,7 @@ bool TmcDriverState::SetChopConf(uint32_t newVal) } // Set the driver mode -bool TmcDriverState::SetDriverMode(unsigned int mode) +bool TmcDriverState::SetDriverMode(unsigned int mode) noexcept { switch (mode) { @@ -633,7 +633,7 @@ bool TmcDriverState::SetDriverMode(unsigned int mode) } // Get the driver mode -DriverMode TmcDriverState::GetDriverMode() const +DriverMode TmcDriverState::GetDriverMode() const noexcept { return ((writeRegisters[WriteGConf] & GCONF_STEALTHCHOP) != 0) ? DriverMode::stealthChop : ((writeRegisters[WriteChopConf] & CHOPCONF_CHM) == 0) ? DriverMode::spreadCycle @@ -644,13 +644,13 @@ DriverMode TmcDriverState::GetDriverMode() const } // Set the motor current -void TmcDriverState::SetCurrent(float current) +void TmcDriverState::SetCurrent(float current) noexcept { motorCurrent = static_cast<uint32_t>(constrain<float>(current, MinimumMotorCurrent, MaxTmc5160Current)); UpdateCurrent(); } -void TmcDriverState::UpdateCurrent() +void TmcDriverState::UpdateCurrent() noexcept { #if TMC_TYPE == 5130 // Assume a current sense resistor of 0.082 ohms, to which we must add 0.025 ohms internal resistance. @@ -688,7 +688,7 @@ void TmcDriverState::UpdateCurrent() } // Enable or disable the driver -void TmcDriverState::Enable(bool en) +void TmcDriverState::Enable(bool en) noexcept { if (enabled != en) { @@ -698,13 +698,13 @@ void TmcDriverState::Enable(bool en) } // Read the status -uint32_t TmcDriverState::ReadLiveStatus() const +uint32_t TmcDriverState::ReadLiveStatus() const noexcept { return readRegisters[ReadDrvStat] & (TMC_RR_SG | TMC_RR_OT | TMC_RR_OTPW | TMC_RR_S2G | TMC_RR_OLA | TMC_RR_OLB | TMC_RR_STST); } // Read the status -uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) +uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) noexcept { TaskCriticalSectionLocker lock; const uint32_t status = accumulatedReadRegisters[ReadDrvStat]; @@ -713,7 +713,7 @@ uint32_t TmcDriverState::ReadAccumulatedStatus(uint32_t bitsToKeep) } // Append the driver status to a string, and reset the min/max load values -void TmcDriverState::AppendDriverStatus(const StringRef& reply, bool clearGlobalStats) +void TmcDriverState::AppendDriverStatus(const StringRef& reply, bool clearGlobalStats) noexcept { const uint32_t lastReadStatus = readRegisters[ReadDrvStat]; if (lastReadStatus & TMC_RR_OT) @@ -763,7 +763,7 @@ void TmcDriverState::AppendDriverStatus(const StringRef& reply, bool clearGlobal ResetLoadRegisters(); } -void TmcDriverState::SetStallDetectFilter(bool sgFilter) +void TmcDriverState::SetStallDetectFilter(bool sgFilter) noexcept { if (sgFilter) { @@ -776,13 +776,13 @@ void TmcDriverState::SetStallDetectFilter(bool sgFilter) newRegistersToUpdate |= 1u << WriteCoolConf; } -void TmcDriverState::SetStallMinimumStepsPerSecond(unsigned int stepsPerSecond) +void TmcDriverState::SetStallMinimumStepsPerSecond(unsigned int stepsPerSecond) noexcept { //TODO use hardware facility instead maxStallStepInterval = StepTimer::StepClockRate/max<unsigned int>(stepsPerSecond, 1); } -void TmcDriverState::AppendStallConfig(const StringRef& reply) const +void TmcDriverState::AppendStallConfig(const StringRef& reply) const noexcept { const bool filtered = ((writeRegisters[WriteCoolConf] & COOLCONF_SGFILT) != 0); int threshold = (int)((writeRegisters[WriteCoolConf] & COOLCONF_SGT_MASK) >> COOLCONF_SGT_SHIFT); @@ -795,7 +795,7 @@ void TmcDriverState::AppendStallConfig(const StringRef& reply) const } // In the following, only byte accesses to sendDataBlock are allowed, because accesses to non-cacheable memory must be aligned -void TmcDriverState::GetSpiCommand(uint8_t *sendDataBlock) +void TmcDriverState::GetSpiCommand(uint8_t *sendDataBlock) noexcept { // Find which register to send. The common case is when no registers need to be updated. { @@ -825,7 +825,7 @@ void TmcDriverState::GetSpiCommand(uint8_t *sendDataBlock) } } -void TmcDriverState::TransferSucceeded(const uint8_t *rcvDataBlock) +void TmcDriverState::TransferSucceeded(const uint8_t *rcvDataBlock) noexcept { // If we wrote a register, mark it up to date if (regIndexBeingUpdated < NumWriteRegisters) @@ -902,7 +902,7 @@ void TmcDriverState::TransferSucceeded(const uint8_t *rcvDataBlock) previousRegIndexRequested = (regIndexBeingUpdated == NoRegIndex) ? regIndexRequested : NoRegIndex; } -void TmcDriverState::TransferFailed() +void TmcDriverState::TransferFailed() noexcept { regIndexRequested = previousRegIndexRequested = NoRegIndex; } @@ -918,7 +918,7 @@ static __nocache uint8_t sendData[5 * MaxSmartDrivers]; static __nocache uint8_t rcvData[5 * MaxSmartDrivers]; // Set up the PDC or DMAC to send a register and receive the status, but don't enable it yet -static void SetupDMA() +static void SetupDMA() noexcept { #if SAME70 /* From the data sheet: @@ -1019,7 +1019,7 @@ static void SetupDMA() #endif } -static inline void EnableDma() +static inline void EnableDma() noexcept { #if SAME70 xdmac_channel_enable(XDMAC, DmacChanTmcRx); @@ -1032,7 +1032,7 @@ static inline void EnableDma() #endif } -static inline void DisableDma() +static inline void DisableDma() noexcept { #if SAME70 xdmac_channel_disable(XDMAC, DmacChanTmcTx); @@ -1045,7 +1045,7 @@ static inline void DisableDma() #endif } -static inline void ResetSpi() +static inline void ResetSpi() noexcept { #if TMC51xx_USES_SERCOM hri_sercomspi_clear_CTRLA_ENABLE_bit(SERCOM_TMC51xx); // warning: this makes SCLK float! @@ -1057,7 +1057,7 @@ static inline void ResetSpi() #endif } -static inline void EnableSpi() +static inline void EnableSpi() noexcept { #if TMC51xx_USES_SERCOM hri_sercomspi_set_CTRLB_RXEN_bit(SERCOM_TMC51xx); @@ -1069,7 +1069,7 @@ static inline void EnableSpi() #endif } -static inline void DisableEndOfTransferInterrupt() +static inline void DisableEndOfTransferInterrupt() noexcept { #if SAME70 xdmac_channel_disable_interrupt(XDMAC, DmacChanTmcRx, XDMAC_CIE_BIE); @@ -1082,7 +1082,7 @@ static inline void DisableEndOfTransferInterrupt() #endif } -static inline void EnableEndOfTransferInterrupt() +static inline void EnableEndOfTransferInterrupt() noexcept { #if SAME70 xdmac_channel_enable_interrupt(XDMAC, DmacChanTmcRx, XDMAC_CIE_BIE); @@ -1096,7 +1096,7 @@ static inline void EnableEndOfTransferInterrupt() } // DMA complete callback -void RxDmaCompleteCallback(CallbackParameter param) +void RxDmaCompleteCallback(CallbackParameter param) noexcept { #if SAME70 xdmac_channel_disable_interrupt(XDMAC, DmacChanTmcRx, 0xFFFFFFFF); @@ -1105,7 +1105,7 @@ void RxDmaCompleteCallback(CallbackParameter param) tmcTask.GiveFromISR(); } -extern "C" [[noreturn]] void TmcLoop(void *) +extern "C" [[noreturn]] void TmcLoop(void *) noexcept { bool timedOut = true; for (;;) @@ -1208,7 +1208,7 @@ extern "C" [[noreturn]] void TmcLoop(void *) // Initialise the driver interface and the drivers, leaving each drive disabled. // It is assumed that the drivers are not powered, so driversPowered(true) must be called after calling this before the motors can be moved. -void SmartDrivers::Init() +void SmartDrivers::Init() noexcept { // Make sure the ENN and CS pins are high pinMode(GlobalTmc51xxEnablePin, OUTPUT_HIGH); @@ -1323,7 +1323,7 @@ void SmartDrivers::Init() } // Shut down the drivers and stop any related interrupts. Don't call Spin() again after calling this as it may re-enable them. -void SmartDrivers::Exit() +void SmartDrivers::Exit() noexcept { digitalWrite(GlobalTmc51xxEnablePin, HIGH); NVIC_DisableIRQ(TMC51xx_SPI_IRQn); @@ -1331,7 +1331,7 @@ void SmartDrivers::Exit() driversState = DriversState::noPower; } -void SmartDrivers::SetAxisNumber(size_t driver, uint32_t axisNumber) +void SmartDrivers::SetAxisNumber(size_t driver, uint32_t axisNumber) noexcept { if (driver < numTmc51xxDrivers) { @@ -1339,12 +1339,12 @@ void SmartDrivers::SetAxisNumber(size_t driver, uint32_t axisNumber) } } -uint32_t SmartDrivers::GetAxisNumber(size_t drive) +uint32_t SmartDrivers::GetAxisNumber(size_t drive) noexcept { return (drive < numTmc51xxDrivers) ? driverStates[drive].GetAxisNumber() : 0; } -void SmartDrivers::SetCurrent(size_t driver, float current) +void SmartDrivers::SetCurrent(size_t driver, float current) noexcept { if (driver < numTmc51xxDrivers) { @@ -1352,7 +1352,7 @@ void SmartDrivers::SetCurrent(size_t driver, float current) } } -void SmartDrivers::EnableDrive(size_t driver, bool en) +void SmartDrivers::EnableDrive(size_t driver, bool en) noexcept { if (driver < numTmc51xxDrivers) { @@ -1360,18 +1360,18 @@ void SmartDrivers::EnableDrive(size_t driver, bool en) } } -uint32_t SmartDrivers::GetLiveStatus(size_t driver) +uint32_t SmartDrivers::GetLiveStatus(size_t driver) noexcept { return (driver < numTmc51xxDrivers) ? driverStates[driver].ReadLiveStatus() : 0; } -uint32_t SmartDrivers::GetAccumulatedStatus(size_t driver, uint32_t bitsToKeep) +uint32_t SmartDrivers::GetAccumulatedStatus(size_t driver, uint32_t bitsToKeep) noexcept { return (driver < numTmc51xxDrivers) ? driverStates[driver].ReadAccumulatedStatus(bitsToKeep) : 0; } // Set microstepping and microstep interpolation -bool SmartDrivers::SetMicrostepping(size_t driver, unsigned int microsteps, bool interpolate) +bool SmartDrivers::SetMicrostepping(size_t driver, unsigned int microsteps, bool interpolate) noexcept { if (driver < numTmc51xxDrivers && microsteps > 0) { @@ -1393,7 +1393,7 @@ bool SmartDrivers::SetMicrostepping(size_t driver, unsigned int microsteps, bool } // Get microstepping and interpolation -unsigned int SmartDrivers::GetMicrostepping(size_t driver, bool& interpolation) +unsigned int SmartDrivers::GetMicrostepping(size_t driver, bool& interpolation) noexcept { if (driver < numTmc51xxDrivers) { @@ -1403,19 +1403,19 @@ unsigned int SmartDrivers::GetMicrostepping(size_t driver, bool& interpolation) return 1; } -bool SmartDrivers::SetDriverMode(size_t driver, unsigned int mode) +bool SmartDrivers::SetDriverMode(size_t driver, unsigned int mode) noexcept { return driver < numTmc51xxDrivers && driverStates[driver].SetDriverMode(mode); } -DriverMode SmartDrivers::GetDriverMode(size_t driver) +DriverMode SmartDrivers::GetDriverMode(size_t driver) noexcept { return (driver < numTmc51xxDrivers) ? driverStates[driver].GetDriverMode() : DriverMode::unknown; } // Flag that the the drivers have been powered up or down // Before the first call to this function with 'powered' true, you must call Init() -void SmartDrivers::Spin(bool powered) +void SmartDrivers::Spin(bool powered) noexcept { TaskCriticalSectionLocker lock; @@ -1435,13 +1435,13 @@ void SmartDrivers::Spin(bool powered) } // This is called from the tick ISR, possibly while Spin (with powered either true or false) is being executed -void SmartDrivers::TurnDriversOff() +void SmartDrivers::TurnDriversOff() noexcept { digitalWrite(GlobalTmc51xxEnablePin, true); // disable the drivers driversState = DriversState::noPower; } -void SmartDrivers::SetStallThreshold(size_t driver, int sgThreshold) +void SmartDrivers::SetStallThreshold(size_t driver, int sgThreshold) noexcept { if (driver < numTmc51xxDrivers) { @@ -1449,7 +1449,7 @@ void SmartDrivers::SetStallThreshold(size_t driver, int sgThreshold) } } -void SmartDrivers::SetStallFilter(size_t driver, bool sgFilter) +void SmartDrivers::SetStallFilter(size_t driver, bool sgFilter) noexcept { if (driver < numTmc51xxDrivers) { @@ -1457,7 +1457,7 @@ void SmartDrivers::SetStallFilter(size_t driver, bool sgFilter) } } -void SmartDrivers::SetStallMinimumStepsPerSecond(size_t driver, unsigned int stepsPerSecond) +void SmartDrivers::SetStallMinimumStepsPerSecond(size_t driver, unsigned int stepsPerSecond) noexcept { if (driver < numTmc51xxDrivers) { @@ -1465,7 +1465,7 @@ void SmartDrivers::SetStallMinimumStepsPerSecond(size_t driver, unsigned int ste } } -void SmartDrivers::AppendStallConfig(size_t driver, const StringRef& reply) +void SmartDrivers::AppendStallConfig(size_t driver, const StringRef& reply) noexcept { if (driver < numTmc51xxDrivers) { @@ -1473,7 +1473,7 @@ void SmartDrivers::AppendStallConfig(size_t driver, const StringRef& reply) } } -void SmartDrivers::AppendDriverStatus(size_t driver, const StringRef& reply) +void SmartDrivers::AppendDriverStatus(size_t driver, const StringRef& reply) noexcept { if (driver < numTmc51xxDrivers) { @@ -1481,12 +1481,12 @@ void SmartDrivers::AppendDriverStatus(size_t driver, const StringRef& reply) } } -float SmartDrivers::GetStandstillCurrentPercent(size_t driver) +float SmartDrivers::GetStandstillCurrentPercent(size_t driver) noexcept { return (driver < numTmc51xxDrivers) ? driverStates[driver].GetStandstillCurrentPercent() : 0.0; } -void SmartDrivers::SetStandstillCurrentPercent(size_t driver, float percent) +void SmartDrivers::SetStandstillCurrentPercent(size_t driver, float percent) noexcept { if (driver < numTmc51xxDrivers) { @@ -1494,12 +1494,12 @@ void SmartDrivers::SetStandstillCurrentPercent(size_t driver, float percent) } } -bool SmartDrivers::SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) +bool SmartDrivers::SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) noexcept { return (driver < numTmc51xxDrivers) && driverStates[driver].SetRegister(reg, regVal); } -uint32_t SmartDrivers::GetRegister(size_t driver, SmartDriverRegister reg) +uint32_t SmartDrivers::GetRegister(size_t driver, SmartDriverRegister reg) noexcept { return (driver < numTmc51xxDrivers) ? driverStates[driver].GetRegister(reg) : 0; } diff --git a/src/Movement/StepperDrivers/TMC51xx.h b/src/Movement/StepperDrivers/TMC51xx.h index cc2c454e..82aea738 100644 --- a/src/Movement/StepperDrivers/TMC51xx.h +++ b/src/Movement/StepperDrivers/TMC51xx.h @@ -26,30 +26,30 @@ const uint32_t TMC_RR_SGRESULT = 0x3FF; // 10-bit stallGuard2 result namespace SmartDrivers { - void Init(); - void Exit(); - void Spin(bool powered); - void TurnDriversOff(); - - void SetAxisNumber(size_t driver, uint32_t axisNumber); - uint32_t GetAxisNumber(size_t drive); - void SetCurrent(size_t driver, float current); - void EnableDrive(size_t driver, bool en); - uint32_t GetLiveStatus(size_t driver); - uint32_t GetAccumulatedStatus(size_t drive, uint32_t bitsToKeep); - bool SetMicrostepping(size_t drive, unsigned int microsteps, bool interpolation); - unsigned int GetMicrostepping(size_t drive, bool& interpolation); - bool SetDriverMode(size_t driver, unsigned int mode); - DriverMode GetDriverMode(size_t driver); - void SetStallThreshold(size_t driver, int sgThreshold); - void SetStallFilter(size_t driver, bool sgFilter); - void SetStallMinimumStepsPerSecond(size_t driver, unsigned int stepsPerSecond); - void AppendStallConfig(size_t driver, const StringRef& reply); - void AppendDriverStatus(size_t driver, const StringRef& reply); - float GetStandstillCurrentPercent(size_t driver); - void SetStandstillCurrentPercent(size_t driver, float percent); - bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal); - uint32_t GetRegister(size_t driver, SmartDriverRegister reg); + void Init() noexcept; + void Exit() noexcept; + void Spin(bool powered) noexcept; + void TurnDriversOff() noexcept; + + void SetAxisNumber(size_t driver, uint32_t axisNumber) noexcept; + uint32_t GetAxisNumber(size_t drive) noexcept; + void SetCurrent(size_t driver, float current) noexcept; + void EnableDrive(size_t driver, bool en) noexcept; + uint32_t GetLiveStatus(size_t driver) noexcept; + uint32_t GetAccumulatedStatus(size_t drive, uint32_t bitsToKeep) noexcept; + bool SetMicrostepping(size_t drive, unsigned int microsteps, bool interpolation) noexcept; + unsigned int GetMicrostepping(size_t drive, bool& interpolation) noexcept; + bool SetDriverMode(size_t driver, unsigned int mode) noexcept; + DriverMode GetDriverMode(size_t driver) noexcept; + void SetStallThreshold(size_t driver, int sgThreshold) noexcept; + void SetStallFilter(size_t driver, bool sgFilter) noexcept; + void SetStallMinimumStepsPerSecond(size_t driver, unsigned int stepsPerSecond) noexcept; + void AppendStallConfig(size_t driver, const StringRef& reply) noexcept; + void AppendDriverStatus(size_t driver, const StringRef& reply) noexcept; + float GetStandstillCurrentPercent(size_t driver) noexcept; + void SetStandstillCurrentPercent(size_t driver, float percent) noexcept; + bool SetRegister(size_t driver, SmartDriverRegister reg, uint32_t regVal) noexcept; + uint32_t GetRegister(size_t driver, SmartDriverRegister reg) noexcept; }; #endif diff --git a/src/Networking/LwipEthernet/GMAC/ethernet_sam.cpp b/src/Networking/LwipEthernet/GMAC/ethernet_sam.cpp index e706a153..d4301e93 100644 --- a/src/Networking/LwipEthernet/GMAC/ethernet_sam.cpp +++ b/src/Networking/LwipEthernet/GMAC/ethernet_sam.cpp @@ -89,14 +89,14 @@ static timers_info_t gs_timers_table[] = { #endif }; -extern uint32_t millis(); +extern uint32_t millis() noexcept; } // end extern "C" /** * \brief Process timing functions. */ -void ethernet_timers_update(void) +void ethernet_timers_update(void) noexcept { static uint32_t ul_last_time; uint32_t ul_cur_time, ul_time_diff, ul_idx_timer; @@ -127,7 +127,7 @@ void ethernet_timers_update(void) //************************************************************************************************************ // This sets the static IP configuration on-the-fly -void ethernet_set_configuration(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay) +void ethernet_set_configuration(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay) noexcept { ip4_addr_t x_ip_addr, x_net_mask, x_gateway; x_ip_addr.addr = ipAddress.GetV4LittleEndian(); @@ -143,7 +143,7 @@ void ethernet_set_configuration(IPAddress ipAddress, IPAddress netMask, IPAddres /** \brief Initialize the Ethernet subsystem. * */ -void init_ethernet(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay) +void init_ethernet(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay) noexcept { ip4_addr_t x_ip_addr, x_net_mask, x_gateway; x_ip_addr.addr = ipAddress.GetV4LittleEndian(); @@ -169,7 +169,7 @@ void init_ethernet(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay) /** \brief Configure the Ethernet subsystem. Should be called after init_ethernet() * */ -void ethernet_configure_interface(const uint8_t macAddress[], const char *hostname) +void ethernet_configure_interface(const uint8_t macAddress[], const char *hostname) noexcept { ethernetif_set_mac_address(macAddress); @@ -181,7 +181,7 @@ void ethernet_configure_interface(const uint8_t macAddress[], const char *hostna /* \brief Perform ethernet auto-negotiation and establish link. Returns true when ready * */ -bool ethernet_establish_link(void) +bool ethernet_establish_link() noexcept { if (ethernetif_establish_link()) { @@ -194,7 +194,7 @@ bool ethernet_establish_link(void) /* \brief Is the link still up? Also updates the interface status if the link has gone down * */ -bool ethernet_link_established(void) +bool ethernet_link_established() noexcept { if (!ethernetif_link_established()) { @@ -210,7 +210,7 @@ bool ethernet_link_established(void) * * \return Returns true if data has been processed. */ -void ethernet_task(void) +void ethernet_task() noexcept { #if !LWIP_GMAC_TASK /* Run polling tasks */ @@ -229,7 +229,7 @@ void ethernet_task(void) * * \param callback The callback to be called when a new packet is ready */ -void ethernet_set_rx_callback(gmac_dev_tx_cb_t callback) +void ethernet_set_rx_callback(gmac_dev_tx_cb_t callback) noexcept { ethernetif_set_rx_callback(callback); } @@ -238,7 +238,7 @@ void ethernet_set_rx_callback(gmac_dev_tx_cb_t callback) /* * \brief Returns the current IP address */ -void ethernet_get_ipaddress(IPAddress& ipAddress, IPAddress& netMask, IPAddress& gateWay) +void ethernet_get_ipaddress(IPAddress& ipAddress, IPAddress& netMask, IPAddress& gateWay) noexcept { ipAddress.SetV4LittleEndian(gs_net_if.ip_addr.addr); netMask.SetV4LittleEndian(gs_net_if.netmask.addr); diff --git a/src/Networking/LwipEthernet/GMAC/ethernet_sam.h b/src/Networking/LwipEthernet/GMAC/ethernet_sam.h index 06516e19..c1948803 100644 --- a/src/Networking/LwipEthernet/GMAC/ethernet_sam.h +++ b/src/Networking/LwipEthernet/GMAC/ethernet_sam.h @@ -52,35 +52,35 @@ #include "lwip/netif.h" // Perform low-level initialisation of the network interface -void init_ethernet(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay); +void init_ethernet(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay) noexcept; // Terminate Ethernet and stop any interrupts, tasks etc. Used when shutting down the whole system. -inline void ethernet_terminate() { ethernetif_terminate(); } +inline void ethernet_terminate() noexcept { ethernetif_terminate(); } // Configure the ethernet interface -void ethernet_configure_interface(const uint8_t macAddress[], const char *hostname); +void ethernet_configure_interface(const uint8_t macAddress[], const char *hostname) noexcept; // Perform ethernet auto-negotiation and establish link. Returns true when ready -bool ethernet_establish_link(void); +bool ethernet_establish_link() noexcept; // Is the link still up? Also updates the interface status if the link has gone down -bool ethernet_link_established(void); +bool ethernet_link_established() noexcept; // Update IPv4 configuration on demand -void ethernet_set_configuration(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay); +void ethernet_set_configuration(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay) noexcept; // Must be called periodically to keep the LwIP timers running -void ethernet_timers_update(void); +void ethernet_timers_update() noexcept; // Reads all stored network packets and processes them -void ethernet_task(void); +void ethernet_task() noexcept; #if !LWIP_GMAC_TASK // Set the RX callback for incoming network packets -void ethernet_set_rx_callback(gmac_dev_tx_cb_t callback); +void ethernet_set_rx_callback(gmac_dev_tx_cb_t callback) noexcept; #endif // Returns the network interface's current IPv4 address -void ethernet_get_ipaddress(IPAddress& ipAddress, IPAddress& netMask, IPAddress& gateWay); +void ethernet_get_ipaddress(IPAddress& ipAddress, IPAddress& netMask, IPAddress& gateWay) noexcept; #endif /* ETHERNET_SAM_H_INCLUDED */ diff --git a/src/Networking/LwipEthernet/GMAC/same70_gmac.cpp b/src/Networking/LwipEthernet/GMAC/same70_gmac.cpp index 863f4018..2565fe79 100644 --- a/src/Networking/LwipEthernet/GMAC/same70_gmac.cpp +++ b/src/Networking/LwipEthernet/GMAC/same70_gmac.cpp @@ -176,7 +176,7 @@ static gmac_dev_tx_cb_t gmac_rx_cb = nullptr; /** * \brief GMAC interrupt handler. */ -void GMAC_Handler(void) +extern "C" void GMAC_Handler() noexcept { #if LWIP_GMAC_TASK /* Get interrupt status. */ @@ -214,7 +214,7 @@ void GMAC_Handler(void) * \param p_gmac_dev Pointer to driver data structure. * \param startAt The index to start populating from */ -static void gmac_rx_populate_queue(struct gmac_device *p_gmac_dev, uint32_t startAt) +static void gmac_rx_populate_queue(struct gmac_device *p_gmac_dev, uint32_t startAt) noexcept { uint32_t ul_index = startAt; @@ -278,7 +278,7 @@ static void gmac_rx_populate_queue(struct gmac_device *p_gmac_dev, uint32_t star * * \param ps_gmac_dev Pointer to driver data structure. */ -static void gmac_rx_init(struct gmac_device *ps_gmac_dev) +static void gmac_rx_init(struct gmac_device *ps_gmac_dev) noexcept { uint32_t ul_index = 0; @@ -308,7 +308,7 @@ static void gmac_rx_init(struct gmac_device *ps_gmac_dev) * * \param ps_gmac_dev Pointer to driver data structure. */ -static void gmac_tx_init(struct gmac_device *ps_gmac_dev) +static void gmac_tx_init(struct gmac_device *ps_gmac_dev) noexcept { uint32_t ul_index; @@ -334,7 +334,7 @@ static void gmac_tx_init(struct gmac_device *ps_gmac_dev) * * \param netif the lwIP network interface structure for this ethernetif. */ -static void gmac_low_level_init(struct netif *netif) +static void gmac_low_level_init(struct netif *netif) noexcept { #if 0 // chrishamm volatile uint32_t ul_delay; @@ -402,7 +402,7 @@ static void gmac_low_level_init(struct netif *netif) * \return ERR_OK if the packet could be sent. * an err_t value if the packet couldn't be sent. */ -static err_t gmac_low_level_output(netif *p_netif, struct pbuf *p) +static err_t gmac_low_level_output(netif *p_netif, struct pbuf *p) noexcept { gmac_device *const ps_gmac_dev = static_cast<gmac_device *>(p_netif->state); @@ -482,7 +482,7 @@ static err_t gmac_low_level_output(netif *p_netif, struct pbuf *p) * \return a pbuf filled with the received packet (including MAC header). * 0 on memory error. */ -static pbuf *gmac_low_level_input(struct netif *netif) +static pbuf *gmac_low_level_input(struct netif *netif) noexcept { gmac_device *ps_gmac_dev = static_cast<gmac_device *>(netif->state); @@ -565,7 +565,7 @@ static pbuf *gmac_low_level_input(struct netif *netif) * * \param pvParameters A pointer to the gmac_device instance. */ -extern "C" [[noreturn]] void gmac_task(void *pvParameters) +extern "C" [[noreturn]] void gmac_task(void *pvParameters) noexcept { gmac_device * const ps_gmac_dev = static_cast<gmac_device*>(pvParameters); netif * const p_netif = ps_gmac_dev->netif; @@ -593,7 +593,7 @@ extern "C" [[noreturn]] void gmac_task(void *pvParameters) * * \param netif the lwIP network interface structure for this ethernetif. */ -bool ethernetif_input(struct netif *netif) +bool ethernetif_input(struct netif *netif) noexcept { struct eth_hdr *ethhdr; struct pbuf *p; @@ -642,7 +642,7 @@ bool ethernetif_input(struct netif *netif) * ERR_MEM if private data couldn't be allocated. * any other err_t on error. */ -err_t ethernetif_init(struct netif *netif) +err_t ethernetif_init(struct netif *netif) noexcept { LWIP_ASSERT("netif != NULL", (netif != NULL)); @@ -683,7 +683,7 @@ err_t ethernetif_init(struct netif *netif) return ERR_OK; } -void ethernetif_hardware_init(void) +void ethernetif_hardware_init() noexcept { /* Enable GMAC clock. */ pmc_enable_periph_clk(ID_GMAC); @@ -767,7 +767,7 @@ void ethernetif_hardware_init(void) NVIC_EnableIRQ(GMAC_IRQn); } -bool ethernetif_establish_link(void) +bool ethernetif_establish_link() noexcept { /* Auto Negotiate, work in RMII mode. */ uint8_t result = ethernet_phy_auto_negotiate(GMAC, BOARD_GMAC_PHY_ADDR); @@ -790,7 +790,7 @@ bool ethernetif_establish_link(void) } // Ask the PHY if the link is still up -bool ethernetif_link_established(void) +bool ethernetif_link_established() noexcept { gmac_enable_management(GMAC, true); @@ -810,13 +810,13 @@ bool ethernetif_link_established(void) } #if !LWIP_GMAC_TASK -void ethernetif_set_rx_callback(gmac_dev_tx_cb_t callback) +void ethernetif_set_rx_callback(gmac_dev_tx_cb_t callback) noexcept { gmac_rx_cb = callback; } #endif -void ethernetif_set_mac_address(const uint8_t macAddress[]) +void ethernetif_set_mac_address(const uint8_t macAddress[]) noexcept { // This function must be called once before low_level_init(), because that is where the // MAC address of the netif is assigned @@ -827,7 +827,7 @@ void ethernetif_set_mac_address(const uint8_t macAddress[]) } // This is called when we shut down -void ethernetif_terminate() +void ethernetif_terminate() noexcept { NVIC_DisableIRQ(GMAC_IRQn); #if LWIP_GMAC_TASK @@ -835,9 +835,9 @@ void ethernetif_terminate() #endif } -extern "C" u32_t millis(); +extern "C" u32_t millis() noexcept; -extern "C" u32_t sys_now(void) +extern "C" u32_t sys_now() noexcept { return millis(); } diff --git a/src/Networking/LwipEthernet/GMAC/same70_gmac.h b/src/Networking/LwipEthernet/GMAC/same70_gmac.h index 6d494faf..8d6bd595 100644 --- a/src/Networking/LwipEthernet/GMAC/same70_gmac.h +++ b/src/Networking/LwipEthernet/GMAC/same70_gmac.h @@ -57,24 +57,24 @@ extern "C" { #ifdef __cplusplus } -err_t ethernetif_init(struct netif *netif); // called by LwIP to initialise the interface +err_t ethernetif_init(struct netif *netif) noexcept; // called by LwIP to initialise the interface -void ethernetif_terminate(); // called when we shut down +void ethernetif_terminate() noexcept; // called when we shut down -bool ethernetif_input(struct netif *netif); // checks for a new packet and returns true if one was processed +bool ethernetif_input(struct netif *netif) noexcept; // checks for a new packet and returns true if one was processed -void ethernetif_hardware_init(void); // initialises the low-level hardware interface +void ethernetif_hardware_init() noexcept; // initialises the low-level hardware interface -bool ethernetif_establish_link(void); // attempts to establish link and returns true on success +bool ethernetif_establish_link() noexcept; // attempts to establish link and returns true on success -bool ethernetif_link_established(void); // asks the PHY if the link is still up +bool ethernetif_link_established() noexcept; // asks the PHY if the link is still up #if !LWIP_GMAC_TASK -typedef void (*gmac_dev_tx_cb_t) (uint32_t ul_status); // copied from gmac_raw.h -void ethernetif_set_rx_callback(gmac_dev_tx_cb_t callback); +typedef void (*gmac_dev_tx_cb_t) (uint32_t ul_status) noexcept; // copied from gmac_raw.h +void ethernetif_set_rx_callback(gmac_dev_tx_cb_t callback) noexcept; #endif -void ethernetif_set_mac_address(const uint8_t macAddress[]); +void ethernetif_set_mac_address(const uint8_t macAddress[]) noexcept; #endif diff --git a/src/Networking/LwipEthernet/Lwip/src/include/lwip/sys.h b/src/Networking/LwipEthernet/Lwip/src/include/lwip/sys.h index 3bfa245f..89e44449 100644 --- a/src/Networking/LwipEthernet/Lwip/src/include/lwip/sys.h +++ b/src/Networking/LwipEthernet/Lwip/src/include/lwip/sys.h @@ -40,7 +40,10 @@ #include <Lwip/src/include/lwip/opt.h> #ifdef __cplusplus +# define NOEXCEPT noexcept extern "C" { +#else +# define NOEXCEPT #endif #if NO_SYS @@ -340,7 +343,7 @@ u32_t sys_jiffies(void); * Returns the current time in milliseconds, * may be the same as sys_jiffies or at least based on it. */ -u32_t sys_now(void); +u32_t sys_now(void) NOEXCEPT; /* Critical Region Protection */ /* These functions must be implemented in the sys_arch.c file. diff --git a/src/Networking/LwipEthernet/LwipEthernetInterface.cpp b/src/Networking/LwipEthernet/LwipEthernetInterface.cpp index 79378030..88c42a90 100644 --- a/src/Networking/LwipEthernet/LwipEthernetInterface.cpp +++ b/src/Networking/LwipEthernet/LwipEthernetInterface.cpp @@ -134,7 +134,7 @@ extern "C" /*-----------------------------------------------------------------------------------*/ -LwipEthernetInterface::LwipEthernetInterface(Platform& p) : platform(p), closeDataPort(false), state(NetworkState::disabled), +LwipEthernetInterface::LwipEthernetInterface(Platform& p) noexcept : platform(p), closeDataPort(false), state(NetworkState::disabled), activated(false), initialised(false), usingDhcp(false) { ethernetInterface = this; @@ -175,7 +175,7 @@ DEFINE_GET_OBJECT_MODEL_TABLE(LwipEthernetInterface) #endif -void LwipEthernetInterface::Init() +void LwipEthernetInterface::Init() noexcept { interfaceMutex.Create("LwipIface"); //TODO we don't yet use this mutex anywhere! @@ -193,7 +193,7 @@ void LwipEthernetInterface::Init() memcpy(macAddress, platform.GetDefaultMacAddress(), sizeof(macAddress)); } -GCodeResult LwipEthernetInterface::EnableProtocol(NetworkProtocol protocol, int port, int secure, const StringRef& reply) +GCodeResult LwipEthernetInterface::EnableProtocol(NetworkProtocol protocol, int port, int secure, const StringRef& reply) noexcept { if (secure != 0 && secure != -1) { @@ -229,7 +229,7 @@ GCodeResult LwipEthernetInterface::EnableProtocol(NetworkProtocol protocol, int return GCodeResult::error; } -GCodeResult LwipEthernetInterface::DisableProtocol(NetworkProtocol protocol, const StringRef& reply) +GCodeResult LwipEthernetInterface::DisableProtocol(NetworkProtocol protocol, const StringRef& reply) noexcept { if (protocol < NumProtocols) { @@ -246,7 +246,7 @@ GCodeResult LwipEthernetInterface::DisableProtocol(NetworkProtocol protocol, con return GCodeResult::error; } -void LwipEthernetInterface::StartProtocol(NetworkProtocol protocol) +void LwipEthernetInterface::StartProtocol(NetworkProtocol protocol) noexcept { if (listeningPcbs[protocol] == nullptr) { @@ -278,7 +278,7 @@ void LwipEthernetInterface::StartProtocol(NetworkProtocol protocol) } } -void LwipEthernetInterface::ShutdownProtocol(NetworkProtocol protocol) +void LwipEthernetInterface::ShutdownProtocol(NetworkProtocol protocol) noexcept { #if 0 // chrishamm: Also see Network::Stop for (NetworkResponder* r = responders; r != nullptr; r = r->GetNext()) @@ -317,7 +317,7 @@ void LwipEthernetInterface::ShutdownProtocol(NetworkProtocol protocol) } // Report the protocols and ports in use -GCodeResult LwipEthernetInterface::ReportProtocols(const StringRef& reply) const +GCodeResult LwipEthernetInterface::ReportProtocols(const StringRef& reply) const noexcept { reply.Clear(); for (size_t i = 0; i < NumProtocols; ++i) @@ -327,7 +327,7 @@ GCodeResult LwipEthernetInterface::ReportProtocols(const StringRef& reply) const return GCodeResult::ok; } -void LwipEthernetInterface::ReportOneProtocol(NetworkProtocol protocol, const StringRef& reply) const +void LwipEthernetInterface::ReportOneProtocol(NetworkProtocol protocol, const StringRef& reply) const noexcept { if (protocolEnabled[protocol]) { @@ -341,7 +341,7 @@ void LwipEthernetInterface::ReportOneProtocol(NetworkProtocol protocol, const St // This is called at the end of config.g processing. // Start the network if it was enabled -void LwipEthernetInterface::Activate() +void LwipEthernetInterface::Activate() noexcept { if (!activated) { @@ -357,14 +357,14 @@ void LwipEthernetInterface::Activate() } } -void LwipEthernetInterface::Exit() +void LwipEthernetInterface::Exit() noexcept { Stop(); ethernet_terminate(); } // Get the network state into the reply buffer, returning true if there is some sort of error -GCodeResult LwipEthernetInterface::GetNetworkState(const StringRef& reply) +GCodeResult LwipEthernetInterface::GetNetworkState(const StringRef& reply) noexcept { ethernet_get_ipaddress(ipAddress, netmask, gateway); const int enableState = EnableState(); @@ -375,7 +375,7 @@ GCodeResult LwipEthernetInterface::GetNetworkState(const StringRef& reply) } // Start up the network -void LwipEthernetInterface::Start() +void LwipEthernetInterface::Start() noexcept { #if defined(DUET3) digitalWrite(PhyResetPin, true); // bring the Ethernet Phy out of reset @@ -412,7 +412,7 @@ void LwipEthernetInterface::Start() } // Stop the network -void LwipEthernetInterface::Stop() +void LwipEthernetInterface::Stop() noexcept { if (state != NetworkState::disabled) { @@ -430,7 +430,7 @@ void LwipEthernetInterface::Stop() } // Main spin loop. If 'full' is true then we are being called from the main spin loop. If false then we are being called during HSMCI idle time. -void LwipEthernetInterface::Spin() +void LwipEthernetInterface::Spin() noexcept { #if LWIP_GMAC_TASK MutexLocker lock(lwipMutex); @@ -542,7 +542,7 @@ void LwipEthernetInterface::Spin() #endif } -void LwipEthernetInterface::Interrupt() +void LwipEthernetInterface::Interrupt() noexcept { #if !LWIP_GMAC_TASK if (initialised && LockLWIP()) @@ -553,7 +553,7 @@ void LwipEthernetInterface::Interrupt() #endif } -void LwipEthernetInterface::Diagnostics(MessageType mtype) +void LwipEthernetInterface::Diagnostics(MessageType mtype) noexcept { platform.Message(mtype, "- Ethernet -\n"); platform.MessageF(mtype, "State: %d\n", (int)state); @@ -575,7 +575,7 @@ void LwipEthernetInterface::Diagnostics(MessageType mtype) } // Enable or disable the network. For Ethernet the ssid parameter is not used. -GCodeResult LwipEthernetInterface::EnableInterface(int mode, const StringRef& ssid, const StringRef& reply) +GCodeResult LwipEthernetInterface::EnableInterface(int mode, const StringRef& ssid, const StringRef& reply) noexcept { if (!activated) { @@ -598,12 +598,12 @@ GCodeResult LwipEthernetInterface::EnableInterface(int mode, const StringRef& ss return GCodeResult::ok; } -int LwipEthernetInterface::EnableState() const +int LwipEthernetInterface::EnableState() const noexcept { return (state == NetworkState::disabled) ? 0 : 1; } -bool LwipEthernetInterface::InNetworkStack() const +bool LwipEthernetInterface::InNetworkStack() const noexcept { #if LWIP_GMAC_TASK return false; @@ -612,7 +612,7 @@ bool LwipEthernetInterface::InNetworkStack() const #endif } -bool LwipEthernetInterface::ConnectionEstablished(tcp_pcb *pcb) +bool LwipEthernetInterface::ConnectionEstablished(tcp_pcb *pcb) noexcept { for (LwipSocket *s : sockets) { @@ -627,12 +627,12 @@ bool LwipEthernetInterface::ConnectionEstablished(tcp_pcb *pcb) return false; } -IPAddress LwipEthernetInterface::GetIPAddress() const +IPAddress LwipEthernetInterface::GetIPAddress() const noexcept { return ipAddress; } -void LwipEthernetInterface::SetIPAddress(IPAddress p_ipAddress, IPAddress p_netmask, IPAddress p_gateway) +void LwipEthernetInterface::SetIPAddress(IPAddress p_ipAddress, IPAddress p_netmask, IPAddress p_gateway) noexcept { if (state == NetworkState::obtainingIP || state == NetworkState::active) { @@ -668,7 +668,7 @@ void LwipEthernetInterface::SetIPAddress(IPAddress p_ipAddress, IPAddress p_netm } } -void LwipEthernetInterface::UpdateHostname(const char *hostname) +void LwipEthernetInterface::UpdateHostname(const char *hostname) noexcept { if (initialised) { @@ -677,12 +677,12 @@ void LwipEthernetInterface::UpdateHostname(const char *hostname) } } -void LwipEthernetInterface::SetMacAddress(const uint8_t mac[]) +void LwipEthernetInterface::SetMacAddress(const uint8_t mac[]) noexcept { memcpy(macAddress, mac, sizeof(macAddress)); } -void LwipEthernetInterface::OpenDataPort(Port port) +void LwipEthernetInterface::OpenDataPort(Port port) noexcept { if (listeningPcbs[NumProtocols] != nullptr) { @@ -699,7 +699,7 @@ void LwipEthernetInterface::OpenDataPort(Port port) } // Close FTP data port and purge associated resources -void LwipEthernetInterface::TerminateDataPort() +void LwipEthernetInterface::TerminateDataPort() noexcept { if (closeDataPort || !sockets[FtpDataSocketNumber]->IsClosing()) { @@ -720,7 +720,7 @@ void LwipEthernetInterface::TerminateDataPort() } } -void LwipEthernetInterface::InitSockets() +void LwipEthernetInterface::InitSockets() noexcept { for (size_t i = 0; i < NumProtocols; ++i) { @@ -732,7 +732,7 @@ void LwipEthernetInterface::InitSockets() nextSocketToPoll = 0; } -void LwipEthernetInterface::TerminateSockets() +void LwipEthernetInterface::TerminateSockets() noexcept { for (LwipSocket *socket : sockets) { @@ -748,7 +748,7 @@ void GetServiceTxtEntries(struct mdns_service *service, void *txt_userdata) } } -void LwipEthernetInterface::RebuildMdnsServices() +void LwipEthernetInterface::RebuildMdnsServices() noexcept { mdns_resp_remove_netif(&gs_net_if); mdns_resp_add_netif(&gs_net_if, reprap.GetNetwork().GetHostname(), MdnsTtl); diff --git a/src/Networking/LwipEthernet/LwipEthernetInterface.h b/src/Networking/LwipEthernet/LwipEthernetInterface.h index 94ec30e0..3a4a6f42 100644 --- a/src/Networking/LwipEthernet/LwipEthernetInterface.h +++ b/src/Networking/LwipEthernet/LwipEthernetInterface.h @@ -28,36 +28,36 @@ struct tcp_pcb; class LwipEthernetInterface : public NetworkInterface { public: - LwipEthernetInterface(Platform& p); - - void Init() override; - void Activate() override; - void Exit() override; - void Spin() override; - void Interrupt() override; - void Diagnostics(MessageType mtype) override; - - GCodeResult EnableInterface(int mode, const StringRef& ssid, const StringRef& reply) override; // enable or disable the network - GCodeResult EnableProtocol(NetworkProtocol protocol, int port, int secure, const StringRef& reply) override; - GCodeResult DisableProtocol(NetworkProtocol protocol, const StringRef& reply) override; - GCodeResult ReportProtocols(const StringRef& reply) const override; - - GCodeResult GetNetworkState(const StringRef& reply) override; - int EnableState() const override; - bool InNetworkStack() const override; - bool IsWiFiInterface() const override { return false; } - - void UpdateHostname(const char *hostname) override; - IPAddress GetIPAddress() const override; - void SetIPAddress(IPAddress p_ipAddress, IPAddress p_netmask, IPAddress p_gateway) override; - void SetMacAddress(const uint8_t mac[]) override; - const uint8_t *GetMacAddress() const override { return macAddress; } + LwipEthernetInterface(Platform& p) noexcept; + + void Init() noexcept override; + void Activate() noexcept override; + void Exit() noexcept override; + void Spin() noexcept override; + void Interrupt() noexcept override; + void Diagnostics(MessageType mtype) noexcept override; + + GCodeResult EnableInterface(int mode, const StringRef& ssid, const StringRef& reply) noexcept override; // enable or disable the network + GCodeResult EnableProtocol(NetworkProtocol protocol, int port, int secure, const StringRef& reply) noexcept override; + GCodeResult DisableProtocol(NetworkProtocol protocol, const StringRef& reply) noexcept override; + GCodeResult ReportProtocols(const StringRef& reply) const noexcept override; + + GCodeResult GetNetworkState(const StringRef& reply) noexcept override; + int EnableState() const noexcept override; + bool InNetworkStack() const noexcept override; + bool IsWiFiInterface() const noexcept override { return false; } + + void UpdateHostname(const char *hostname) noexcept override; + IPAddress GetIPAddress() const noexcept override; + void SetIPAddress(IPAddress p_ipAddress, IPAddress p_netmask, IPAddress p_gateway) noexcept override; + void SetMacAddress(const uint8_t mac[]) noexcept override; + const uint8_t *GetMacAddress() const noexcept override { return macAddress; } // LwIP interfaces - bool ConnectionEstablished(tcp_pcb *pcb); + bool ConnectionEstablished(tcp_pcb *pcb) noexcept; - void OpenDataPort(Port port) override; - void TerminateDataPort() override; + void OpenDataPort(Port port) noexcept override; + void TerminateDataPort() noexcept override; protected: DECLARE_OBJECT_MODEL @@ -73,20 +73,20 @@ private: active // network running }; - void Start(); - void Stop(); - void InitSockets(); - void TerminateSockets(); + void Start() noexcept; + void Stop() noexcept; + void InitSockets() noexcept; + void TerminateSockets() noexcept; - void RebuildMdnsServices(); + void RebuildMdnsServices() noexcept; - void StartProtocol(NetworkProtocol protocol) + void StartProtocol(NetworkProtocol protocol) noexcept pre(protocol < NumProtocols); - void ShutdownProtocol(NetworkProtocol protocol) + void ShutdownProtocol(NetworkProtocol protocol) noexcept pre(protocol < NumProtocols); - void ReportOneProtocol(NetworkProtocol protocol, const StringRef& reply) const + void ReportOneProtocol(NetworkProtocol protocol, const StringRef& reply) const noexcept pre(protocol < NumProtocols); Platform& platform; diff --git a/src/Networking/LwipEthernet/LwipSocket.cpp b/src/Networking/LwipEthernet/LwipSocket.cpp index 69d7bab5..52c5288c 100644 --- a/src/Networking/LwipEthernet/LwipSocket.cpp +++ b/src/Networking/LwipEthernet/LwipSocket.cpp @@ -77,13 +77,13 @@ extern void UnlockLWIP(); // LwipSocket class -LwipSocket::LwipSocket(NetworkInterface *iface) : Socket(iface), connectionPcb(nullptr), +LwipSocket::LwipSocket(NetworkInterface *iface) noexcept : Socket(iface), connectionPcb(nullptr), receivedData(nullptr), state(SocketState::disabled) { ReInit(); } -bool LwipSocket::AcceptConnection(tcp_pcb *pcb) +bool LwipSocket::AcceptConnection(tcp_pcb *pcb) noexcept { if (state == SocketState::listening && pcb->local_port == localPort) { @@ -104,7 +104,7 @@ bool LwipSocket::AcceptConnection(tcp_pcb *pcb) return false; } -void LwipSocket::DataReceived(pbuf *data) +void LwipSocket::DataReceived(pbuf *data) noexcept { if (state != SocketState::closing) { @@ -125,7 +125,7 @@ void LwipSocket::DataReceived(pbuf *data) } } -void LwipSocket::DataSent(size_t numBytes) +void LwipSocket::DataSent(size_t numBytes) noexcept { if (numBytes <= unAcked) { @@ -144,7 +144,7 @@ void LwipSocket::DataSent(size_t numBytes) } } -void LwipSocket::ConnectionClosedGracefully() +void LwipSocket::ConnectionClosedGracefully() noexcept { if (connectionPcb != nullptr) { @@ -166,7 +166,7 @@ void LwipSocket::ConnectionClosedGracefully() } } -void LwipSocket::ConnectionError(err_t err) +void LwipSocket::ConnectionError(err_t err) noexcept { DiscardReceivedData(); connectionPcb = nullptr; @@ -179,7 +179,7 @@ void LwipSocket::ConnectionError(err_t err) } // Initialise a TCP socket -void LwipSocket::Init(SocketNumber skt, Port serverPort, NetworkProtocol p) +void LwipSocket::Init(SocketNumber skt, Port serverPort, NetworkProtocol p) noexcept { UNUSED(skt); localPort = serverPort; @@ -189,13 +189,13 @@ void LwipSocket::Init(SocketNumber skt, Port serverPort, NetworkProtocol p) ReInit(); } -void LwipSocket::TerminateAndDisable() +void LwipSocket::TerminateAndDisable() noexcept { Terminate(); state = SocketState::disabled; } -void LwipSocket::ReInit() +void LwipSocket::ReInit() noexcept { DiscardReceivedData(); whenConnected = whenWritten = whenClosed = 0; @@ -204,7 +204,7 @@ void LwipSocket::ReInit() } // Close a connection when the last packet has been sent -void LwipSocket::Close() +void LwipSocket::Close() noexcept { if (state != SocketState::disabled && state != SocketState::listening) { @@ -223,7 +223,7 @@ void LwipSocket::Close() } // Terminate a connection immediately -void LwipSocket::Terminate() +void LwipSocket::Terminate() noexcept { if (state != SocketState::disabled) { @@ -246,19 +246,19 @@ void LwipSocket::Terminate() } // Return true if there is or may soon be more data to read -bool LwipSocket::CanRead() const +bool LwipSocket::CanRead() const noexcept { return (state == SocketState::connected) || (state == SocketState::clientDisconnecting && receivedData != nullptr); } -bool LwipSocket::CanSend() const +bool LwipSocket::CanSend() const noexcept { return (state == SocketState::connected); } // Read 1 character from the receive buffers, returning true if successful -bool LwipSocket::ReadChar(char& c) +bool LwipSocket::ReadChar(char& c) noexcept { if (receivedData != nullptr) { @@ -292,7 +292,7 @@ bool LwipSocket::ReadChar(char& c) } // Return a pointer to data in a buffer and a length available -bool LwipSocket::ReadBuffer(const uint8_t *&buffer, size_t &len) +bool LwipSocket::ReadBuffer(const uint8_t *&buffer, size_t &len) noexcept { if (receivedData != nullptr) { @@ -306,7 +306,7 @@ bool LwipSocket::ReadBuffer(const uint8_t *&buffer, size_t &len) } // Flag some data as taken from the receive buffers. We never take data from more than one buffer at a time. -void LwipSocket::Taken(size_t len) +void LwipSocket::Taken(size_t len) noexcept { if (receivedData != nullptr) { @@ -333,7 +333,7 @@ void LwipSocket::Taken(size_t len) } // Poll a socket to see if it needs to be serviced -void LwipSocket::Poll() +void LwipSocket::Poll() noexcept { switch (state) { @@ -399,7 +399,7 @@ void LwipSocket::Poll() } // Discard any received data for this transaction -void LwipSocket::DiscardReceivedData() +void LwipSocket::DiscardReceivedData() noexcept { if (receivedData != nullptr) { @@ -410,7 +410,7 @@ void LwipSocket::DiscardReceivedData() } // Send the data, returning the length buffered -size_t LwipSocket::Send(const uint8_t *data, size_t length) +size_t LwipSocket::Send(const uint8_t *data, size_t length) noexcept { #if LWIP_GMAC_TASK MutexLocker lock(lwipMutex); diff --git a/src/Networking/LwipEthernet/LwipSocket.h b/src/Networking/LwipEthernet/LwipSocket.h index 5f9b1f0f..f2e9ef85 100644 --- a/src/Networking/LwipEthernet/LwipSocket.h +++ b/src/Networking/LwipEthernet/LwipSocket.h @@ -21,30 +21,30 @@ struct pbuf; class LwipSocket : public Socket { public: - LwipSocket(NetworkInterface *iface); - int GetState() const { return (int)state; } // for debugging + LwipSocket(NetworkInterface *iface) noexcept; + int GetState() const noexcept { return (int)state; } // for debugging // LwIP interfaces - bool AcceptConnection(tcp_pcb *pcb); - void DataReceived(pbuf *data); - void DataSent(size_t numBytes); - void ConnectionClosedGracefully(); - void ConnectionError(err_t err); + bool AcceptConnection(tcp_pcb *pcb) noexcept; + void DataReceived(pbuf *data) noexcept; + void DataSent(size_t numBytes) noexcept; + void ConnectionClosedGracefully() noexcept; + void ConnectionError(err_t err) noexcept; // Inherited members of the Socket class - void Init(SocketNumber s, Port serverPort, NetworkProtocol p); - void TerminateAndDisable() override; - void Poll() override; - void Close() override; - bool IsClosing() const { return (state == SocketState::closing); } - void Terminate() override; - bool ReadChar(char& c) override; - bool ReadBuffer(const uint8_t *&buffer, size_t &len) override; - void Taken(size_t len) override; - bool CanRead() const override; - bool CanSend() const override; - size_t Send(const uint8_t *data, size_t length) override; - void Send() override { } + void Init(SocketNumber s, Port serverPort, NetworkProtocol p) noexcept; + void TerminateAndDisable() noexcept override; + void Poll() noexcept override; + void Close() noexcept override; + bool IsClosing() const noexcept { return (state == SocketState::closing); } + void Terminate() noexcept override; + bool ReadChar(char& c) noexcept override; + bool ReadBuffer(const uint8_t *&buffer, size_t &len) noexcept override; + void Taken(size_t len) noexcept override; + bool CanRead() const noexcept override; + bool CanSend() const noexcept override; + size_t Send(const uint8_t *data, size_t length) noexcept override; + void Send() noexcept override { } private: enum class SocketState : uint8_t @@ -58,8 +58,8 @@ private: aborted }; - void ReInit(); - void DiscardReceivedData(); + void ReInit() noexcept; + void DiscardReceivedData() noexcept; uint32_t whenConnected; uint32_t whenWritten; diff --git a/src/Platform.cpp b/src/Platform.cpp index aaab5084..6a0791b2 100644 --- a/src/Platform.cpp +++ b/src/Platform.cpp @@ -1329,12 +1329,6 @@ void Platform::SoftwareReset(uint16_t reason, const uint32_t *stk) noexcept { reason |= (uint16_t)SoftwareResetReason::inUsbOutput; // if we are resetting because we are stuck in a Spin function, record whether we are trying to send to USB } -#if HAS_LWIP_NETWORKING - if (reprap.GetNetwork().InNetworkStack()) - { - reason |= (uint16_t)SoftwareResetReason::inLwipSpin; - } -#endif #ifdef SERIAL_AUX_DEVICE if (SERIAL_AUX_DEVICE.canWrite() == 0 diff --git a/src/RepRap.cpp b/src/RepRap.cpp index 3377fa7e..d8acfd4d 100644 --- a/src/RepRap.cpp +++ b/src/RepRap.cpp @@ -2640,7 +2640,7 @@ void RepRap::ReportInternalError(const char *file, const char *func, int line) c #if SUPPORT_12864_LCD -const char *RepRap::GetLatestMessage(uint16_t& sequence) const +const char *RepRap::GetLatestMessage(uint16_t& sequence) const noexcept { sequence = messageSequence; return message.c_str(); diff --git a/src/SoftwareReset.h b/src/SoftwareReset.h index 9af2f36b..29c47d91 100644 --- a/src/SoftwareReset.h +++ b/src/SoftwareReset.h @@ -38,7 +38,7 @@ enum class SoftwareResetReason : uint16_t unusedBit = 0x0200, // spare bit unused2 = 0x0400, // spare bit inAuxOutput = 0x0800, // this bit is or'ed in if we were in aux output at the time - inLwipSpin = 0x2000, // we got stuck in a call to LWIP for too long + unused_was_inLwipSpin = 0x2000, // no longer used inUsbOutput = 0x4000, // this bit is or'ed in if we were in USB output at the time deliberate = 0x8000 // this but it or'ed in if we deliberately caused a fault }; |