v1.2版本改为通过xbox系列手柄进行遥控,并增加智能模式和手动模式

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/B_G431B_ESC1/B_G431B_ESC1.ino

@@ -0,0 +1,112 @@
+/** 
+ * B-G431B-ESC1 position motion control example with encoder
+ *
+ */
+#include <SimpleFOC.h>
+
+// Motor instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver6PWM driver = BLDCDriver6PWM(PHASE_UH, PHASE_UL, PHASE_VH, PHASE_VL, PHASE_WH, PHASE_WL);
+LowsideCurrentSense currentSense = LowsideCurrentSense(0.003, -64.0/7.0, OP1_OUT, OP2_OUT, OP3_OUT);
+
+
+// encoder instance
+Encoder encoder = Encoder(HALL2, HALL3, 2048, HALL1);
+
+// Interrupt routine intialisation
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+void doIndex(){encoder.handleIndex();}
+
+// angle set point variable
+float target_angle = 0;
+// instantiate the commander
+Commander command = Commander(Serial);
+void doTarget(char* cmd) { command.scalar(&target_angle, cmd); }
+
+void setup() {
+  
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB); 
+
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+  
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+
+  // current sensing
+  currentSense.init();
+  // no need for aligning
+  currentSense.skip_align = true;
+  motor.linkCurrentSense(&currentSense);
+
+  // aligning voltage [V]
+  motor.voltage_sensor_align = 3;
+  // index search velocity [rad/s]
+  motor.velocity_index_search = 3;
+
+  // set motion control loop to be used
+  motor.controller = MotionControlType::velocity;
+
+  // contoller configuration 
+  // default parameters in defaults.h
+
+  // velocity PI controller parameters
+  motor.PID_velocity.P = 0.2;
+  motor.PID_velocity.I = 20;
+  // default voltage_power_supply
+  motor.voltage_limit = 6;
+  // jerk control using voltage voltage ramp
+  // default value is 300 volts per sec  ~ 0.3V per millisecond
+  motor.PID_velocity.output_ramp = 1000;
+ 
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01;
+
+  // angle P controller
+  motor.P_angle.P = 20;
+  //  maximal velocity of the position control
+  motor.velocity_limit = 4;
+
+
+  // use monitoring with serial 
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+  
+  // initialize motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // add target command T
+  command.add('T', doTarget, "target angle");
+
+  Serial.println(F("Motor ready."));
+  Serial.println(F("Set the target angle using serial terminal:"));
+  _delay(1000);
+}
+
+// angle set point variable
+float target_angle = 0;
+
+void loop() {
+  // main FOC algorithm function
+
+  // Motion control function
+  motor.move(target_angle);
+
+  // function intended to be used with serial plotter to monitor motor variables
+  // significantly slowing the execution down!!!!
+  // motor.monitor();
+  
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/B_G431B_ESC1/build_opt.h

@@ -0,0 +1 @@
+-DHAL_OPAMP_MODULE_ENABLED

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/Bluepill_examples/encoder/bluepill_position_control/bluepill_position_control.ino

@@ -0,0 +1,115 @@
+/**
+ *
+ * STM32 Bluepill position motion control example with encoder
+ *
+ * The same example can be ran with any STM32 board - just make sure that put right pin numbers.
+ *
+ */
+#include <SimpleFOC.h>
+
+// Motor instance
+BLDCMotor motor = BLDCMotor(11);
+// BLDCDriver3PWM(IN1, IN2, IN3, enable(optional))
+BLDCDriver3PWM driver = BLDCDriver3PWM(PB6, PB7, PB8, PB5);
+// BLDCDriver6PWM(IN1_H, IN1_L, IN2_H, IN2_L, IN3_H, IN3_L, enable(optional))
+//BLDCDriver6PWM driver = BLDCDriver6PWM(PA8, PB13, PA9, PB14, PA10, PB15, PB12);
+
+// encoder instance
+Encoder encoder = Encoder(PA8, PA9, 8192, PA10);
+
+// Interrupt routine intialisation
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+void doI(){encoder.handleIndex();}
+
+
+// angle set point variable
+float target_angle = 0;
+// instantiate the commander
+Commander command = Commander(Serial);
+void doTarget(char* cmd) { command.scalar(&target_angle, cmd); }
+
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB, doI);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+
+  // aligning voltage [V]
+  motor.voltage_sensor_align = 3;
+  // index search velocity [rad/s]
+  motor.velocity_index_search = 3;
+
+  // set motion control loop to be used
+  motor.controller = MotionControlType::velocity;
+
+  // contoller configuration
+  // default parameters in defaults.h
+
+  // velocity PI controller parameters
+  motor.PID_velocity.P = 0.2f;
+  motor.PID_velocity.I = 20;
+  // default voltage_power_supply
+  motor.voltage_limit = 6;
+  // jerk control using voltage voltage ramp
+  // default value is 300 volts per sec  ~ 0.3V per millisecond
+  motor.PID_velocity.output_ramp = 1000;
+
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle P controller
+  motor.P_angle.P = 20;
+  //  maximal velocity of the position control
+  motor.velocity_limit = 4;
+
+
+  // use monitoring with serial
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+  // initialize motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // add target command T
+  command.add('T', doTarget, "target angle");
+
+  Serial.println(F("Motor ready."));
+  Serial.println(F("Set the target angle using serial terminal:"));
+  _delay(1000);
+}
+
+void loop() {
+  // main FOC algorithm function
+  // the faster you run this function the better
+  // Arduino UNO loop  ~1kHz
+  // Bluepill loop ~10kHz
+  motor.loopFOC();
+
+  // Motion control function
+  // velocity, position or voltage (defined in motor.controller)
+  // this function can be run at much lower frequency than loopFOC() function
+  // You can also use motor.move() and set the motor.target in the code
+  motor.move(target_angle);
+
+  // function intended to be used with serial plotter to monitor motor variables
+  // significantly slowing the execution down!!!!
+  // motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/Bluepill_examples/magnetic_sensor/bluepill_position_control/bluepill_position_control.ino

@@ -0,0 +1,115 @@
+/**
+ *
+ * STM32 Bluepill position motion control example with magnetic sensor
+ *
+ * The same example can be ran with any STM32 board - just make sure that put right pin numbers.
+ *
+ */
+#include <SimpleFOC.h>
+
+// SPI Magnetic sensor instance (AS5047U example)
+// MISO PA7
+// MOSI PA6
+// SCK PA5
+MagneticSensorSPI sensor = MagneticSensorSPI(PA4, 14, 0x3FFF);
+
+// I2C Magnetic sensor instance (AS5600 example)
+// make sure to use the pull-ups!!
+// SDA PB7
+// SCL PB6
+//MagneticSensorI2C sensor = MagneticSensorI2C(0x36, 12, 0X0C, 4);
+
+// Motor instance
+BLDCMotor motor = BLDCMotor(11);
+// BLDCDriver3PWM(IN1, IN2, IN3, enable(optional))
+BLDCDriver3PWM driver = BLDCDriver3PWM(PB6, PB7, PB8, PB5);
+// BLDCDriver6PWM(IN1_H, IN1_L, IN2_H, IN2_L, IN3_H, IN3_L, enable(optional))
+//BLDCDriver6PWM driver = BLDCDriver6PWM(PA8, PB13, PA9, PB14, PA10, PB15, PB12);
+
+
+// angle set point variable
+float target_angle = 0;
+// instantiate the commander
+Commander command = Commander(Serial);
+void doTarget(char* cmd) { command.scalar(&target_angle, cmd); }
+
+
+void setup() {
+
+  // initialise magnetic sensor hardware
+  sensor.init();
+  // link the motor to the sensor
+  motor.linkSensor(&sensor);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+
+  // choose FOC modulation (optional)
+  motor.foc_modulation = FOCModulationType::SpaceVectorPWM;
+
+  // set motion control loop to be used
+  motor.controller = MotionControlType::angle;
+
+  // contoller configuration
+  // default parameters in defaults.h
+
+  // velocity PI controller parameters
+  motor.PID_velocity.P = 0.2f;
+  motor.PID_velocity.I = 20;
+  // maximal voltage to be set to the motor
+  motor.voltage_limit = 6;
+
+  // velocity low pass filtering time constant
+  // the lower the less filtered
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle P controller
+  motor.P_angle.P = 20;
+  // maximal velocity of the position control
+  motor.velocity_limit = 40;
+
+  // use monitoring with serial
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+
+  // initialize motor
+  motor.init();
+  // align sensor and start FOC
+  motor.initFOC();
+
+  // add target command T
+  command.add('T', doTarget, "target angle");
+
+  Serial.println(F("Motor ready."));
+  Serial.println(F("Set the target angle using serial terminal:"));
+  _delay(1000);
+}
+
+void loop() {
+
+  // main FOC algorithm function
+  // the faster you run this function the better
+  // Arduino UNO loop  ~1kHz
+  // Bluepill loop ~10kHz
+  motor.loopFOC();
+
+  // Motion control function
+  // velocity, position or voltage (defined in motor.controller)
+  // this function can be run at much lower frequency than loopFOC() function
+  // You can also use motor.move() and set the motor.target in the code
+  motor.move(target_angle);
+
+
+  // function intended to be used with serial plotter to monitor motor variables
+  // significantly slowing the execution down!!!!
+  // motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/DRV8302_driver/3pwm_example/encoder/full_control_serial/full_control_serial.ino

@@ -0,0 +1,130 @@
+/**
+ * Comprehensive BLDC motor control example using encoder and the DRV8302 board
+ *
+ * Using serial terminal user can send motor commands and configure the motor and FOC in real-time:
+ * - configure PID controller constants
+ * - change motion control loops
+ * - monitor motor variabels
+ * - set target values
+ * - check all the configuration values
+ *
+ * check the https://docs.simplefoc.com for full list of motor commands
+ *
+ */
+#include <SimpleFOC.h>
+
+// DRV8302 pins connections
+// don't forget to connect the common ground pin
+#define INH_A 9
+#define INH_B 10
+#define INH_C 11
+
+#define EN_GATE 7
+#define M_PWM A1
+#define M_OC A2
+#define OC_ADJ A3
+
+// Motor instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver3PWM driver = BLDCDriver3PWM(INH_A, INH_B, INH_C, EN_GATE);
+
+// encoder instance
+Encoder encoder = Encoder(2, 3, 8192);
+
+// Interrupt routine intialisation
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+
+// commander interface
+Commander command = Commander(Serial);
+void onMotor(char* cmd){ command.motor(&motor, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // DRV8302 specific code
+  // M_OC  - enable overcurrent protection
+  pinMode(M_OC,OUTPUT);
+  digitalWrite(M_OC,LOW);
+  // M_PWM  - enable 3pwm mode
+  pinMode(M_PWM,OUTPUT);
+  digitalWrite(M_PWM,HIGH);
+  // OD_ADJ - set the maximum overcurrent limit possible
+  // Better option would be to use voltage divisor to set exact value
+  pinMode(OC_ADJ,OUTPUT);
+  digitalWrite(OC_ADJ,HIGH);
+
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+
+
+  // choose FOC modulation
+  motor.foc_modulation = FOCModulationType::SpaceVectorPWM;
+
+  // set control loop type to be used
+  motor.controller = MotionControlType::torque;
+
+  // contoller configuration based on the controll type
+  motor.PID_velocity.P = 0.2f;
+  motor.PID_velocity.I = 20;
+  // default voltage_power_supply
+  motor.voltage_limit = 12;
+
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle loop controller
+  motor.P_angle.P = 20;
+  // angle loop velocity limit
+  motor.velocity_limit = 50;
+
+  // use monitoring with serial for motor init
+  // monitoring port
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+  // initialise motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // set the inital target value
+  motor.target = 2;
+
+  // define the motor id
+  command.add('A', onMotor, "motor");
+
+  Serial.println(F("Full control example: "));
+  Serial.println(F("Run user commands to configure and the motor (find the full command list in docs.simplefoc.com) \n "));
+  Serial.println(F("Initial motion control loop is voltage loop."));
+  Serial.println(F("Initial target voltage 2V."));
+
+  _delay(1000);
+}
+
+
+void loop() {
+  // iterative setting FOC phase voltage
+  motor.loopFOC();
+
+  // iterative function setting the outter loop target
+  // velocity, position or voltage
+  // if tatget not set in parameter uses motor.target variable
+  motor.move();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/DRV8302_driver/6pwm_example/encoder/full_control_serial/full_control_serial.ino

@@ -0,0 +1,131 @@
+/**
+ * Comprehensive BLDC motor control example using encoder and the DRV8302 board
+ *
+ * Using serial terminal user can send motor commands and configure the motor and FOC in real-time:
+ * - configure PID controller constants
+ * - change motion control loops
+ * - monitor motor variabels
+ * - set target values
+ * - check all the configuration values
+ *
+ * check the https://docs.simplefoc.com for full list of motor commands
+ *
+ */
+#include <SimpleFOC.h>
+
+// DRV8302 pins connections
+// don't forget to connect the common ground pin
+#define INH_A 3
+#define INH_B 5
+#define INH_C 9
+#define INL_A 11
+#define INL_B 6
+#define INL_C 10
+
+#define EN_GATE 7
+#define M_PWM A1
+#define M_OC A2
+#define OC_ADJ A3
+
+// Motor instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver6PWM driver = BLDCDriver6PWM(INH_A,INH_A, INH_B,INH_B, INH_C,INL_C, EN_GATE);
+
+// encoder instance
+Encoder encoder = Encoder(2, 3, 8192);
+
+// Interrupt routine intialisation
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+
+// commander interface
+Commander command = Commander(Serial);
+void onMotor(char* cmd){ command.motor(&motor, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // DRV8302 specific code
+  // M_OC  - enable overcurrent protection
+  pinMode(M_OC,OUTPUT);
+  digitalWrite(M_OC,LOW);
+  // M_PWM  - disable 3pwm mode
+  pinMode(M_PWM,OUTPUT);
+  digitalWrite(M_PWM, LOW);
+  // OD_ADJ - set the maximum overcurrent limit possible
+  // Better option would be to use voltage divisor to set exact value
+  pinMode(OC_ADJ,OUTPUT);
+  digitalWrite(OC_ADJ,HIGH);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+
+  // choose FOC modulation
+  motor.foc_modulation = FOCModulationType::SpaceVectorPWM;
+
+  // set control loop type to be used
+  motor.controller = MotionControlType::torque;
+
+  // contoller configuration based on the controll type
+  motor.PID_velocity.P = 0.2f;
+  motor.PID_velocity.I = 20;
+  // default voltage_power_supply
+  motor.voltage_limit = 12;
+
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle loop controller
+  motor.P_angle.P = 20;
+  // angle loop velocity limit
+  motor.velocity_limit = 50;
+
+  // use monitoring with serial for motor init
+  // monitoring port
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+  // initialise motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // set the inital target value
+  motor.target = 2;
+
+  // define the motor id
+  command.add('A', onMotor, "motor");
+
+  Serial.println(F("Full control example: "));
+  Serial.println(F("Run user commands to configure and the motor (find the full command list in docs.simplefoc.com) \n "));
+  Serial.println(F("Initial motion control loop is voltage loop."));
+  Serial.println(F("Initial target voltage 2V."));
+
+  _delay(1000);
+}
+
+
+void loop() {
+  // iterative setting FOC phase voltage
+  motor.loopFOC();
+
+  // iterative function setting the outter loop target
+  // velocity, position or voltage
+  // if tatget not set in parameter uses motor.target variable
+  motor.move();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/DRV8302_driver/esp32_current_control_low_side/esp32_current_control_low_side.ino

@@ -0,0 +1,164 @@
+/**
+ * Comprehensive BLDC motor control example using encoder and the DRV8302 board
+ *
+ * Using serial terminal user can send motor commands and configure the motor and FOC in real-time:
+ * - configure PID controller constants
+ * - change motion control loops
+ * - monitor motor variabels
+ * - set target values
+ * - check all the configuration values
+ *
+ * check the https://docs.simplefoc.com for full list of motor commands
+ *
+ */
+#include <SimpleFOC.h>
+
+// DRV8302 pins connections
+// don't forget to connect the common ground pin
+#define INH_A 21
+#define INH_B 19
+#define INH_C 18
+
+#define EN_GATE 5
+#define M_PWM 25
+#define M_OC 26
+#define OC_ADJ 12
+#define OC_GAIN 14
+
+#define IOUTA 34
+#define IOUTB 35
+#define IOUTC 32
+
+// Motor instance
+BLDCMotor motor = BLDCMotor(7);
+BLDCDriver3PWM driver = BLDCDriver3PWM(INH_A, INH_B, INH_C, EN_GATE);
+
+// DRV8302 board has 0.005Ohm shunt resistors and the gain of 12.22 V/V
+LowsideCurrentSense cs = LowsideCurrentSense(0.005f, 12.22f, IOUTA, IOUTB, IOUTC);
+
+// encoder instance
+Encoder encoder = Encoder(22, 23, 500);
+
+// Interrupt routine intialisation
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+
+// commander interface
+Commander command = Commander(Serial);
+void onMotor(char* cmd){ command.motor(&motor, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // DRV8302 specific code
+  // M_OC  - enable overcurrent protection
+  pinMode(M_OC,OUTPUT);
+  digitalWrite(M_OC,LOW);
+  // M_PWM  - enable 3pwm mode
+  pinMode(M_PWM,OUTPUT);
+  digitalWrite(M_PWM,HIGH);
+  // OD_ADJ - set the maximum overcurrent limit possible
+  // Better option would be to use voltage divisor to set exact value
+  pinMode(OC_ADJ,OUTPUT);
+  digitalWrite(OC_ADJ,HIGH);
+  pinMode(OC_GAIN,OUTPUT);
+  digitalWrite(OC_GAIN,LOW);
+
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.pwm_frequency = 15000;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+  motor.voltage_sensor_align = 0.5;
+  
+  // control loop type and torque mode 
+  motor.torque_controller = TorqueControlType::voltage;
+  motor.controller = MotionControlType::torque;
+  motor.motion_downsample = 0.0;
+  
+  // velocity loop PID
+  motor.PID_velocity.P = 0.2;
+  motor.PID_velocity.I = 5.0;
+  // Low pass filtering time constant 
+  motor.LPF_velocity.Tf = 0.02;
+  // angle loop PID
+  motor.P_angle.P = 20.0;
+  // Low pass filtering time constant 
+  motor.LPF_angle.Tf = 0.0;
+  // current q loop PID 
+  motor.PID_current_q.P = 3.0;
+  motor.PID_current_q.I = 100.0;
+  // Low pass filtering time constant 
+  motor.LPF_current_q.Tf = 0.02;
+  // current d loop PID
+  motor.PID_current_d.P = 3.0;
+  motor.PID_current_d.I = 100.0;
+  // Low pass filtering time constant 
+  motor.LPF_current_d.Tf = 0.02;
+
+  // Limits 
+  motor.velocity_limit = 100.0; // 100 rad/s velocity limit
+  motor.voltage_limit = 12.0;   // 12 Volt limit 
+  motor.current_limit = 2.0;    // 2 Amp current limit
+
+
+  // use monitoring with serial for motor init
+  // monitoring port
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+  motor.monitor_variables = _MON_CURR_Q | _MON_CURR_D; // monitor the two currents d and q
+  motor.monitor_downsample = 1000;
+
+  // initialise motor
+  motor.init();
+
+  cs.init();
+  cs.driverSync(&driver);
+  // driver 8302 has inverted gains on all channels
+  cs.gain_a *=-1;
+  cs.gain_b *=-1;
+  cs.gain_c *=-1;
+  motor.linkCurrentSense(&cs);
+  
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // set the inital target value
+  motor.target = 0;
+
+  // define the motor id
+  command.add('M', onMotor, "motor");
+
+  Serial.println(F("Full control example: "));
+  Serial.println(F("Run user commands to configure and the motor (find the full command list in docs.simplefoc.com) \n "));
+  Serial.println(F("Initial motion control loop is voltage loop."));
+  Serial.println(F("Initial target voltage 2V."));
+
+  _delay(1000);
+}
+
+
+void loop() {
+  // iterative setting FOC phase voltage
+  motor.loopFOC();
+
+  // iterative function setting the outter loop target
+  motor.move();
+
+  // monitoring the state variables
+  motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/ESP32/encoder/esp32_position_control/esp32_position_control.ino

@@ -0,0 +1,107 @@
+/**
+ * ESP32 position motion control example with encoder
+ *
+ */
+#include <SimpleFOC.h>
+
+// Motor instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver3PWM driver = BLDCDriver3PWM(25, 26, 27, 7);
+
+// encoder instance
+Encoder encoder = Encoder(4, 2, 1024);
+
+// Interrupt routine intialisation
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+// angle set point variable
+float target_angle = 0;
+// instantiate the commander
+Commander command = Commander(Serial);
+void doTarget(char* cmd) { command.scalar(&target_angle, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB);
+
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+
+  // aligning voltage [V]
+  motor.voltage_sensor_align = 3;
+  // index search velocity [rad/s]
+  motor.velocity_index_search = 3;
+
+  // set motion control loop to be used
+  motor.controller = MotionControlType::velocity;
+
+  // contoller configuration
+  // default parameters in defaults.h
+
+  // velocity PI controller parameters
+  motor.PID_velocity.P = 0.2f;
+  motor.PID_velocity.I = 20;
+  // default voltage_power_supply
+  motor.voltage_limit = 6;
+  // jerk control using voltage voltage ramp
+  // default value is 300 volts per sec  ~ 0.3V per millisecond
+  motor.PID_velocity.output_ramp = 1000;
+
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle P controller
+  motor.P_angle.P = 20;
+  //  maximal velocity of the position control
+  motor.velocity_limit = 4;
+
+
+  // use monitoring with serial
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+  // initialize motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // add target command T
+  command.add('T', doTarget, "target angle");
+
+  Serial.println(F("Motor ready."));
+  Serial.println(F("Set the target angle using serial terminal:"));
+  _delay(1000);
+}
+
+void loop() {
+  // main FOC algorithm function
+  // the faster you run this function the better
+  // Arduino UNO loop  ~1kHz
+  // Bluepill loop ~10kHz
+  motor.loopFOC();
+
+  // Motion control function
+  // velocity, position or voltage (defined in motor.controller)
+  // this function can be run at much lower frequency than loopFOC() function
+  // You can also use motor.move() and set the motor.target in the code
+  motor.move(target_angle);
+
+  // function intended to be used with serial plotter to monitor motor variables
+  // significantly slowing the execution down!!!!
+  // motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/ESP32/magnetic_sensor/esp32_position_control/esp32_position_control.ino

@@ -0,0 +1,112 @@
+/**
+ * ESP32 position motion control example with magnetic sensor
+ */
+#include <SimpleFOC.h>
+
+// SPI Magnetic sensor instance (AS5047U example)
+// MISO 12
+// MOSI 9
+// SCK 14
+// magnetic sensor instance - SPI
+MagneticSensorSPI sensor = MagneticSensorSPI(AS5147_SPI, 15);
+
+// I2C Magnetic sensor instance (AS5600 example)
+// make sure to use the pull-ups!!
+// SDA 21
+// SCL 22
+// magnetic sensor instance - I2C
+//MagneticSensorI2C sensor = MagneticSensorI2C(AS5600_I2C);
+
+// Analog output Magnetic sensor instance (AS5600)
+// MagneticSensorAnalog sensor = MagneticSensorAnalog(A1, 14, 1020);
+
+// Motor instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver3PWM driver = BLDCDriver3PWM(25, 26, 27, 7);
+
+
+// angle set point variable
+float target_angle = 0;
+// instantiate the commander
+Commander command = Commander(Serial);
+void doTarget(char* cmd) { command.scalar(&target_angle, cmd); }
+
+void setup() {
+
+  // initialise magnetic sensor hardware
+  sensor.init();
+  // link the motor to the sensor
+  motor.linkSensor(&sensor);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+
+  // choose FOC modulation (optional)
+  motor.foc_modulation = FOCModulationType::SpaceVectorPWM;
+
+  // set motion control loop to be used
+  motor.controller = MotionControlType::angle;
+
+  // contoller configuration
+  // default parameters in defaults.h
+
+  // velocity PI controller parameters
+  motor.PID_velocity.P = 0.2f;
+  motor.PID_velocity.I = 20;
+  // maximal voltage to be set to the motor
+  motor.voltage_limit = 6;
+
+  // velocity low pass filtering time constant
+  // the lower the less filtered
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle P controller
+  motor.P_angle.P = 20;
+  // maximal velocity of the position control
+  motor.velocity_limit = 40;
+
+  // use monitoring with serial
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+
+  // initialize motor
+  motor.init();
+  // align sensor and start FOC
+  motor.initFOC();
+
+  // add target command T
+  command.add('T', doTarget, "target angle");
+
+  Serial.println(F("Motor ready."));
+  Serial.println(F("Set the target angle using serial terminal:"));
+  _delay(1000);
+}
+
+void loop() {
+
+  // main FOC algorithm function
+  // the faster you run this function the better
+  // Arduino UNO loop  ~1kHz
+  // Bluepill loop ~10kHz
+  motor.loopFOC();
+
+  // Motion control function
+  // velocity, position or voltage (defined in motor.controller)
+  // this function can be run at much lower frequency than loopFOC() function
+  // You can also use motor.move() and set the motor.target in the code
+  motor.move(target_angle);
+
+
+  // function intended to be used with serial plotter to monitor motor variables
+  // significantly slowing the execution down!!!!
+  // motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/HMBGC_example/position_control/position_control.ino

@@ -0,0 +1,127 @@
+/**
+ *
+ * HMBGC position motion control example with encoder
+ *
+ * - Motor is connected the MOT1 connector (MOT1 9,10,11; MOT2 3,5,6)
+ * - Encoder is connected to A0 and A1
+ *
+ * This board doesn't have any interrupt pins so we need to run all the encoder channels with the software interrupt library
+ * - For this example we use: PciManager library : https://github.com/prampec/arduino-pcimanager
+ *
+ * See docs.simplefoc.com for more info.
+ *
+ */
+#include <SimpleFOC.h>
+// software interrupt library
+#include <PciManager.h>
+#include <PciListenerImp.h>
+
+
+// BLDC motor & driver instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver3PWM driver = BLDCDriver3PWM(9, 10, 11);
+
+// encoder instance
+Encoder encoder = Encoder(A0, A1, 2048);
+
+// Interrupt routine intialisation
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+// encoder interrupt init
+PciListenerImp listenerA(encoder.pinA, doA);
+PciListenerImp listenerB(encoder.pinB, doB);
+
+
+// angle set point variable
+float target_angle = 0;
+// instantiate the commander
+Commander command = Commander(Serial);
+void doTarget(char* cmd) { command.scalar(&target_angle, cmd); }
+
+void setup() {
+
+  // initialise encoder hardware
+  encoder.init();
+  // interrupt initialization
+  PciManager.registerListener(&listenerA);
+  PciManager.registerListener(&listenerB);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+
+  // aligning voltage [V]
+  motor.voltage_sensor_align = 3;
+  // index search velocity [rad/s]
+  motor.velocity_index_search = 3;
+
+  // set motion control loop to be used
+  motor.controller = MotionControlType::angle;
+
+  // contoller configuration
+  // default parameters in defaults.h
+
+  // velocity PI controller parameters
+  motor.PID_velocity.P = 0.2f;
+  motor.PID_velocity.I = 20;
+  // default voltage_power_supply
+  motor.voltage_limit = 6;
+  // jerk control using voltage voltage ramp
+  // default value is 300 volts per sec  ~ 0.3V per millisecond
+  motor.PID_velocity.output_ramp = 1000;
+
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle P controller
+  motor.P_angle.P = 20;
+  //  maximal velocity of the position control
+  motor.velocity_limit = 4;
+
+
+  // use monitoring with serial
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+  // initialize motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // add target command T
+  command.add('T', doTarget, "target angle");
+
+  Serial.println(F("Motor ready."));
+  Serial.println(F("Set the target angle using serial terminal:"));
+  _delay(1000);
+}
+
+
+void loop() {
+  // main FOC algorithm function
+  // the faster you run this function the better
+  // Arduino UNO loop  ~1kHz
+  // Bluepill loop ~10kHz
+  motor.loopFOC();
+
+  // Motion control function
+  // velocity, position or voltage (defined in motor.controller)
+  // this function can be run at much lower frequency than loopFOC() function
+  // You can also use motor.move() and set the motor.target in the code
+  motor.move(target_angle);
+
+  // function intended to be used with serial plotter to monitor motor variables
+  // significantly slowing the execution down!!!!
+  // motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/HMBGC_example/voltage_control/voltage_control.ino

@@ -0,0 +1,110 @@
+/**
+ * 
+ * HMBGC torque control example using voltage control loop.
+ * 
+ * - Motor is connected the MOT1 connector (MOT1 9,10,11; MOT2 3,5,6)
+ * - Encoder is connected to A0 and A1
+ * 
+ * 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. position motion control example with encoder
+ * 
+ * NOTE:
+ * > HMBGC doesn't have any interrupt pins so we need to run all the encoder channels with the software interrupt library 
+ * > - For this example we use: PciManager library : https://github.com/prampec/arduino-pcimanager
+ * 
+ * See docs.simplefoc.com for more info.
+ * 
+ */
+#include <SimpleFOC.h>
+// software interrupt library
+#include <PciManager.h>
+#include <PciListenerImp.h>
+
+
+// BLDC motor & driver instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver3PWM driver = BLDCDriver3PWM(9, 10, 11);
+
+// encoder instance
+Encoder encoder = Encoder(A0, A1, 8192);
+
+// Interrupt routine intialisation
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+// encoder interrupt init
+PciListenerImp listenerA(encoder.pinA, doA);
+PciListenerImp listenerB(encoder.pinB, doB);
+
+
+// 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() { 
+  
+  // initialize encoder sensor hardware
+  encoder.init();
+  // interrupt initialization
+  PciManager.registerListener(&listenerA);
+  PciManager.registerListener(&listenerB);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link the motor and the driver
+  motor.linkDriver(&driver);
+  
+  // choose FOC modulation (optional)
+  motor.foc_modulation = FOCModulationType::SpaceVectorPWM;
+
+  // set motion control loop to be used
+  motor.controller = MotionControlType::torque;
+
+  // use monitoring with serial for motor init
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+  // use monitoring with serial 
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+
+  // initialize motor
+  motor.init();
+  // align sensor and start 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() {
+
+  // main FOC algorithm function
+  // the faster you run this function the better
+  // Arduino UNO loop  ~1kHz
+  // Bluepill loop ~10kHz 
+  motor.loopFOC();
+
+  // Motion control function
+  // velocity, position or voltage (defined in motor.controller)
+  // this function can be run at much lower frequency than loopFOC() function
+  // You can also use motor.move() and set the motor.target in the code
+  motor.move(target_voltage);
+  
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/SAMD_examples/README.md

@@ -0,0 +1,62 @@
+
+# SAMD Support
+
+SimpleFOC supports many SAMD21 MCUs, really any SAMD21 supported by Arduino core should work.
+
+## Pin assignments
+
+The SAMD chips have some very powerful PWM features, but do not have flexible pin assignments.
+
+You should be able to use *most* (but not all!), pin combinations for attaching your motor's PWM pins. Please ignore the board descriptions and pinout diagrammes regarding PWM-pins on SAMD boards. They are pretty much all incorrect to varying degrees of awfulness.
+
+On SAMD we use TCC and TC timer peripherals (built into the SAMD chip) to control the PWM. Depending on the chip there are various timer units, whose PWM outputs are attached to various different pins, and it is all very complicated. Luckily SimpleFOC sets it all up automatically *if* there is a compatible configuration for those pins.
+
+Not all timers are created equal. The TCC timers are pretty awesome for PWM motor control, while the TC timers are just ok for the job. So to get best performance, you want to use just TCC timer pins if you can.
+
+By enabling
+
+```
+ #define SIMPLEFOC_SAMD_DEBUG
+```
+
+in drivers/hardware_specific/samd_mcu.cpp<br>
+you will see a table of pin assignments printed on the serial console, as well as the timers SimpleFOC was able to find and configure on the pins you specified. You can use this to optimize your choice of pins if you want.
+
+You can configure up to 12 pins for PWM motor control, i.e. 6x 2-PWM motors, 4x 3-PWM motors, 3x 4-PWM motors or 2x 6-PWM motors. 
+
+## PWM control modes
+
+All modes (3-PWM, 6-PWM, Stepper 2-PWM and Stepper 4-PWM) are supported.
+
+For 2-, 3- amd 4- PWM, any valid pin-combinations can be used. If you stick to TCC timers rather than using TC timers, then you'll get getter PWM waveforms. If you use pins which are all on the same TCC unit, you'll get the best result, with the PWM signals all perfectly aligned as well.
+
+For 6-PWM, the situation is much more complicated:<br>
+TC timers cannot be used for 6-PWM, only TCC timers.
+
+For Hardware Dead-Time insertion, you must use H and L pins for one phase from the same TCC unit, and on the same channel, but using complementary WOs (Waveform Outputs, i.e. PWM output pins). Check the table to find pins on the same channel (like TCC0-0) but complementary WOs (like TCC0-0[0] and TCC0-0[4] or TCC1-0[0] and TCC1-0[2]).
+
+For Software Dead-Time insertion, you must use the same TCC and different channels for the H and L pins of the same phase.
+
+Note: in all of the above note that you *cannot* set the timers or WOs used - they are fixed, and determined by the pins you selected. SimpleFOC will find the best combination of timers given the pins, trying to use TCC timers before TC, and trying to keep things on the same timers as much as possible. If you configure multiple motors, it will take into account the pins already assigned to other motors.
+So it is matter of choosing the right pins, nothing else.
+
+Note also: Unfortunately you can't set the PWM frequency. It is currently fixed at 24KHz. This is a tradeoff between limiting PWM resolution vs
+increasing frequency, and also due to keeping the pin assignemts flexible, which would not be possible if we ran the timers at different rates.
+
+## Status
+
+Currently, SAMD21 is supported, and SAMD51 is unsupported. SAMD51 support is in progress.
+
+Boards tested:
+
+ * Arduino Nano 33 IoT
+ * Arduino MKR1000
+ * Arduino MKR1010 Wifi
+ * Seeduino XIAO
+ * Feather M0 Basic
+
+Environments tested:
+
+ * Arduino IDE
+ * Arduino Pro IDE
+ * Sloeber

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/SAMD_examples/nano33IoT/nano33IoT_velocity_control/nano33IoT_velocity_control.ino

@@ -0,0 +1,64 @@
+
+// show the infos for SAMD pin assignment on serial console
+// set this #define SIMPLEFOC_SAMD_DEBUG in drivers/hardware_specific/samd21_mcu.h
+
+
+#include "Arduino.h"
+#include <Wire.h>
+#include <SimpleFOC.h>
+
+// this is for an AS5048B absolute magnetic encoder on I2C address 0x41
+MagneticSensorI2C sensor = MagneticSensorI2C(0x41, 14, 0xFE, 8);
+
+// small BLDC gimbal motor, 7 pole-pairs
+BLDCMotor motor = BLDCMotor(7);
+// 3-PWM driving on pins 6, 5 and 8 - these are all on the same timer unit (TCC0), but different channels
+BLDCDriver3PWM driver =  BLDCDriver3PWM(6,5,8);
+
+// velocity set point variable
+float target_velocity = 2.0f;
+// instantiate the commander
+Commander command = Commander(SerialUSB);
+void doTarget(char* cmd) { command.scalar(&target_velocity, cmd); }
+
+
+void setup() {
+	Serial.begin(115200);
+	delay(1000);
+	Serial.println("Initializing...");
+
+	sensor.init();
+	Wire.setClock(400000);
+	motor.linkSensor(&sensor);
+	driver.voltage_power_supply = 9;
+	driver.init();
+	motor.linkDriver(&driver);
+	motor.controller = MotionControlType::velocity;
+	motor.PID_velocity.P = 0.2f;
+	motor.PID_velocity.I = 20;
+	motor.PID_velocity.D = 0.001f;
+	motor.PID_velocity.output_ramp = 1000;
+	motor.LPF_velocity.Tf = 0.01f;
+	motor.voltage_limit = 9;
+	//motor.P_angle.P = 20;
+	motor.init();
+	motor.initFOC();
+
+	// add target command T
+	command.add('T', doTarget, "target velocity");
+
+	Serial.println(F("Motor ready."));
+	Serial.println(F("Set the target velocity using serial terminal:"));
+	delay(100);
+}
+
+
+
+void loop() {
+//	Serial.print("Sensor: ");
+//	Serial.println(sensor.getAngle());
+	motor.loopFOC();
+	motor.move(target_velocity);
+	// user communication
+	command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/SimpleFOC-PowerShield/version_v02/single_full_control_example/single_full_control_example.ino

@@ -0,0 +1,100 @@
+
+#include <SimpleFOC.h>
+
+// BLDC motor & driver instance
+BLDCMotor motor = BLDCMotor(7);
+BLDCDriver3PWM driver = BLDCDriver3PWM(9, 5, 6, 8, 4, 7);
+
+// encoder instance
+Encoder encoder = Encoder(10, 11, 500);
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+// inline current sensor instance
+InlineCurrentSense current_sense = InlineCurrentSense(0.001, 50.0, A0, A1);
+
+// commander communication instance
+Commander command = Commander(Serial);
+// void doMotor(char* cmd){ command.motor(&motor, cmd); }
+void doTarget(char* cmd){ command.scalar(&motor.target, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 20;
+  driver.init();
+  // link driver
+  motor.linkDriver(&driver);
+
+  motor.voltage_sensor_align = 1;
+  // set control loop type to be used
+  motor.torque_controller = TorqueControlType::foc_current;
+  motor.controller = MotionControlType::torque;
+
+  // contoller configuration based on the controll type
+  motor.PID_velocity.P = 0.05f;
+  motor.PID_velocity.I = 1;
+  motor.PID_velocity.D = 0;
+  // default voltage_power_supply
+  motor.voltage_limit = 12;
+
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle loop controller
+  motor.P_angle.P = 20;
+  // angle loop velocity limit
+  motor.velocity_limit = 20;
+
+  // use monitoring with serial for motor init
+  // monitoring port
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+  motor.monitor_downsample = 0; // disable intially
+  motor.monitor_variables = _MON_TARGET | _MON_VEL | _MON_ANGLE; // monitor target velocity and angle
+
+  // current sense init and linking
+  current_sense.init();
+  motor.linkCurrentSense(&current_sense);
+
+  // initialise motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // set the inital target value
+  motor.target = 0;
+
+  // subscribe motor to the commander
+  // command.add('M', doMotor, "motor");
+  command.add('T', doTarget, "target");
+
+  // Run user commands to configure and the motor (find the full command list in docs.simplefoc.com)
+  Serial.println("Motor ready.");
+
+  _delay(1000);
+}
+
+
+void loop() {
+  // iterative setting FOC phase voltage
+  motor.loopFOC();
+
+  // iterative function setting the outter loop target
+  motor.move();
+
+  // motor monitoring
+  motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/SimpleFOCShield/version_v1/double_full_control_example/double_full_control_example.ino

@@ -0,0 +1,118 @@
+
+#include <SimpleFOC.h>
+
+// BLDC motor & driver instance
+BLDCMotor motor1 = BLDCMotor(11);
+BLDCDriver3PWM driver1 = BLDCDriver3PWM(9, 5, 6, 8);
+
+// BLDC motor & driver instance
+BLDCMotor motor2 = BLDCMotor(11);
+BLDCDriver3PWM driver2  = BLDCDriver3PWM(3, 10, 11, 7);
+
+// encoder instance
+Encoder encoder1 = Encoder(2, A3, 500);
+// channel A and B callbacks
+void doA1(){encoder1.handleA();}
+void doB1(){encoder1.handleB();}
+
+// encoder instance
+Encoder encoder2 = Encoder(A1, A2, 500);
+// channel A and B callbacks
+void doA2(){encoder2.handleA();}
+void doB2(){encoder2.handleB();}
+
+// commander communication instance
+Commander command = Commander(Serial);
+void doMotor1(char* cmd){ command.motor(&motor1, cmd); }
+void doMotor2(char* cmd){ command.motor(&motor2, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder1.init();
+  encoder1.enableInterrupts(doA1, doB1);
+  // initialize encoder sensor hardware
+  encoder2.init();
+  encoder2.enableInterrupts(doA2, doB2);
+  // link the motor to the sensor
+  motor1.linkSensor(&encoder1);
+  motor2.linkSensor(&encoder2);
+
+
+  // driver config
+  // power supply voltage [V]
+  driver1.voltage_power_supply = 12;
+  driver1.init();
+  // link driver
+  motor1.linkDriver(&driver1);
+  // power supply voltage [V]
+  driver2.voltage_power_supply = 12;
+  driver2.init();
+  // link driver
+  motor2.linkDriver(&driver2);
+
+  // set control loop type to be used
+  motor1.controller = MotionControlType::torque;
+  motor2.controller = MotionControlType::torque;
+
+  // contoller configuration based on the controll type
+  motor1.PID_velocity.P = 0.05f;
+  motor1.PID_velocity.I = 1;
+  motor1.PID_velocity.D = 0;
+  // default voltage_power_supply
+  motor1.voltage_limit = 12;
+  // contoller configuration based on the controll type
+  motor2.PID_velocity.P = 0.05f;
+  motor2.PID_velocity.I = 1;
+  motor2.PID_velocity.D = 0;
+  // default voltage_power_supply
+  motor2.voltage_limit = 12;
+
+  // angle loop velocity limit
+  motor1.velocity_limit = 20;
+  motor2.velocity_limit = 20;
+
+  // use monitoring with serial for motor init
+  // monitoring port
+  Serial.begin(115200);
+  // comment out if not needed
+  motor1.useMonitoring(Serial);
+  motor2.useMonitoring(Serial);
+
+  // initialise motor
+  motor1.init();
+  // align encoder and start FOC
+  motor1.initFOC();
+
+  // initialise motor
+  motor2.init();
+  // align encoder and start FOC
+  motor2.initFOC();
+
+  // set the inital target value
+  motor1.target = 2;
+  motor2.target = 2;
+
+  // subscribe motor to the commander
+  command.add('A', doMotor1, "motor 1");
+  command.add('B', doMotor2, "motor 2");
+
+  // Run user commands to configure and the motor (find the full command list in docs.simplefoc.com)
+  Serial.println(F("Double motor sketch ready."));
+
+  _delay(1000);
+}
+
+
+void loop() {
+  // iterative setting FOC phase voltage
+  motor1.loopFOC();
+  motor2.loopFOC();
+
+  // iterative function setting the outter loop target
+  motor1.move();
+  motor2.move();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/SimpleFOCShield/version_v1/single_full_control_example/single_full_control_example.ino

@@ -0,0 +1,89 @@
+
+#include <SimpleFOC.h>
+
+// BLDC motor & driver instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver3PWM driver = BLDCDriver3PWM(9, 5, 6, 8);
+
+// encoder instance
+Encoder encoder = Encoder(2, 3, 500);
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+// commander communication instance
+Commander command = Commander(Serial);
+void doMotor(char* cmd){ command.motor(&motor, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link driver
+  motor.linkDriver(&driver);
+
+  // set control loop type to be used
+  motor.controller = MotionControlType::torque;
+
+  // contoller configuration based on the controll type
+  motor.PID_velocity.P = 0.05f;
+  motor.PID_velocity.I = 1;
+  motor.PID_velocity.D = 0;
+  // default voltage_power_supply
+  motor.voltage_limit = 12;
+
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle loop controller
+  motor.P_angle.P = 20;
+  // angle loop velocity limit
+  motor.velocity_limit = 20;
+
+  // use monitoring with serial for motor init
+  // monitoring port
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+  motor.monitor_downsample = 0; // disable intially
+  motor.monitor_variables = _MON_TARGET | _MON_VEL | _MON_ANGLE; // monitor target velocity and angle
+
+  // initialise motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // set the inital target value
+  motor.target = 2;
+
+  // subscribe motor to the commander
+  command.add('M', doMotor, "motor");
+
+  // Run user commands to configure and the motor (find the full command list in docs.simplefoc.com)
+  Serial.println(F("Motor commands sketch | Initial motion control > torque/voltage : target 2V."));
+
+  _delay(1000);
+}
+
+
+void loop() {
+  // iterative setting FOC phase voltage
+  motor.loopFOC();
+
+  // iterative function setting the outter loop target
+  motor.move();
+
+  // motor monitoring
+  motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/SimpleFOCShield/version_v2/double_full_control_example/double_full_control_example.ino

@@ -0,0 +1,139 @@
+
+#include <SimpleFOC.h>
+
+// BLDC motor & driver instance
+BLDCMotor motor1 = BLDCMotor(11);
+BLDCDriver3PWM driver1 = BLDCDriver3PWM(5, 10, 6, 8);
+
+// BLDC motor & driver instance
+BLDCMotor motor2 = BLDCMotor(11);
+BLDCDriver3PWM driver2  = BLDCDriver3PWM(3, 9, 11, 7);
+
+// encoder instance
+Encoder encoder1 = Encoder(12, 2, 500);
+// channel A and B callbacks
+void doA1(){encoder1.handleA();}
+void doB1(){encoder1.handleB();}
+
+// encoder instance
+Encoder encoder2 = Encoder(A5, A4, 500);
+// channel A and B callbacks
+void doA2(){encoder2.handleA();}
+void doB2(){encoder2.handleB();}
+
+
+// inline current sensor instance
+// check if your board has R010 (0.01 ohm resistor) or R006 (0.006 mOhm resistor)
+InlineCurrentSense current_sense1 = InlineCurrentSense(0.01, 50.0, A0, A2);
+
+// inline current sensor instance
+// check if your board has R010 (0.01 ohm resistor) or R006 (0.006 mOhm resistor)
+InlineCurrentSense current_sense2 = InlineCurrentSense(0.01, 50.0, A1, A3);
+
+// commander communication instance
+Commander command = Commander(Serial);
+// void doMotor1(char* cmd){ command.motor(&motor1, cmd); }
+// void doMotor2(char* cmd){ command.motor(&motor2, cmd); }
+void doTarget1(char* cmd){ command.scalar(&motor1.target, cmd); }
+void doTarget2(char* cmd){ command.scalar(&motor2.target, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder1.init();
+  encoder1.enableInterrupts(doA1, doB1);
+  // initialize encoder sensor hardware
+  encoder2.init();
+  encoder2.enableInterrupts(doA2, doB2);
+  // link the motor to the sensor
+  motor1.linkSensor(&encoder1);
+  motor2.linkSensor(&encoder2);
+
+
+  // driver config
+  // power supply voltage [V]
+  driver1.voltage_power_supply = 12;
+  driver1.init();
+  // link driver
+  motor1.linkDriver(&driver1);
+  // power supply voltage [V]
+  driver2.voltage_power_supply = 12;
+  driver2.init();
+  // link driver
+  motor2.linkDriver(&driver2);
+
+  // set control loop type to be used
+  motor1.controller = MotionControlType::torque;
+  motor2.controller = MotionControlType::torque;
+
+  // contoller configuration based on the controll type
+  motor1.PID_velocity.P = 0.05f;
+  motor1.PID_velocity.I = 1;
+  motor1.PID_velocity.D = 0;
+  // default voltage_power_supply
+  motor1.voltage_limit = 12;
+  // contoller configuration based on the controll type
+  motor2.PID_velocity.P = 0.05f;
+  motor2.PID_velocity.I = 1;
+  motor2.PID_velocity.D = 0;
+  // default voltage_power_supply
+  motor2.voltage_limit = 12;
+
+  // angle loop velocity limit
+  motor1.velocity_limit = 20;
+  motor2.velocity_limit = 20;
+
+  // use monitoring with serial for motor init
+  // monitoring port
+  Serial.begin(115200);
+  // comment out if not needed
+  motor1.useMonitoring(Serial);
+  motor2.useMonitoring(Serial);
+
+
+  // current sense init and linking
+  current_sense1.init();
+  motor1.linkCurrentSense(&current_sense1);
+  // current sense init and linking
+  current_sense2.init();
+  motor2.linkCurrentSense(&current_sense2);
+
+  // initialise motor
+  motor1.init();
+  // align encoder and start FOC
+  motor1.initFOC();
+
+  // initialise motor
+  motor2.init();
+  // align encoder and start FOC
+  motor2.initFOC();
+
+  // set the inital target value
+  motor1.target = 2;
+  motor2.target = 2;
+
+  // subscribe motor to the commander
+  // command.add('A', doMotor1, "motor 1");
+  // command.add('B', doMotor2, "motor 2");
+  command.add('A', doTarget1, "target 1");
+  command.add('B', doTarget2, "target 2");
+
+  // Run user commands to configure and the motor (find the full command list in docs.simplefoc.com)
+  Serial.println("Motors ready.");
+
+  _delay(1000);
+}
+
+
+void loop() {
+  // iterative setting FOC phase voltage
+  motor1.loopFOC();
+  motor2.loopFOC();
+
+  // iterative function setting the outter loop target
+  motor1.move();
+  motor2.move();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/SimpleFOCShield/version_v2/single_full_control_example/single_full_control_example.ino

@@ -0,0 +1,99 @@
+
+#include <SimpleFOC.h>
+
+// BLDC motor & driver instance
+BLDCMotor motor = BLDCMotor(11);
+BLDCDriver3PWM driver = BLDCDriver3PWM(5, 10, 6, 8);
+
+// encoder instance
+Encoder encoder = Encoder(2, 3, 500);
+// channel A and B callbacks
+void doA(){encoder.handleA();}
+void doB(){encoder.handleB();}
+
+// inline current sensor instance
+// check if your board has R010 (0.01 ohm resistor) or R006 (0.006 mOhm resistor)
+InlineCurrentSense current_sense = InlineCurrentSense(0.01, 50.0, A0, A2);
+
+// commander communication instance
+Commander command = Commander(Serial);
+void doMotion(char* cmd){ command.motion(&motor, cmd); }
+// void doMotor(char* cmd){ command.motor(&motor, cmd); }
+
+void setup() {
+
+  // initialize encoder sensor hardware
+  encoder.init();
+  encoder.enableInterrupts(doA, doB);
+  // link the motor to the sensor
+  motor.linkSensor(&encoder);
+
+  // driver config
+  // power supply voltage [V]
+  driver.voltage_power_supply = 12;
+  driver.init();
+  // link driver
+  motor.linkDriver(&driver);
+
+  // set control loop type to be used
+  motor.controller = MotionControlType::torque;
+
+  // contoller configuration based on the controll type
+  motor.PID_velocity.P = 0.05f;
+  motor.PID_velocity.I = 1;
+  motor.PID_velocity.D = 0;
+  // default voltage_power_supply
+  motor.voltage_limit = 12;
+
+  // velocity low pass filtering time constant
+  motor.LPF_velocity.Tf = 0.01f;
+
+  // angle loop controller
+  motor.P_angle.P = 20;
+  // angle loop velocity limit
+  motor.velocity_limit = 20;
+
+  // use monitoring with serial for motor init
+  // monitoring port
+  Serial.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(Serial);
+  motor.monitor_downsample = 0; // disable intially
+  motor.monitor_variables = _MON_TARGET | _MON_VEL | _MON_ANGLE; // monitor target velocity and angle
+
+  // current sense init and linking
+  current_sense.init();
+  motor.linkCurrentSense(&current_sense);
+
+  // initialise motor
+  motor.init();
+  // align encoder and start FOC
+  motor.initFOC();
+
+  // set the inital target value
+  motor.target = 2;
+
+  // subscribe motor to the commander
+  command.add('T', doMotion, "motion control");
+  // command.add('M', doMotor, "motor");
+  
+  // Run user commands to configure and the motor (find the full command list in docs.simplefoc.com)
+  Serial.println("Motor ready.");
+
+  _delay(1000);
+}
+
+
+void loop() {
+  // iterative setting FOC phase voltage
+  motor.loopFOC();
+
+  // iterative function setting the outter loop target
+  motor.move();
+
+  // motor monitoring
+  motor.monitor();
+
+  // user communication
+  command.run();
+}

v1.2/Shibo-main-TOMMY/lib/Simple_FOC/examples/hardware_specific_examples/Smart_Stepper/smartstepper_control/smartstepper_control.ino

@@ -0,0 +1,61 @@
+/**
+ * Smart Stepper support with SimpleFOClibrary
+ */
+#include <SimpleFOC.h>
+
+// magnetic sensor instance - SPI
+MagneticSensorSPI sensor = MagneticSensorSPI(AS5147_SPI, A2);
+
+// Stepper motor & driver instance
+StepperMotor motor = StepperMotor(50);
+int in1[2] = {5, 6};
+int in2[2] = {A4, 7};
+StepperDriver2PWM driver = StepperDriver2PWM(4, in1, 9, in2);
+
+// instantiate the commander
+Commander command = Commander(SerialUSB);
+void doMotor(char* cmd) { command.motor(&motor, cmd); }
+
+void setup() {
+
+  // initialise magnetic sensor hardware
+  sensor.init();
+  // link the motor to the sensor
+  motor.linkSensor(&sensor);
+
+  // power supply voltage
+  driver.voltage_power_supply = 12;
+  driver.init();
+  motor.linkDriver(&driver);
+
+  // set motion control loop to be used
+  motor.controller = MotionControlType::torque;
+
+  // use monitoring with SerialUSB 
+  SerialUSB.begin(115200);
+  // comment out if not needed
+  motor.useMonitoring(SerialUSB);
+
+  // initialize motor
+  motor.init();
+  // align sensor and start FOC
+  motor.initFOC();
+
+  // add target command M
+  command.add('M', doMotor, "my motor");
+
+  SerialUSB.println(F("Motor ready."));
+  SerialUSB.println(F("Set the target voltage using Serial terminal:"));
+  _delay(1000);
+}
+
+void loop() {
+  // main FOC algorithm function
+  motor.loopFOC();
+
+  // Motion control function
+  motor.move();
+  
+  // user communication
+  command.run();
+}