Merge remote-tracking branch 'origin/dev' into dev

Author: runger1101001

.github/workflows/ccpp.yml

@@ -26,14 +26,14 @@ jobs:
           - arduino:mbed_rp2040:pico                 # rpi pico          
         include:
           - arduino-boards-fqbn: arduino:avr:nano
-            sketches-exclude: calibrated mt6816_spi smoothing simplefocnano_torque_voltage
+            sketches-exclude: calibrated calibration_save mt6816_spi smoothing simplefocnano_torque_voltage
             required-libraries: Simple FOC
           - arduino-boards-fqbn: arduino:sam:arduino_due_x
             required-libraries: Simple FOC
-            sketches-exclude: calibrated smoothing simplefocnano_torque_voltage simplefocnano_atmega
+            sketches-exclude: calibrated calibration_save smoothing simplefocnano_torque_voltage simplefocnano_atmega
           - arduino-boards-fqbn: arduino:samd:nano_33_iot
             required-libraries: Simple FOC 
-            sketches-exclude: calibrated smoothing
+            sketches-exclude: calibrated calibration_save  smoothing
           - arduino-boards-fqbn: arduino:mbed_rp2040:pico
             required-libraries: Simple FOC
             sketches-exclude: calibrated smoothing simplefocnano_torque_voltage simplefocnano_atmega

examples/encoders/calibrated/calibrated.ino renamed to examples/encoders/calibrated_sensor/calibrated/calibrated.ino

@@ -1,10 +1,5 @@
 /**
- * Torque control example using voltage control loop.
- * 
- * Most of the low-end BLDC driver boards doesn't have current measurement therefore SimpleFOC offers 
- * you a way to control motor torque by setting the voltage to the motor instead hte current. 
- * 
- * This makes the BLDC motor effectively a DC motor, and you can use it in a same way.
+ * The example demonstrates the usage of the calibrated sensor object.
  */
 #include <SimpleFOC.h>
 #include <SimpleFOCDrivers.h>
@@ -16,6 +11,8 @@ MagneticSensorSPI sensor = MagneticSensorSPI(AS5048_SPI, PB6);
 BLDCMotor motor = BLDCMotor(11);
 BLDCDriver3PWM driver = BLDCDriver3PWM(PB4,PC7,PB10,PA9);
 // instantiate the calibrated sensor object
+// argument 1 - sensor object
+// argument 2 - number of samples in the LUT (default 200)
 CalibratedSensor sensor_calibrated = CalibratedSensor(sensor);
 
 // voltage set point variable
@@ -58,6 +55,7 @@ void setup() {
   // set voltage to run calibration
   sensor_calibrated.voltage_calibration = 6;
   // Running calibration
+  // it will ouptut the LUT and the zero electrical angle to the serial monitor !!!!
   sensor_calibrated.calibrate(motor); 
 
   //Serial.println("Calibrating Sensor Done.");

examples/encoders/calibrated_sensor/calibration_save/calibration_save.ino

@@ -0,0 +1,86 @@
+/**
+ * The example demonstrates the calibration of the magnetic sensor with the calibration procedure and saving the calibration data. 
+ * So that the calibration procedure does not have to be run every time the motor is powered up.
+ */
+
+#include <SimpleFOC.h>
+#include <SimpleFOCDrivers.h>
+#include "encoders/calibrated/CalibratedSensor.h"
+
+// fill this array with the calibration values outputed by the calibration procedure
+float calibrationLut[50] = {0};
+float zero_electric_angle = 0;
+Direction sensor_direction = Direction::CW;
+
+// magnetic sensor instance - SPI
+MagneticSensorSPI sensor = MagneticSensorSPI(AS5147_SPI, 14);
+// Stepper motor & driver instance
+StepperMotor motor = StepperMotor(50);
+StepperDriver4PWM driver = StepperDriver4PWM(10, 9, 5, 6,8);
+// instantiate the calibrated sensor object
+// instantiate the calibrated sensor object
+// argument 1 - sensor object
+// argument 2 - number of samples in the LUT (default 200)
+// argument 3 - pointer to the LUT array (defualt nullptr)
+CalibratedSensor sensor_calibrated = CalibratedSensor(sensor, 50);
+
+// voltage set point variable
+float target_voltage = 2;
+
+// instantiate the commander
+Commander command = Commander(Serial);
+
+void doTarget(char* cmd) { command.scalar(&target_voltage, cmd); }
+
+void setup() {
+
+  sensor.init();
+  // Link motor to sensor
+  motor.linkSensor(&sensor);
+  // power supply voltage
+  driver.voltage_power_supply = 20;
+  driver.init();
+  motor.linkDriver(&driver);
+  // aligning voltage 
+  motor.voltage_sensor_align = 8;
+  motor.voltage_limit = 20;
+  // set motion control loop to be used
+  motor.controller = MotionControlType::torque;
+
+  // use monitoring with serial 
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+  motor.monitor_variables =  _MON_VEL; 
+  motor.monitor_downsample = 10; // default 10
+
+  // initialize motor
+  motor.init();
+
+  // Running calibration
+  // the function will setup everything for the provided calibration LUT
+  sensor_calibrated.calibrate(motor, calibrationLut, zero_electric_angle, sensor_direction);
+
+  // Linking sensor to motor object
+  motor.linkSensor(&sensor_calibrated);
+
+  // calibrated init FOC
+  motor.initFOC();
+
+  // add target command T
+  command.add('T', doTarget, "target voltage");
+  
+  Serial.println(F("Motor ready."));
+
+  Serial.println(F("Set the target voltage using serial terminal:"));
+  _delay(1000);
+}
+
+void loop() {
+
+  motor.loopFOC();
+  motor.move(target_voltage);
+  command.run();
+  motor.monitor();
+ 
+}

examples/encoders/smoothing/smoothing.ino

@@ -1,6 +1,9 @@
 /**
  *
- * Hall sensor velocity motion control example, modified to demonstrate usage of SmoothingSensor
+ * Hall sensor velocity motion control example, modified to demonstrate usage of SmoothingSensor. 
+ * The only changes are the declaration of the SmoothingSensor, passing it to motor.linkSensor 
+ * instead of the HallSensor instance, and the added Commander code to switch between the two.
+ *
  * Steps:
  * 1) Configure the motor and sensor
  * 2) Run the code
@@ -63,8 +66,6 @@ void setup() {
   sensor.enableInterrupts(doA, doB); //, doC);
   // software interrupts
   PciManager.registerListener(&listenerIndex);
-  // set SmoothingSensor phase correction for hall sensors
-  smooth.phase_correction = -_PI_6;
   // link the SmoothingSensor to the motor
   motor.linkSensor(&smooth);
 

src/comms/stm32speeddir/README.md

@@ -21,6 +21,10 @@ The direction input is optional - if not provided, you can control the direction
 
 The velocity values returned are in the range `min_speed` to `max_speed`, while the input PWM duty cycle should lie within the range `min_pwm` to `max_pwm`. Actual input values smaller than `min_pwm` will be treated as `min_pwm`, values larger than `max_pwm` will be treated as `max_pwm`. The behaviour for 100% or 0% duty cycles is undefined, and they should be avoided.
 
+> **IMPORTANT**<br>
+> If the PWM frequency of the speed input is not known, provide its value in Hz to the constructor. If not provided, it will default to 1kHz (very common value). The frequency is used to make sure that the PWM period stays within one timer counter period. If this is not the case the timer counter can overflow and the input will not work correctly.
+
+
 ## Usage
 
 Use it like this:
@@ -31,8 +35,9 @@ Use it like this:
 // some example pins - the speed pin has to be on channel 1 or 2 of a timer
 #define PIN_SPEED PC6
 #define PIN_DIRECTION PB8
+#define PWM_FREQUENCY 1000 // 1kHz (defualt)
 
-STM32SpeedDirInput speed_dir = STM32SpeedDirInput(PIN_SPEED, PIN_DIRECTION);
+STM32SpeedDirInput speed_dir = STM32SpeedDirInput(PIN_SPEED, PIN_DIRECTION, PWM_FREQUENCY);
 
 float target = 0.0f;
 

src/comms/stm32speeddir/STM32SpeedDirInput.cpp

@@ -3,7 +3,7 @@
 
 #if defined(_STM32_DEF_)
 
-STM32SpeedDirInput::STM32SpeedDirInput(int pin_speed, int pin_dir) : STM32PWMInput(pin_speed) {
+STM32SpeedDirInput::STM32SpeedDirInput(int pin_speed, int pin_dir, uint32_t pwm_freq) : STM32PWMInput(pin_speed, _pwm_freq) {
     _pin_speed = pin_speed;
     _pin_dir = pin_dir;
 };

src/comms/stm32speeddir/STM32SpeedDirInput.h

@@ -10,7 +10,21 @@
 
 class STM32SpeedDirInput : public STM32PWMInput {
     public:
-        STM32SpeedDirInput(int pin_speed, int pin_dir = NOT_SET);
+
+        /**
+         * STM32SpeedDirInput constructor
+         * 
+         * @param pin_speed - the pin number to read the speed PWM signal from
+         * @param pin_dir - the pin number to read the direction signal from (default is NOT_SET)
+         * @param pwm_freq - the frequency of the PWM signal (default is 1kHz)
+         * 
+         * This class is used to read speed and direction signals from a pin using the STM32 HAL library.
+         * IMPORTANT!
+         *      This class can only be used with the pins that are associated with some timer,
+         *      and only if they are associated to the channels 1 or 2. The timer can not be
+         *      used for other purposes, like motor control.
+         */
+        STM32SpeedDirInput(int pin_speed, int pin_dir = NOT_SET, uint32_t pwm_freq = 1000);
         ~STM32SpeedDirInput();
 
         int init();