Merge branch 'hotfix/GCC9_Compatibility'

Author: lunOptics

src/RotateControlBase.h

@@ -1,19 +1,19 @@
 #pragma once
 
 #include "MotorControlBase.h"
-#include <algorithm>
+//#include <algorithm>
 #include "core_pins.h"
 
 template <typename Accelerator, typename TimerField>
 class RotateControlBase : public MotorControlBase<TimerField>
 {
   public:
-    RotateControlBase(unsigned pulseWidth = 5, unsigned accUpdatePeriod = 5000);    
+    RotateControlBase(unsigned pulseWidth = 5, unsigned accUpdatePeriod = 5000);
 
     // Non-blocking movements ----------------
     template <typename... Steppers>
     void rotateAsync(Steppers &... steppers);
-   
+
     template <size_t N>
     void rotateAsync(Stepper *(&motors)[N]);
 
@@ -59,33 +59,33 @@ void RotateControlBase<a, t>::doRotate(int N, float speedFactor)
     if (this->leadMotor->vMax == 0)
         return;
 
-    this->leadMotor->currentSpeed = 0; 
+    this->leadMotor->currentSpeed = 0;
 
-    this->leadMotor->A = std::abs(this->leadMotor->vMax);
+    this->leadMotor->A = abs(this->leadMotor->vMax);
     for (int i = 1; i < N; i++)
     {
-        this->motorList[i]->A = std::abs(this->motorList[i]->vMax);
+        this->motorList[i]->A = abs(this->motorList[i]->vMax);
         this->motorList[i]->B = 2 * this->motorList[i]->A - this->leadMotor->A;
     }
     uint32_t acceleration = (*std::min_element(this->motorList, this->motorList + N, Stepper::cmpAcc))->a; // use the lowest acceleration for the move
-    
-    // Start moving---------------------------------------------------------------------------------------  
+
+    // Start moving---------------------------------------------------------------------------------------
     accelerator.prepareRotation(this->leadMotor->current, this->leadMotor->vMax, acceleration, this->accUpdatePeriod, speedFactor);
-    this->timerField.setStepFrequency(0);    
-    this->timerField.accTimerStart();    
+    this->timerField.setStepFrequency(0);
+    this->timerField.accTimerStart();
 }
 
 // ISR -----------------------------------------------------------------------------------------------------------
 
 template <typename a, typename t>
 void RotateControlBase<a, t>::accTimerISR()
-{   
+{
     int32_t newSpeed = accelerator.updateSpeed(this->leadMotor->current); // get new speed for the leading motor
-     
+
     //Serial.printf("rc,curSpeed: %i newspd:%i\n",this->leadMotor->currentSpeed,  newSpeed);
 
     if (this->leadMotor->currentSpeed == newSpeed)
-    {         
+    {
         return; // nothing changed, just keep running
     }
 
@@ -99,10 +99,10 @@ void RotateControlBase<a, t>::accTimerISR()
         }
         delayMicroseconds(this->pulseWidth);
     }
-    
-    
-    this->timerField.setStepFrequency(std::abs(newSpeed)); // speed changed, update timer    
-    this->leadMotor->currentSpeed = newSpeed;   
+
+
+    this->timerField.setStepFrequency(abs(newSpeed)); // speed changed, update timer
+    this->leadMotor->currentSpeed = newSpeed;
 }
 
 // ROTATE Commands -------------------------------------------------------------------------------
@@ -117,7 +117,7 @@ void RotateControlBase<a, t>::rotateAsync(Steppers &... steppers)
 
 template <typename a, typename t>
 template <size_t N>
-void RotateControlBase<a, t>::rotateAsync(Stepper *(&steppers)[N]) 
+void RotateControlBase<a, t>::rotateAsync(Stepper *(&steppers)[N])
 {
     this->attachStepper(steppers);
     doRotate(N);

src/StepControlBase.h

@@ -61,7 +61,7 @@ void StepControlBase<a, t>::doMove(int N, bool move)
     }
 
     // Calculate acceleration parameters --------------------------------------------------------------
-    uint32_t targetSpeed = std::abs((*std::min_element(this->motorList, this->motorList + N, Stepper::cmpVmin))->vMax); // use the lowest max frequency for the move, scale by relSpeed
+    uint32_t targetSpeed = abs((*std::min_element(this->motorList, this->motorList + N, Stepper::cmpVmin))->vMax); // use the lowest max frequency for the move, scale by relSpeed
     uint32_t acceleration = (*std::min_element(this->motorList, this->motorList + N, Stepper::cmpAcc))->a;              // use the lowest acceleration for the move
     if (this->leadMotor->A == 0 || targetSpeed == 0)
         return;

src/Stepper.cpp

@@ -78,4 +78,9 @@ void Stepper::setTargetRel(int32_t delta)
     setDir(delta < 0 ? -1 : 1);
     target = current + delta;
     A = std::abs(delta);
-}
+}
+
+const int32_t  Stepper::vMaxMax = 300000;  // largest speed possible (steps/s)
+const uint32_t Stepper::aMax = 500000;     // speed up to 500kHz within 1 s (steps/s^2)
+const uint32_t Stepper::vMaxDefault = 800; // should work with every motor (1 rev/sec in 1/4-step mode)
+const uint32_t Stepper::aDefault = 2500;   // reasonably low (~0.5s for reaching the default speed)

src/Stepper.h

@@ -5,10 +5,10 @@
 
 class Stepper
 {
-    static constexpr int32_t vMaxMax = 300000;   // largest speed possible (steps/s)
-    static constexpr uint32_t aMax = 500000;     // speed up to 500kHz within 1 s (steps/s^2)
-    static constexpr uint32_t vMaxDefault = 800; // should work with every motor (1 rev/sec in 1/4-step mode)
-    static constexpr uint32_t aDefault = 2500;   // reasonably low (~0.5s for reaching the default speed)
+    static const int32_t vMaxMax;      // largest speed possible (steps/s)
+    static const uint32_t aMax;        // speed up to 500kHz within 1 s (steps/s^2)
+    static const uint32_t vMaxDefault; // should work with every motor (1 rev/sec in 1/4-step mode)
+    static const uint32_t aDefault;    // reasonably low (~0.5s for reaching the default speed)
 
   public:
     Stepper(const int StepPin, const int DirPin);
@@ -34,7 +34,7 @@ class Stepper
     inline void toggleDir();
 
     volatile int32_t current;
-    volatile int32_t currentSpeed; 
+    volatile int32_t currentSpeed;
     volatile int32_t target;
 
     int32_t A, B; // Bresenham paramters
@@ -44,8 +44,8 @@ class Stepper
     // compare functions
     static bool cmpDelta(const Stepper *a, const Stepper *b) { return a->A > b->A; }
     static bool cmpAcc(const Stepper *a, const Stepper *b) { return a->a < b->a; }
-    static bool cmpVmin(const Stepper *a, const Stepper *b) { return std::abs(a->vMax) < std::abs(b->vMax); }
-    static bool cmpVmax(const Stepper *a, const Stepper *b) { return std::abs(a->vMax) > std::abs(b->vMax); }
+    static bool cmpVmin(const Stepper *a, const Stepper *b) { return abs(a->vMax) < abs(b->vMax); }
+    static bool cmpVmax(const Stepper *a, const Stepper *b) { return abs(a->vMax) > abs(b->vMax); }
 
     // Pin & Dir registers
     volatile uint32_t *stepPinActiveReg;

src/TeensyStep.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include "version.h"
-
 #include "RotateControlBase.h"
 #include "StepControlBase.h"
 

src/accelerators/LinRotAccelerator.h

@@ -1,10 +1,8 @@
 #pragma once
 
-#include "wiring.h"
 
-#include <cmath>
-#include <cstdint>
-#include <algorithm>
+#include "Arduino.h"
+
 
 class LinRotAccelerator
 {
@@ -34,7 +32,7 @@ class LinRotAccelerator
 void LinRotAccelerator::prepareRotation(int32_t currentPosition, int32_t targetSpeed, uint32_t a, uint32_t accUpdatePeriod, float speedFactor)
 {
     v_tgt_orig = targetSpeed;
-    dv_orig = ((float)a * accUpdatePeriod) / 1E6;  
+    dv_orig = ((float)a * accUpdatePeriod) / 1E6;
     v_cur = 0;
 
     overrideAcceleration(1.0f);
@@ -44,7 +42,7 @@ void LinRotAccelerator::prepareRotation(int32_t currentPosition, int32_t targetS
 void LinRotAccelerator::overrideSpeed(float factor)
 {
     //Serial.printf("a:------ %d\n", a);
-
+    
     noInterrupts();
     v_tgt = v_tgt_orig * factor;
     dv = v_tgt > v_cur ? dv_cur : -dv_cur;
@@ -87,4 +85,3 @@ void LinRotAccelerator::eStop()
     v_tgt = 0.0f;
     interrupts();
 }
-   

src/accelerators/LinStepAccelerator.h

@@ -30,7 +30,7 @@ class LinStepAccelerator
 int32_t LinStepAccelerator::prepareMovement(int32_t currentPos, int32_t targetPos, uint32_t targetSpeed, uint32_t a)
 {
     s_0 = currentPos;
-    delta_tgt = std::abs(targetPos - currentPos);
+    delta_tgt = abs(targetPos - currentPos);
     v_tgt = targetSpeed;
     two_a = 2 * a;
     v_min2 = a;
@@ -44,7 +44,7 @@ int32_t LinStepAccelerator::prepareMovement(int32_t currentPos, int32_t targetPo
 
 int32_t LinStepAccelerator::updateSpeed(int32_t curPos)
 {
-    uint32_t stepsDone = std::abs(s_0 - curPos);
+    uint32_t stepsDone = abs(s_0 - curPos);
 
     // acceleration phase -------------------------------------
     if (stepsDone < accLength)
@@ -64,7 +64,7 @@ int32_t LinStepAccelerator::updateSpeed(int32_t curPos)
 
 uint32_t LinStepAccelerator::initiateStopping(int32_t curPos)
 {
-    uint32_t stepsDone = std::abs(s_0 - curPos);
+    uint32_t stepsDone = abs(s_0 - curPos);
 
     if (stepsDone < accLength)              // still accelerating
     {

src/timer/teensy3/config.h

@@ -7,10 +7,10 @@ namespace TeensyStepFTM
 {
 
 
-//========================================================================== 
-// Available timer modules for the Teensy XX boards. Please note that those 
-// timers are also used by the core libraries for PWM and AnalogWrite. 
-// Therefore, choose a timer which isn't attached to the pins you need for 
+//==========================================================================
+// Available timer modules for the Teensy XX boards. Please note that those
+// timers are also used by the core libraries for PWM and AnalogWrite.
+// Therefore, choose a timer which isn't attached to the pins you need for
 // PWM or AnalogWrite. (TEENSY LC not yet supported)
 //
 // D: Default, X: available
@@ -32,14 +32,14 @@ namespace TeensyStepFTM
 
 
 //==========================================================================
-// Nothing to be changed below here 
+// Nothing to be changed below here
 //==========================================================================
 
 
 
 #if USE_TIMER == TIMER_DEFAULT
 #undef USE_TIMER
-#if defined __MKL26Z64__    
+#if defined __MKL26Z64__
 #define USE_TIMER TIMER_TPM0
 #else
 #define USE_TIMER TIMER_FTM0
@@ -57,15 +57,15 @@ namespace TeensyStepFTM
         T_LC, T_30, T31_2, T_35, T_36
     };
 
-#if defined __MKL26Z64__      
+#if defined __MKL26Z64__
     constexpr _boards board = _boards::T_LC;
-#elif defined __MK20DX128__    
+#elif defined __MK20DX128__
     constexpr _boards board = _boards::T_30;
-#elif defined __MK20DX256__     
+#elif defined __MK20DX256__
     constexpr _boards board = _boards::T31_2;
-#elif defined __MK64FX512__    
+#elif defined __MK64FX512__
     constexpr _boards board = _boards::T_35;
-#elif defined __MK66FX1M0__    
+#elif defined __MK66FX1M0__
     constexpr _boards board = _boards::T_36;
 #endif
 
@@ -138,33 +138,33 @@ namespace TeensyStepFTM
         8,  // FTM3
         6,  // TPM0
         2,  // TPM1
-        2,  // TPM2 
+        2,  // TPM2
     };
 
     constexpr uintptr_t timerAddr = TimerBaseAddr[(int)board][selTimer];
-    constexpr volatile FTM_t* timer = __builtin_constant_p((FTM_t*)timerAddr) ? (FTM_t*)timerAddr : (FTM_t*)timerAddr; // base address for register block of selected timer
-    constexpr unsigned irq = IRQ_Number[(int)board][selTimer];                     // IRQ number of selected timer
-    constexpr unsigned maxChannel = _nrOfChannels[selTimer];                        // Number of channels for selected timer
+    volatile FTM_t *const timer = (FTM_t *)timerAddr;                   // base address for register block of selected timer
+    constexpr unsigned irq = IRQ_Number[(int)board][selTimer];          // IRQ number of selected timer
+    constexpr unsigned maxChannel = _nrOfChannels[selTimer];            // Number of channels for selected timer
 
-    static_assert(timer != nullptr && irq != 0, "Board does not support choosen timer");  //Generate compiler error in case the board does not support the selected timer
+    static_assert(timerAddr != 0 && irq != 0, "Board does not support choosen timer");  //Generate compiler error in case the board does not support the selected timer
 
     //-----------------------------------------------------------------------------------
-    //Frequency dependent settings 
+    //Frequency dependent settings
 
     constexpr unsigned _timer_frequency = isFTM ? F_BUS : 16000000;  // FTM timers are clocked with F_BUS, the TPM timers are clocked with OSCERCLK (16MHz for all teensies)
 
     // Choose prescaler such that one timer cycle corresponds to about 1µs
-    constexpr unsigned prescale = 
+    constexpr unsigned prescale =
         _timer_frequency > 120000000 ? 0b111 :
         _timer_frequency > 60000000 ? 0b110 :
-        _timer_frequency > 30000000 ? 0b101 : 
+        _timer_frequency > 30000000 ? 0b101 :
         _timer_frequency > 15000000 ? 0b100 :
         _timer_frequency > 8000000 ? 0b011 :
         _timer_frequency > 4000000 ? 0b010 :
         _timer_frequency > 2000000 ? 0b001 : 0b000;
 
-    // Calculates required reload value to get a delay of mu microseconds. 
-    // this will be completely evaluated by the compiler as long as mu is known at compile time 
+    // Calculates required reload value to get a delay of mu microseconds.
+    // this will be completely evaluated by the compiler as long as mu is known at compile time
     constexpr int microsToReload(const float mu)
     {
         return  mu * 1E-6 * _timer_frequency / (1 << prescale) + 0.5;