esp32 comparator is possible

Author: askuric

src/current_sense/hardware_specific/esp32/esp32_mcpwm_mcu.cpp

@@ -19,20 +19,24 @@
 
 
 // adding a debug toggle pin to measure the time of the interrupt with oscilloscope
-
 // #define SIMPLEFOC_ESP32_INTERRUPT_DEBUG
 
 #ifdef SIMPLEFOC_ESP32_INTERRUPT_DEBUG
 #include "driver/gpio.h"
 
-#ifdef CONFIG_IDF_TARGET_ESP32S3
+#ifndef DEBUGPIN
+#ifdef CONFIG_IDF_TARGET_ESP32S3 
 #define DEBUGPIN 16
-#define GPIO_NUM GPIO_NUM_16
 #else
 #define DEBUGPIN 19
-#define GPIO_NUM GPIO_NUM_19
+#endif
 #endif
 
+#define GPIO_NUM (gpio_num_t)((int)GPIO_NUM_0 + DEBUGPIN)
+#endif
+
+#ifndef SIMPLEFOC_CS_PRETRIGGER_US
+#define SIMPLEFOC_CS_PRETRIGGER_US 5 // 5 us because ADC read takes around 10us
 #endif
 
 
@@ -120,40 +124,119 @@ static bool IRAM_ATTR _mcpwmTriggerADCCallback(mcpwm_timer_handle_t tim, const m
   return true;
 }
 
+// Comparator on_reach callback: sample ADC pre-trigger
+// In center-aligned mode, comparator fires twice per cycle (up and down)
+// Only sample on down-count to get one sample per PWM period
+static bool IRAM_ATTR _mcpwmComparatorADCCallback(mcpwm_cmpr_handle_t cmpr, const mcpwm_compare_event_data_t* edata, void* user_data){
+  // Only trigger on down-count direction
+  if(edata->direction != MCPWM_TIMER_DIRECTION_UP){
+    return true;
+  }
+
+  ESP32CurrentSenseParams *p = (ESP32CurrentSenseParams*)user_data;
+#ifdef SIMPLEFOC_ESP32_INTERRUPT_DEBUG
+  gpio_set_level(GPIO_NUM,1);
+#endif
+
+  // sample the phase currents one at a time
+  // ESP's adc read takes around 10us which is very long
+  // so we are sampling one phase per call
+  p->adc_buffer[p->buffer_index] = adcRead(p->pins[p->buffer_index]);
+
+  // increment buffer index
+  p->buffer_index++;
+  if(p->buffer_index >= p->no_adc_channels){
+    p->buffer_index = 0;
+  }
+
+#ifdef SIMPLEFOC_ESP32_INTERRUPT_DEBUG
+  gpio_set_level(GPIO_NUM,0);
+#endif
+  return true;
+}
+
 void* IRAM_ATTR _driverSyncLowSide(void* driver_params, void* cs_params){
 #ifdef SIMPLEFOC_ESP32_INTERRUPT_DEBUG
   pinMode(DEBUGPIN, OUTPUT);
 #endif
   ESP32MCPWMDriverParams *p = (ESP32MCPWMDriverParams*)driver_params;
   mcpwm_timer_t* t = (mcpwm_timer_t*) p->timers[0];
+  int group_id = p->group_id;
 
-  // check if low side callback is already set
-  // if it is, return error
-  if(t->on_full != nullptr){
-    SIMPLEFOC_ESP32_CS_DEBUG("ERROR: Low side callback is already set. Cannot set it again for timer: "+String(t->timer_id)+", group: "+String(t->group->group_id));
+  
+  ESP32CurrentSenseParams *cs = (ESP32CurrentSenseParams*)cs_params;
+  if(!cs){
+    SIMPLEFOC_ESP32_CS_DEBUG("ERROR: cs_params is null");
     return SIMPLEFOC_CURRENT_SENSE_INIT_FAILED;
   }
 
-  // set the callback for the low side current sensing
-  // mcpwm_timer_event_callbacks_t can be used to set the callback
-  // for three timer events
-  // - on_full  - low-side
-  // - on_empty - high-side
-  // - on_sync  - sync event (not used with simplefoc)
-  auto cbs = mcpwm_timer_event_callbacks_t{
-    .on_full = _mcpwmTriggerADCCallback,
-  };
-  SIMPLEFOC_ESP32_CS_DEBUG("Timer "+String(t->timer_id)+" enable interrupt callback.");
-  // set the timer state to init (so that we can call the `mcpwm_timer_register_event_callbacks` )
-  // this is a hack, as this function is not supposed to be called when the timer is running
-  // the timer does not really go to the init state!
-  t->fsm = MCPWM_TIMER_FSM_INIT;
-  // set the callback
-  CHECK_CS_ERR(mcpwm_timer_register_event_callbacks(t, &cbs, cs_params), "Failed to set low side callback");
-  // set the timer state to enabled again
-  t->fsm = MCPWM_TIMER_FSM_ENABLE;
-  SIMPLEFOC_ESP32_CS_DEBUG("Timer "+String(t->timer_id)+" enable interrupts.");
-  CHECK_CS_ERR(esp_intr_enable(t->intr), "Failed to enable low-side interrupts!");
+  SIMPLEFOC_ESP32_CS_DEBUG("Configuring sync with comparator...");
+
+  // Create a spare comparator on the first operator for ADC pre-trigger
+  // This comparator will fire ~5 µs before on_reach (peak)
+  mcpwm_comparator_config_t cmp_config = {0};
+  cmp_config.flags.update_cmp_on_tez = true;
+  for(int i=2; i>=0; i--){ // start from the end as first operators are more likely to be used fully
+    if(p->oper[i] == nullptr) continue;
+    if(mcpwm_new_comparator(p->oper[i], &cmp_config, (mcpwm_cmpr_handle_t*)&cs->pretrig_comparator) == ESP_OK){
+      break;
+    }
+  }
+
+  // if comparator creation failed, fall back to on_full callback
+  if (cs->pretrig_comparator){
+    // Calculate pwm duty cycle ticks for pre-trigger channel
+    uint32_t pwm_duty_cycle  = p->mcpwm_period * (0.75 - ((float)p->pwm_frequency*SIMPLEFOC_CS_PRETRIGGER_US)/1e6/2.0);
+    // set up the comparator duty cycle
+    CHECK_CS_ERR(mcpwm_comparator_set_compare_value((mcpwm_cmpr_handle_t)cs->pretrig_comparator, pwm_duty_cycle),
+                "Failed to set pretrigger compare value");
+
+    // Register comparator on_reach callback for ADC sampling
+    mcpwm_comparator_event_callbacks_t cmp_cbs = {
+      .on_reach = _mcpwmComparatorADCCallback
+    };
+    // register the callback
+    CHECK_CS_ERR(mcpwm_comparator_register_event_callbacks((mcpwm_cmpr_handle_t)cs->pretrig_comparator, &cmp_cbs, cs_params),
+                "Failed to register comparator callback");
+
+    SIMPLEFOC_ESP32_CS_DEBUG("MCPWM"+String(group_id)+" Timer "+String(t->timer_id)+" pretrigger comparator configured.");
+    // notify the driver code that low side is uses one comparator
+    _notifyLowSideUsingComparator(group_id);
+
+  }else{
+
+    SIMPLEFOC_ESP32_CS_DEBUG("WARN: Failed to create comparator!");
+    SIMPLEFOC_ESP32_CS_DEBUG("Configuring sync with on_full callback (less accurate)...");
+
+    // check if low side callback is already set
+    // if it is, return error
+    if(t->on_full != nullptr){
+      SIMPLEFOC_ESP32_CS_DEBUG("ERROR: Low side callback is already set. Cannot set it again for timer: "+String(t->timer_id)+", group: "+String(t->group->group_id));
+      return SIMPLEFOC_CURRENT_SENSE_INIT_FAILED;
+    }
+     // set the callback for the low side current sensing
+    // mcpwm_timer_event_callbacks_t can be used to set the callback
+    // for three timer events
+    // - on_full  - low-side
+    // - on_empty - high-side
+    // - on_sync  - sync event (not used with simplefoc)
+    auto cbs = mcpwm_timer_event_callbacks_t{
+      .on_full = _mcpwmTriggerADCCallback,
+    };
+    SIMPLEFOC_ESP32_CS_DEBUG("Timer "+String(t->timer_id)+" enable interrupt callback.");
+    // set the timer state to init (so that we can call the `mcpwm_timer_register_event_callbacks` )
+    // this is a hack, as this function is not supposed to be called when the timer is running
+    // the timer does not really go to the init state!
+    t->fsm = MCPWM_TIMER_FSM_INIT;
+    // set the callback
+    CHECK_CS_ERR(mcpwm_timer_register_event_callbacks(t, &cbs, cs_params), "Failed to set low side callback");
+    // set the timer state to enabled again
+    t->fsm = MCPWM_TIMER_FSM_ENABLE;
+    CHECK_CS_ERR(esp_intr_enable(t->intr), "Failed to enable low-side interrupts!");
+
+    SIMPLEFOC_ESP32_CS_DEBUG("MCPWM"+String(group_id)+" Timer "+String(t->timer_id)+" on_full callback configured.");
+  }
+
 
   return cs_params;
 }

src/current_sense/hardware_specific/esp32/esp32_mcu.h

@@ -17,6 +17,7 @@ typedef struct ESP32CurrentSenseParams {
   int adc_buffer[3] = {};
   int buffer_index = 0;
   int no_adc_channels = 0;
+  void* pretrig_comparator = nullptr; // MCPWM comparator handle for ADC pre-trigger
 } ESP32CurrentSenseParams;
 
 // macros for debugging wuing the simplefoc debug system

src/drivers/hardware_specific/esp32/esp32_driver_mcpwm.cpp

@@ -121,7 +121,9 @@ uint8_t group_pins_used[2] = {0};
 // last operator in the group
 mcpwm_oper_handle_t last_operator[2];
 
-
+void _notifyLowSideUsingComparator(int group_id){
+  group_pins_used[group_id] +=1;
+}
 
 // checking if group has pins available
 bool _hasAvailablePins(int group, int no_pins){

src/drivers/hardware_specific/esp32/esp32_driver_mcpwm.h

@@ -158,5 +158,11 @@ void _setDutyCycle(mcpwm_cmpr_handle_t cmpr, uint32_t mcpwm_period, float duty_c
  */
 void _forcePhaseState(mcpwm_gen_handle_t generator_high, mcpwm_gen_handle_t generator_low, PhaseState phase_state);
 
+/**
+ * function notifying the driver that low side is used with comparator
+ * @param group_id - mcpwm group id
+ */
+void _notifyLowSideUsingComparator(int group_id);
+
 #endif
 #endif