esp32 final support for multiple motors + samd refactor for new low level api

Author: askuric

src/current_sense/hardware_specific/esp32_mcu.cpp

@@ -16,24 +16,33 @@
 #define _ADC_VOLTAGE 3.3f
 #define _ADC_RESOLUTION 4095.0f
 
+
+typedef struct ESP32MCPWMCurrentSenseParams {
+  int pins[3];
+  float adc_voltage_conv;
+  mcpwm_unit_t mcpwm_unit;
+  int buffer_index;
+} ESP32MCPWMCurrentSenseParams;
+
+
 /**
  *  Inline adc reading implementation 
 */
 // function reading an ADC value and returning the read voltage
 float _readADCVoltageInline(const int pinA, const void* cs_params){
   uint32_t raw_adc = adcRead(pinA);
-  return raw_adc * ((GenericCurrentSenseParams*)cs_params)->adc_voltage_conv;
+  return raw_adc * ((ESP32MCPWMCurrentSenseParams*)cs_params)->adc_voltage_conv;
 }
 
 // function reading an ADC value and returning the read voltage
-void* _configureADCInline(const void* driver_params, const int pinA,const int pinB,const int pinC){
+void* _configureADCInline(const void* driver_params, const int pinA, const int pinB, const int pinC){
   _UNUSED(driver_params);
 
   pinMode(pinA, INPUT);
   pinMode(pinB, INPUT);
   if( _isset(pinC) ) pinMode(pinC, INPUT);
 
-  GenericCurrentSenseParams* params = new GenericCurrentSenseParams {
+  ESP32MCPWMCurrentSenseParams* params = new ESP32MCPWMCurrentSenseParams {
     .pins = { pinA, pinB, pinC },
     .adc_voltage_conv = (_ADC_VOLTAGE)/(_ADC_RESOLUTION)
   };
@@ -46,60 +55,68 @@ void* _configureADCInline(const void* driver_params, const int pinA,const int pi
 /**
  *  Low side adc reading implementation 
 */
-static mcpwm_dev_t *MCPWM[2] = {&MCPWM0, &MCPWM1};
-int a1, a2, a3;         // Current readings from internal current sensor amplifiers
-int _pinA, _pinB, _pinC;
 
 static void IRAM_ATTR mcpwm0_isr_handler(void*);
 static void IRAM_ATTR mcpwm1_isr_handler(void*);
 byte currentState = 1;
-
-int* adc_pins;
-int* adc_buffer;
-int adc_pin_count;
-int adc_pin_read_index;
-
+// two mcpwm units 
+// - max 2 motors per mcpwm unit (6 adc channels)
+int adc_pins[2][6]={0};
+int adc_pin_count[2]={0};
+uint32_t adc_buffer[2][6]={0};
+int adc_read_index[2]={0};
 
 // function reading an ADC value and returning the read voltage
 float _readADCVoltageLowSide(const int pin, const void* cs_params){
   uint32_t raw_adc;
 
-  if (pin == _pinA) raw_adc = a1;
-  else if (pin == _pinB) raw_adc = a2;
-  else if (pin == _pinC) raw_adc = a3;
+  mcpwm_unit_t unit = ((ESP32MCPWMCurrentSenseParams*)cs_params)->mcpwm_unit;
+  int buffer_index = ((ESP32MCPWMCurrentSenseParams*)cs_params)->buffer_index;
+  float adc_voltage_conv = ((ESP32MCPWMCurrentSenseParams*)cs_params)->adc_voltage_conv;
 
-  return  raw_adc * ((GenericCurrentSenseParams*)cs_params)->adc_voltage_conv;
+  for(int i=0; i < adc_pin_count[unit]; i++){
+    if( pin == ((ESP32MCPWMCurrentSenseParams*)cs_params)->pins[i]) // found in the buffer
+      return adc_buffer[unit][buffer_index + i] * adc_voltage_conv;
+  }
+  // not found
+  return  0;
 }
 
-// function reading an ADC value and returning the read voltage
+// function configuring low-side current sensing 
 void* _configureADCLowSide(const void* driver_params, const int pinA,const int pinB,const int pinC){
-  _UNUSED(driver_params);
-
-  _pinA= pinA;
-  _pinB= pinB;
-  if( _isset(pinC) ) _pinC= pinC;
+  
+  mcpwm_unit_t unit = ((ESP32MCPWMDriverParams*)driver_params)->mcpwm_unit;
+  int index_start = adc_pin_count[unit];
+  adc_pins[unit][adc_pin_count[unit]++] = pinA;
+  adc_pins[unit][adc_pin_count[unit]++] = pinB;
+  if( _isset(pinC) ) adc_pins[unit][adc_pin_count[unit]++] = pinC;
 
   pinMode(pinA, INPUT);
   pinMode(pinB, INPUT);
   if( _isset(pinC) ) pinMode(pinC, INPUT);
 
-  GenericCurrentSenseParams* params = new GenericCurrentSenseParams {
+  ESP32MCPWMCurrentSenseParams* params = new ESP32MCPWMCurrentSenseParams {
     .pins = { pinA, pinB, pinC },
-    .adc_voltage_conv = (_ADC_VOLTAGE)/(_ADC_RESOLUTION)
+    .adc_voltage_conv = (_ADC_VOLTAGE)/(_ADC_RESOLUTION),
+    .mcpwm_unit = unit,
+    .buffer_index = index_start
   };
 
   return params;
 }
 
 
 void _driverSyncLowSide(void* driver_params, void* cs_params){
-  // high side registers enable interrupt 
-  // MCPWM[MCPWM_UNIT_0]->int_ena.timer0_tez_int_ena = true;//A PWM timer 0 TEP event will trigger this interrupt
 
-  // low-side register enable interrupt
   mcpwm_dev_t* mcpwm_dev = ((ESP32MCPWMDriverParams*)driver_params)->mcpwm_dev;
   mcpwm_unit_t mcpwm_unit = ((ESP32MCPWMDriverParams*)driver_params)->mcpwm_unit;
+
+  // low-side register enable interrupt
   mcpwm_dev->int_ena.timer0_tep_int_ena = true;//A PWM timer 0 TEP event will trigger this interrupt
+  // high side registers enable interrupt 
+  //mcpwm_dev->int_ena.timer0_tep_int_ena = true;//A PWM timer 0 TEZ event will trigger this interrupt 
+
+  // register interrupts (mcpwm number, interrupt handler, handler argument = NULL, interrupt signal/flag, return handler = NULL)
   if(mcpwm_unit == MCPWM_UNIT_0)
     mcpwm_isr_register(mcpwm_unit, mcpwm0_isr_handler, NULL, ESP_INTR_FLAG_IRAM, NULL);  //Set ISR Handler
   else
@@ -109,63 +126,38 @@ void _driverSyncLowSide(void* driver_params, void* cs_params){
 // Read currents when interrupt is triggered
 static void IRAM_ATTR mcpwm0_isr_handler(void*){
   // // high side
-  // uint32_t mcpwm_intr_status_0 = MCPWM0.int_st.timer0_tez_int_st;
+  // uint32_t mcpwm_intr_status = MCPWM0.int_st.timer0_tez_int_st;
 
   // low side
   uint32_t mcpwm_intr_status = MCPWM0.int_st.timer0_tep_int_st;
   if(mcpwm_intr_status){
-    switch (currentState)
-    {
-    case 1 :
-      a1 = adcRead(_pinA);
-      currentState = 2;
-      break;
-    case 2 :
-      a2 = adcRead(_pinB);
-      currentState = _isset(_pinC) ?  3 : 1;
-      break;
-    case 3 :
-      a3 = adcRead(_pinC);
-      currentState = 1;
-      break;
-    }
+    adc_buffer[0][adc_read_index[0]] = adcRead(adc_pins[0][adc_read_index[0]]);
+    adc_read_index[0]++;
+    if(adc_read_index[0] == adc_pin_count[0]) adc_read_index[0] = 0;
   }
-  // high side
-  // MCPWM0.int_clr.timer0_tez_int_clr = mcpwm_intr_status_0;
-
   // low side
   MCPWM0.int_clr.timer0_tep_int_clr = mcpwm_intr_status;
+  // high side
+  // MCPWM0.int_clr.timer0_tez_int_clr = mcpwm_intr_status_0;
 }
 
+
 // Read currents when interrupt is triggered
 static void IRAM_ATTR mcpwm1_isr_handler(void*){
   // // high side
-  // uint32_t mcpwm_intr_status_0 = MCPWM1.int_st.timer0_tez_int_st;
+  // uint32_t mcpwm_intr_status = MCPWM1.int_st.timer0_tez_int_st;
 
   // low side
   uint32_t mcpwm_intr_status = MCPWM1.int_st.timer0_tep_int_st;
   if(mcpwm_intr_status){
-    switch (currentState)
-    {
-    case 1 :
-      a1 = adcRead(_pinA);
-      currentState = 2;
-      break;
-    case 2 :
-      a2 = adcRead(_pinB);
-      currentState = _isset(_pinC) ?  3 : 1;
-      break;
-    case 3 :
-      a3 = adcRead(_pinC);
-      currentState = 1;
-      break;
-    }
+    adc_buffer[1][adc_read_index[1]] = adcRead(adc_pins[1][adc_read_index[1]]);
+    adc_read_index[1]++;
+    if(adc_read_index[1] == adc_pin_count[1]) adc_read_index[1] = 0;
   }
-  // high side
-  // MCPWM1.int_clr.timer0_tez_int_clr = mcpwm_intr_status_0;
-
   // low side
   MCPWM1.int_clr.timer0_tep_int_clr = mcpwm_intr_status;
+  // high side
+  // MCPWM1.int_clr.timer0_tez_int_clr = mcpwm_intr_status_0;
 }
 
 

src/current_sense/hardware_specific/samd21_mcu.cpp

@@ -8,21 +8,23 @@ static bool freeRunning = false;
 static int _pinA, _pinB, _pinC;
 static uint16_t a = 0xFFFF, b = 0xFFFF, c = 0xFFFF; // updated by adcStopWithDMA when configured in freerunning mode
 static SAMDCurrentSenseADCDMA instance;
-/**
- *  function reading an ADC value and returning the read voltage 
- * 
- * @param pinA - adc pin A
- * @param pinB - adc pin B
- * @param pinC - adc pin C
- */
-void _configureADCLowSide(const int pinA,const int pinB,const int pinC)
+
+// function configuring low-side current sensing 
+void* _configureADCLowSide(const void* driver_params, const int pinA,const int pinB,const int pinC)
 {
+  _UNUSED(driver_params);
+
   _pinA = pinA;
   _pinB = pinB; 
   _pinC = pinC;
   freeRunning = true;
   instance.init(pinA, pinB, pinC);
 
+  GenericCurrentSenseParams* params = new GenericCurrentSenseParams {
+    .pins = { pinA, pinB, pinC }
+  };
+
+  return params;
 }
 void _startADC3PinConversionLowSide()
 {
@@ -33,8 +35,10 @@ void _startADC3PinConversionLowSide()
  * 
  * @param pinA - the arduino pin to be read (it has to be ADC pin)
  */
-float _readADCVoltageLowSide(const int pinA)
+float _readADCVoltageLowSide(const int pinA, const void* cs_params)
 {
+  _UNUSED(cs_params);
+
   instance.readResults(a, b, c);
 
   if(pinA == _pinA)
@@ -50,8 +54,11 @@ float _readADCVoltageLowSide(const int pinA)
 /**
  *  function syncing the Driver with the ADC  for the LowSide Sensing
  */
-void _driverSyncLowSide()
+void _driverSyncLowSide(void* driver_params, void* cs_params)
 {
+  _UNUSED(driver_params);
+  _UNUSED(cs_params);
+
   SIMPLEFOC_SAMD_DEBUG_SERIAL.println(F("TODO! _driverSyncLowSide() is not implemented"));
   instance.startADCScan();
   //TODO: hook with PWM interrupts

src/current_sense/hardware_specific/samd_mcu.cpp

@@ -1,37 +1,31 @@
 #include "../hardware_api.h" 
 
-#if defined(_SAMD21_)||defined(_SAMD51_)||defined(_SAME51_)
+#if defined(_SAMD21_)|| defined(_SAMD51_) || defined(_SAME51_)
 
 #define _ADC_VOLTAGE 3.3f
 #define _ADC_RESOLUTION 1024.0f
 
-// adc counts to voltage conversion ratio
-// some optimizing for faster execution
-#define _ADC_CONV ( (_ADC_VOLTAGE) / (_ADC_RESOLUTION) )
-
 // function reading an ADC value and returning the read voltage
-float _readADCVoltageInline(const int pinA){
+float _readADCVoltageInline(const int pinA, const void* cs_params){
+  digitalWrite(7,HIGH);
   uint32_t raw_adc = analogRead(pinA);
-  return raw_adc * _ADC_CONV;
+  digitalWrite(7,LOW);
+  return raw_adc * ((GenericCurrentSenseParams*)cs_params)->adc_voltage_conv;
 }
+
 // function reading an ADC value and returning the read voltage
-void _configureADCInline(const int pinA,const int pinB,const int pinC){
+void* _configureADCInline(const void* driver_params, const int pinA,const int pinB,const int pinC){
+  _UNUSED(driver_params);
+  pinMode(7,OUTPUT);
   pinMode(pinA, INPUT);
   pinMode(pinB, INPUT);
   if( _isset(pinC) ) pinMode(pinC, INPUT);
-}
 
+  GenericCurrentSenseParams* params = new GenericCurrentSenseParams {
+    .pins = { pinA, pinB, pinC },
+    .adc_voltage_conv = (_ADC_VOLTAGE)/(_ADC_RESOLUTION)
+  };
 
-// function reading an ADC value and returning the read voltage
-float _readADCVoltageLowSide(const int pinA){
-  return _readADCVoltageInline(pinA);
+  return params;
 }
-// Configure low side for generic mcu
-// cannot do much but 
-void _configureADCLowSide(const int pinA,const int pinB,const int pinC){
-  pinMode(pinA, INPUT);
-  pinMode(pinB, INPUT);
-  if( _isset(pinC) ) pinMode(pinC, INPUT);
-}
-
 #endif