FEAT added separate driver classes

Author: askuric

keywords.txt

@@ -8,6 +8,10 @@ HallSensors	KEYWORD1
 MagneticSensorSPI	KEYWORD1
 MagneticSensorI2C	KEYWORD1
 MagneticSensorAnalog	KEYWORD1
+BLDCDriver3PWM	KEYWORD1    
+BLDCDriver	KEYWORD1    
+StepperDriver4PWM	KEYWORD1    
+StepperDriver	KEYWORD1    
 
 initFOC	KEYWORD2
 loopFOC	KEYWORD2
@@ -36,6 +40,7 @@ Direction	KEYWORD1
 MagneticSensorI2CConfig_s	KEYWORD1
 MagneticSensorSPIConfig_s	KEYWORD1
 
+linkDriver	KEYWORD2
 linkSensor	KEYWORD2
 handleA	KEYWORD2
 handleB	KEYWORD2
@@ -60,11 +65,11 @@ shaft_velocity_sp	KEYWORD2
 shaft_angle	KEYWORD2
 shaft_velocity	KEYWORD2
 controller	KEYWORD2
-driver	KEYWORD2
 pullup	KEYWORD2
 quadrature	KEYWORD2
 foc_modulation	KEYWORD2
 target	KEYWORD2
+pwm_frequency	KEYWORD2
 
 
 voltage	KEYWORD2

src/BLDCDriver3PWM.cpp

@@ -0,0 +1,69 @@
+#include "BLDCDriver3PWM.h"
+
+BLDCDriver3PWM::BLDCDriver3PWM(int phA, int phB, int phC, int en){
+  // Pin initialization
+  pwmA = phA;
+  pwmB = phB;
+  pwmC = phC;
+
+  // enable_pin pin
+  enable_pin = en;
+
+  // default power-supply value
+  voltage_power_supply = DEF_POWER_SUPPLY;
+  voltage_limit = NOT_SET
+
+}
+
+// enable motor driver
+void  BLDCDriver3PWM::enable(){
+    // enable_pin the driver - if enable_pin pin available
+    if ( enable_pin != NOT_SET ) digitalWrite(enable_pin, HIGH);
+    // set zero to PWM
+    setPwm(0,0,0);
+}
+
+// disable motor driver
+void BLDCDriver3PWM::disable()
+{
+  // set zero to PWM
+  setPwm(0, 0, 0);
+  // disable the driver - if enable_pin pin available
+  if ( enable_pin != NOT_SET ) digitalWrite(enable_pin, LOW);
+
+}
+
+// init hardware pins   
+void BLDCDriver3PWM::init() {
+
+  // PWM pins
+  pinMode(pwmA, OUTPUT);
+  pinMode(pwmB, OUTPUT);
+  pinMode(pwmC, OUTPUT);
+  if(enable_pin != NOT_SET) pinMode(enable_pin, OUTPUT);
+
+
+  // sanity check for the voltage limit configuration
+  if(voltage_limit == NOT_SET || voltage_limit > voltage_power_supply) voltage_limit =  voltage_power_supply;
+
+  // Set the pwm frequency to the pins
+  // hardware specific function - depending on driver and mcu
+  _setPwmFrequency(pwm_frequency, pwmA, pwmB, pwmC);
+}
+
+
+// Set voltage to the pwm pin
+void BLDCDriver3PWM::setPwm(float Ua, float Ub, float Uc) {  
+  // limit the voltage in driver
+  Ua = _constrain(Ua, -voltage_limit, voltage_limit);
+  Ub = _constrain(Ub, -voltage_limit, voltage_limit);
+  Uc = _constrain(Uc, -voltage_limit, voltage_limit);    
+  // calculate duty cycle
+  // limited in [0,1]
+  float dc_a = _constrain(Ua / voltage_power_supply, 0 , 1 );
+  float dc_b = _constrain(Ub / voltage_power_supply, 0 , 1 );
+  float dc_c = _constrain(Uc / voltage_power_supply, 0 , 1 );
+  // hardware specific writing
+  // hardware specific function - depending on driver and mcu
+  _writeDutyCycle(dc_a, dc_b, dc_c, pwmA, pwmB, pwmC);
+}

src/BLDCDriver3PWM.h

@@ -0,0 +1,51 @@
+#ifndef BLDCDriver3PWM_h
+#define BLDCDriver3PWM_h
+
+#include "common/interfaces/BLDCDriver.h"
+#include "common/foc_utils.h"
+#include "common/hardware_utils.h"
+#include "common/defaults.h"
+
+/**
+ 3 pwm bldc driver class
+*/
+class BLDCDriver3PWM: public BLDCDriver
+{
+  public:
+    /**
+      BLDCDriver class constructor
+      @param phA A phase pwm pin
+      @param phB B phase pwm pin
+      @param phC C phase pwm pin
+      @param en enable pin (optional input)
+    */
+    BLDCDriver3PWM(int phA,int phB,int phC, int en = NOT_SET);
+    
+    /**  Motor hardware init function */
+  	void init() override;
+    /** Motor disable function */
+  	void disable() override;
+    /** Motor enable function */
+    void enable() override;
+
+    // hardware variables
+  	int pwmA; //!< phase A pwm pin number
+  	int pwmB; //!< phase B pwm pin number
+  	int pwmC; //!< phase C pwm pin number
+    int enable_pin; //!< enable pin number
+
+    /** 
+     * Set phase voltages to the harware 
+     * 
+     * @param Ua - phase A voltage
+     * @param Ub - phase B voltage
+     * @param Uc - phase C voltage
+    */
+    void setPwm(float Ua, float Ub, float Uc) override;
+
+  private:
+        
+};
+
+
+#endif

src/BLDCMotor.cpp

@@ -5,37 +5,35 @@
 // - pp            - pole pair number
 // - cpr           - counts per rotation number (cpm=ppm*4)
 // - enable pin    - (optional input)
-BLDCMotor::BLDCMotor(int phA, int phB, int phC, int pp, int en)
+BLDCMotor::BLDCMotor( int phA, int phB, int phC, int pp, int cpr, int en){
+  
+}
+
+// BLDCMotor( int pp)
+// - phA, phB, phC - motor A,B,C phase pwm pins
+// - pp            - pole pair number
+// - cpr           - counts per rotation number (cpm=ppm*4)
+// - enable pin    - (optional input)
+BLDCMotor::BLDCMotor(int pp)
 : FOCMotor()
 {
-  // Pin initialization
-  pwmA = phA;
-  pwmB = phB;
-  pwmC = phC;
+  // save pole pairs number
   pole_pairs = pp;
+}
 
-  // enable_pin pin
-  enable_pin = en;
 
+/**
+	Link the driver which controls the motor
+*/
+void BLDCMotor::linkDriver(BLDCDriver* _driver) {
+  driver = _driver;
 }
 
-
 // init hardware pins   
-void BLDCMotor::init(long pwm_frequency) {
-  if(monitor_port) monitor_port->println("MOT: Init pins.");
-  // PWM pins
-  pinMode(pwmA, OUTPUT);
-  pinMode(pwmB, OUTPUT);
-  pinMode(pwmC, OUTPUT);
-  if(enable_pin != NOT_SET) pinMode(enable_pin, OUTPUT);
-
-  if(monitor_port) monitor_port->println("MOT: PWM config.");
-  // Increase PWM frequency to 32 kHz
-  // make silent
-  _setPwmFrequency(pwm_frequency, pwmA, pwmB, pwmC);
-
+void BLDCMotor::init() {
+  if(monitor_port) monitor_port->println("MOT: Initialise variables.");
   // sanity check for the voltage limit configuration
-  if(voltage_limit > voltage_power_supply) voltage_limit =  voltage_power_supply;
+  if(voltage_limit > driver->voltage_power_supply) voltage_limit =  driver->voltage_power_supply;
   // constrain voltage for sensor alignment
   if(voltage_sensor_align > voltage_limit) voltage_sensor_align = voltage_limit;
   // update the controller limits
@@ -44,7 +42,7 @@ void BLDCMotor::init(long pwm_frequency) {
 
   _delay(500);
   // enable motor
-  if(monitor_port) monitor_port->println("MOT: Enable.");
+  if(monitor_port) monitor_port->println("MOT: Enable driver.");
   enable();
   _delay(500);
 }
@@ -53,18 +51,18 @@ void BLDCMotor::init(long pwm_frequency) {
 // disable motor driver
 void BLDCMotor::disable()
 {
-  // disable the driver - if enable_pin pin available
-  if (enable_pin != NOT_SET) digitalWrite(enable_pin, LOW);
   // set zero to PWM
-  setPwm(0, 0, 0);
+  driver->setPwm(0, 0, 0);
+  // disable the driver 
+  driver->disable();
 }
 // enable motor driver
 void BLDCMotor::enable()
 {
+  // enable the driver 
+  driver->enable();
   // set zero to PWM
-  setPwm(0, 0, 0);
-  // enable_pin the driver - if enable_pin pin available
-  if (enable_pin != NOT_SET) digitalWrite(enable_pin, HIGH);
+  driver->setPwm(0, 0, 0);
 
 }
 
@@ -240,9 +238,9 @@ void BLDCMotor::setPhaseVoltage(float Uq, float angle_el) {
       Ubeta =  _cos(angle_el) * Uq;    //  cos(angle) * Uq;
 
       // Clarke transform
-      Ua = Ualpha + voltage_power_supply/2;
-      Ub = -0.5 * Ualpha  + _SQRT3_2 * Ubeta + voltage_power_supply/2;
-      Uc = -0.5 * Ualpha - _SQRT3_2 * Ubeta + voltage_power_supply/2;
+      Ua = Ualpha + driver->voltage_power_supply/2;
+      Ub = -0.5 * Ualpha  + _SQRT3_2 * Ubeta + driver->voltage_power_supply/2;
+      Uc = -0.5 * Ualpha - _SQRT3_2 * Ubeta + driver->voltage_power_supply/2;
       break;
 
     case FOCModulationType::SpaceVectorPWM :
@@ -261,10 +259,10 @@ void BLDCMotor::setPhaseVoltage(float Uq, float angle_el) {
       // find the sector we are in currently
       int sector = floor(angle_el / _PI_3) + 1;
       // calculate the duty cycles
-      float T1 = _SQRT3*_sin(sector*_PI_3 - angle_el) * Uq/voltage_power_supply;
-      float T2 = _SQRT3*_sin(angle_el - (sector-1.0)*_PI_3) * Uq/voltage_power_supply;
+      float T1 = _SQRT3*_sin(sector*_PI_3 - angle_el) * Uq/driver->voltage_power_supply;
+      float T2 = _SQRT3*_sin(angle_el - (sector-1.0)*_PI_3) * Uq/driver->voltage_power_supply;
       // two versions possible 
-      // centered around voltage_power_supply/2
+      // centered around driver->voltage_power_supply/2
       float T0 = 1 - T1 - T2;
       // pulled to 0 - better for low power supply voltage
       //float T0 = 0;
@@ -310,27 +308,14 @@ void BLDCMotor::setPhaseVoltage(float Uq, float angle_el) {
       }
 
       // calculate the phase voltages and center
-      Ua = Ta*voltage_power_supply;
-      Ub = Tb*voltage_power_supply;
-      Uc = Tc*voltage_power_supply;
+      Ua = Ta*driver->voltage_power_supply;
+      Ub = Tb*driver->voltage_power_supply;
+      Uc = Tc*driver->voltage_power_supply;
       break;
   }
 
-  // set the voltages in hardware
-  setPwm(Ua, Ub, Uc);
-}
-
-
-
-// Set voltage to the pwm pin
-void BLDCMotor::setPwm(float Ua, float Ub, float Uc) {      
-  // calculate duty cycle
-  // limited in [0,1]
-  float dc_a = constrain(Ua / voltage_power_supply, 0 , 1 );
-  float dc_b = constrain(Ub / voltage_power_supply, 0 , 1 );
-  float dc_c = constrain(Uc / voltage_power_supply, 0 , 1 );
-  // hardware specific writing
-  _writeDutyCycle(dc_a, dc_b, dc_c, pwmA, pwmB, pwmC );
+  // set the voltages in driver
+  driver->setPwm(Ua, Ub, Uc);
 }
 
 

src/BLDCMotor.h

@@ -9,6 +9,7 @@
 #include "Arduino.h"
 #include "common/interfaces/FOCMotor.h"
 #include "common/interfaces/Sensor.h"
+#include "common/interfaces/BLDCDriver.h"
 #include "common/foc_utils.h"
 #include "common/hardware_utils.h"
 #include "common/defaults.h"
@@ -20,18 +21,28 @@ class BLDCMotor: public FOCMotor
 {
   public:
     /**
-      BLDCMotor class constructor
-      @param phA A phase pwm pin
-      @param phB B phase pwm pin
-      @param phC C phase pwm pin
-      @param pp  pole pair number
-      @param cpr counts per rotation number (cpm=ppm*4)
-      @param en enable pin (optional input)
+     BLDCMotor class constructor
+     @param pp pole pairs number
+     */ 
+    BLDCMotor(int pp);
+    
+
+    /**
+     * Function linking a motor and a foc driver 
+     * 
+     * @param driver BLDCDriver class implementing all the hardware specific functions necessary PWM setting
+     */
+    void linkDriver(BLDCDriver* driver);
+
+    /** 
+      * BLDCDriver link:
+      * - 3PWM 
+      * - 6PWM 
     */
-    BLDCMotor(int phA,int phB,int phC,int pp, int en = NOT_SET);
+    BLDCDriver* driver; 
 
     /**  Motor hardware init function */
-  	void init(long pwm_frequency = NOT_SET) override;
+  	void init() override;
     /** Motor disable function */
   	void disable() override;
     /** Motor enable function */
@@ -59,12 +70,9 @@ class BLDCMotor: public FOCMotor
      * This function doesn't need to be run upon each loop execution - depends of the use case
      */
     void move(float target = NOT_SET) override;
-
-    // hardware variables
-  	int pwmA; //!< phase A pwm pin number
-  	int pwmB; //!< phase B pwm pin number
-  	int pwmC; //!< phase C pwm pin number
-    int enable_pin; //!< enable pin number
+    
+    float Ua,Ub,Uc;//!< Current phase voltages Ua,Ub and Uc set to motor
+    float	Ualpha,Ubeta; //!< Phase voltages U alpha and U beta used for inverse Park and Clarke transform
 
 
   private:
@@ -81,14 +89,7 @@ class BLDCMotor: public FOCMotor
     int alignSensor();
     /** Motor and sensor alignment to the sensors absolute 0 angle  */
     int absoluteZeroAlign();
-    /** 
-     * Set phase voltages to the harware 
-     * 
-     * @param Ua phase A voltage
-     * @param Ub phase B voltage
-     * @param Uc phase C voltage
-    */
-    void setPwm(float Ua, float Ub, float Uc);
+
 
     // Open loop motion control    
     /**

src/SimpleFOC.h

@@ -93,5 +93,7 @@ void loop() {
 #include "MagneticSensorI2C.h"
 #include "MagneticSensorAnalog.h"
 #include "HallSensor.h"
+#include "BLDCDriver3PWM.h"
+#include "StepperDriver4PWM.h"
 
 #endif