software 6-PWM is working

Author: Richard Unger

src/drivers/hardware_specific/renesas/renesas.cpp

@@ -97,16 +97,17 @@ ClockDivAndRange getClockDivAndRange(uint32_t pwm_frequency, uint8_t timer_chann
   else {
       SimpleFOCDebug::println("DRV: PWM frequency too low");
   }
-
   return result;
 };
 
 
-bool configureTimerPin(RenesasHardwareDriverParams* params, uint8_t index) {
+bool configureTimerPin(RenesasHardwareDriverParams* params, uint8_t index, bool active_high, bool complementary = false, bool complementary_active_high = true) {
   uint8_t pin = params->pins[index];
+  uint8_t pin_C;
   std::array<uint16_t, 3> pinCfgs = getPinCfgs(pin, PIN_CFG_REQ_PWM);
+  std::array<uint16_t, 3> pinCfgs_C;
   if(pinCfgs[0] == 0) {
-    SIMPLEFOC_DEBUG("DRV: no PWM on pin");
+    SIMPLEFOC_DEBUG("DRV: no PWM on pin ", pin);
     return false;
   }
   if (IS_PIN_AGT_PWM(pinCfgs[0])) {
@@ -121,24 +122,46 @@ bool configureTimerPin(RenesasHardwareDriverParams* params, uint8_t index) {
     return false;
   }
 
+  if (complementary) {
+    pin_C = params->pins[index+1];
+    pinCfgs_C = getPinCfgs(pin_C, PIN_CFG_REQ_PWM);
+    if(pinCfgs_C[0] == 0) {
+      SIMPLEFOC_DEBUG("DRV: no PWM on pin ", pin_C);
+      return false;
+    }
+    if (IS_PIN_AGT_PWM(pinCfgs_C[0]) || GET_CHANNEL(pinCfgs_C[0])!=timer_channel) {
+      SIMPLEFOC_DEBUG("DRV: comp. channel different");
+      return false;
+    }
+  }
+  TimerPWMChannel_t pwm_output = IS_PWM_ON_A(pinCfgs[0]) ? CHANNEL_A : CHANNEL_B;
+  if (complementary) {
+    TimerPWMChannel_t pwm_output_C = IS_PWM_ON_A(pinCfgs_C[0]) ? CHANNEL_A : CHANNEL_B;
+    if (pwm_output != CHANNEL_A || pwm_output_C != CHANNEL_B) {
+      SIMPLEFOC_DEBUG("DRV: output A/B mismatch");
+      return false;
+    }
+  }
+
   // configure GPIO pin
-  // pinMode(pin, OUTPUT);
   fsp_err_t err = R_IOPORT_PinCfg(&g_ioport_ctrl, g_pin_cfg[pin].pin, (uint32_t) (IOPORT_CFG_PERIPHERAL_PIN | IOPORT_PERIPHERAL_GPT1));
+  if ((err == FSP_SUCCESS) && complementary)
+    err = R_IOPORT_PinCfg(&g_ioport_ctrl, g_pin_cfg[pin_C].pin, (uint32_t) (IOPORT_CFG_PERIPHERAL_PIN | IOPORT_PERIPHERAL_GPT1));
   if (err != FSP_SUCCESS) {
     SIMPLEFOC_DEBUG("DRV: pin config failed");
     return false;
   }
 
-  TimerPWMChannel_t pwm_output = IS_PWM_ON_A(pinCfgs[0]) ? CHANNEL_A : CHANNEL_B;  
-
 
   // configure timer channel - frequency / top value
   ClockDivAndRange timings = getClockDivAndRange(params->pwm_frequency, timer_channel);
   #if defined(SIMPLEFOC_RENESAS_DEBUG)
   SimpleFOCDebug::println("---PWM Config---");
   SimpleFOCDebug::println("DRV: pwm pin: ", pin);
+  if (complementary)
+    SimpleFOCDebug::println("DRV: compl. pin: ", pin_C);
   SimpleFOCDebug::println("DRV: pwm channel: ", timer_channel);
-  SimpleFOCDebug::print("DRV: pwm A/B: "); SimpleFOCDebug::println((pwm_output==CHANNEL_A)?"A":"B");
+  SimpleFOCDebug::print("DRV: pwm A/B: "); SimpleFOCDebug::println(complementary?"A+B":((pwm_output==CHANNEL_A)?"A":"B"));
   SimpleFOCDebug::println("DRV: pwm freq: ", (int)params->pwm_frequency);
   SimpleFOCDebug::println("DRV: pwm range: ", (int)timings.range);
   SimpleFOCDebug::println("DRV: pwm clkdiv: ", timings.clk_div);
@@ -171,35 +194,45 @@ bool configureTimerPin(RenesasHardwareDriverParams* params, uint8_t index) {
   t->pwm_cfg.interrupt_skip_adc = GPT_INTERRUPT_SKIP_ADC_NONE;
   t->pwm_cfg.gtioca_disable_setting = GPT_GTIOC_DISABLE_PROHIBITED;
   t->pwm_cfg.gtiocb_disable_setting = GPT_GTIOC_DISABLE_PROHIBITED;
+  // configure dead-time if both outputs are used
+  if (complementary) {
+    uint32_t dt = params->dead_zone * timings.range;
+    t->pwm_cfg.dead_time_count_up = dt;
+    t->pwm_cfg.dead_time_count_down = dt;
+  }
 
-
-
-  // configure timer channel - polarity
+  // configure timer channel - outputs and polarity
   t->ext_cfg.gtior_setting.gtior = 0L;
-  if(pwm_output == CHANNEL_A) {
-      t->duty_pin = GPT_IO_PIN_GTIOCA;
-      t->ext_cfg.gtioca.output_enabled = true;
-      t->ext_cfg.gtiocb.output_enabled = false;
-      t->ext_cfg.gtior_setting.gtior_b.gtioa = 0x03 | (SIMPLEFOC_PWM_ACTIVE_HIGH ? 0x00 : 0x08);
-      t->ext_cfg.gtior_setting.gtior_b.oadflt = SIMPLEFOC_PWM_ACTIVE_HIGH ? 0x00 : 0x01;
-      t->ext_cfg.gtior_setting.gtior_b.oahld = 0x0;
-      t->ext_cfg.gtior_setting.gtior_b.oadf = 0x0;
-      t->ext_cfg.gtior_setting.gtior_b.nfaen = 0x0;
-  } 
+  if (!complementary) {
+    if(pwm_output == CHANNEL_A) {
+        t->duty_pin = GPT_IO_PIN_GTIOCA;
+        t->ext_cfg.gtioca.output_enabled = true;
+        t->ext_cfg.gtiocb.output_enabled = false;
+        t->ext_cfg.gtior_setting.gtior_b.gtioa = 0x03 | (active_high ? 0x00 : 0x10);
+        t->ext_cfg.gtior_setting.gtior_b.oadflt = active_high ? 0x00 : 0x01;
+        // t->ext_cfg.gtior_setting.gtior_b.oahld = 0x0;
+        // t->ext_cfg.gtior_setting.gtior_b.oadf = 0x0;
+        // t->ext_cfg.gtior_setting.gtior_b.nfaen = 0x0;
+    } 
+    else {
+        t->duty_pin = GPT_IO_PIN_GTIOCB;
+        t->ext_cfg.gtiocb.output_enabled = true;
+        t->ext_cfg.gtioca.output_enabled = false;
+        t->ext_cfg.gtior_setting.gtior_b.gtiob = 0x03 | (active_high ? 0x00 : 0x10);
+        t->ext_cfg.gtior_setting.gtior_b.obdflt = active_high ? 0x00 : 0x01;
+    }
+  }
   else {
-      t->duty_pin = GPT_IO_PIN_GTIOCB;
-      t->ext_cfg.gtiocb.output_enabled = true;
-      t->ext_cfg.gtioca.output_enabled = false;
-      t->ext_cfg.gtior_setting.gtior_b.gtiob = 0x03 | (SIMPLEFOC_PWM_ACTIVE_HIGH ? 0x00 : 0x08);
-      t->ext_cfg.gtior_setting.gtior_b.obdflt = SIMPLEFOC_PWM_ACTIVE_HIGH ? 0x00 : 0x01;
-      t->ext_cfg.gtior_setting.gtior_b.obhld = 0x0;
-      t->ext_cfg.gtior_setting.gtior_b.obdf = 0x0;
-      t->ext_cfg.gtior_setting.gtior_b.nfben = 0x0;
-  }
-  // t->duty_pin = GPT_IO_PIN_GTIOCA_AND_GTIOCB;
-  // TODO configure timer channel - dead-time if both outputs are used
-  memset(&(t->ctrl), 0, sizeof(gpt_instance_ctrl_t));
+    t->duty_pin = GPT_IO_PIN_GTIOCA_AND_GTIOCB;
+    t->ext_cfg.gtioca.output_enabled = true;
+    t->ext_cfg.gtiocb.output_enabled = true;
+    t->ext_cfg.gtior_setting.gtior_b.gtioa = 0x03 | (active_high ? 0x00 : 0x10);
+    t->ext_cfg.gtior_setting.gtior_b.oadflt = active_high ? 0x00 : 0x01;
+    t->ext_cfg.gtior_setting.gtior_b.gtiob = 0x03 | (complementary_active_high ? 0x00 : 0x10);
+    t->ext_cfg.gtior_setting.gtior_b.obdflt = complementary_active_high ? 0x00 : 0x01;
+  }
 
+  memset(&(t->ctrl), 0, sizeof(gpt_instance_ctrl_t));
   err = R_GPT_Open(&(t->ctrl),&(t->timer_cfg));
   if ((err != FSP_ERR_ALREADY_OPEN) && (err != FSP_SUCCESS)) {
     SIMPLEFOC_DEBUG("DRV: open failed");
@@ -210,11 +243,6 @@ bool configureTimerPin(RenesasHardwareDriverParams* params, uint8_t index) {
     SimpleFOCDebug::println("DRV: timer already open");
   }
   #endif
-  // err = R_GPT_Enable(&(t->ctrl));
-  // if (err != FSP_SUCCESS) {
-  //   SIMPLEFOC_DEBUG("DRV: enable failed");
-  //   return false;
-  // }
   err = R_GPT_PeriodSet(&(t->ctrl), t->timer_cfg.period_counts);
   if (err != FSP_SUCCESS) {
     SIMPLEFOC_DEBUG("DRV: period set failed");
@@ -225,17 +253,21 @@ bool configureTimerPin(RenesasHardwareDriverParams* params, uint8_t index) {
     SIMPLEFOC_DEBUG("DRV: pin enable failed");
     return false;
   }
+
+  channel_used[timer_channel] = true;
   params->timer_config[index] = t;
   params->channels[index] = timer_channel;
-  channel_used[timer_channel] = true;
+  if (complementary) {
+    params->timer_config[index+1] = t;
+    params->channels[index+1] = timer_channel;
+  }
 
   return true;
 }
 
 
+// start the timer channels for the motor, synchronously
 bool startTimerChannels(RenesasHardwareDriverParams* params, int num_channels) {
-
-  // start the channels
   uint32_t mask = 0;
   for (int i = 0; i < num_channels; i++) {
     RenesasTimerConfig* t = params->timer_config[i];
@@ -256,6 +288,18 @@ bool startTimerChannels(RenesasHardwareDriverParams* params, int num_channels) {
 }
 
 
+// check if the given pins are on the same timer channel
+bool isHardware6Pwm(const int pin1, const int pin2) {
+  std::array<uint16_t, 3> pinCfgs1 = getPinCfgs(pin1, PIN_CFG_REQ_PWM);
+  std::array<uint16_t, 3> pinCfgs2 = getPinCfgs(pin2, PIN_CFG_REQ_PWM);
+  if(pinCfgs1[0] == 0 || pinCfgs2[0] == 0)
+    return false;
+  if (IS_PIN_AGT_PWM(pinCfgs1[0]) || IS_PIN_AGT_PWM(pinCfgs2[0]))
+    return false;
+  uint8_t timer_channel1 = GET_CHANNEL(pinCfgs1[0]);
+  uint8_t timer_channel2 = GET_CHANNEL(pinCfgs2[0]);
+  return timer_channel1==timer_channel2;
+}
 
 
 
@@ -264,7 +308,7 @@ void* _configure1PWM(long pwm_frequency, const int pinA) {
   params->pins[0] = pinA;
   params->pwm_frequency = (pwm_frequency==NOT_SET)?RENESAS_DEFAULT_PWM_FREQUENCY:pwm_frequency;
   bool success = true;
-  success = configureTimerPin(params, 0);
+  success = configureTimerPin(params, 0, SIMPLEFOC_PWM_ACTIVE_HIGH);
   if (success)
     success = startTimerChannels(params, 1);
   if (!success)
@@ -278,11 +322,10 @@ void* _configure2PWM(long pwm_frequency,const int pinA, const int pinB) {
   params->pins[0] = pinA; params->pins[1] = pinB;
   params->pwm_frequency = (pwm_frequency==NOT_SET)?RENESAS_DEFAULT_PWM_FREQUENCY:pwm_frequency;
   bool success = true;
-  success = configureTimerPin(params, 0);
-  if (success)
-    success = configureTimerPin(params, 1);
-  if (success)
-    success = startTimerChannels(params, 2);
+  success = configureTimerPin(params, 0, SIMPLEFOC_PWM_ACTIVE_HIGH);
+  success &= configureTimerPin(params, 1, SIMPLEFOC_PWM_ACTIVE_HIGH);
+  if (!success)
+    success &= startTimerChannels(params, 2);
   if (!success)
     return SIMPLEFOC_DRIVER_INIT_FAILED;
   return params;
@@ -294,11 +337,9 @@ void* _configure3PWM(long pwm_frequency,const int pinA, const int pinB, const in
   params->pins[0] = pinA; params->pins[1] = pinB; params->pins[2] = pinC;
   params->pwm_frequency = (pwm_frequency==NOT_SET)?RENESAS_DEFAULT_PWM_FREQUENCY:pwm_frequency;
   bool success = true;
-  success = configureTimerPin(params, 0);
-  if (success)
-    success = configureTimerPin(params, 1);
-  if (success)
-    success = configureTimerPin(params, 2);
+  success = configureTimerPin(params, 0, SIMPLEFOC_PWM_ACTIVE_HIGH);
+  success &= configureTimerPin(params, 1, SIMPLEFOC_PWM_ACTIVE_HIGH);
+  success &= configureTimerPin(params, 2, SIMPLEFOC_PWM_ACTIVE_HIGH);
   if (success)
     success = startTimerChannels(params, 3);
   if (!success)
@@ -312,13 +353,10 @@ void* _configure4PWM(long pwm_frequency, const int pin1A, const int pin1B, const
   params->pins[0] = pin1A; params->pins[1] = pin1B; params->pins[2] = pin2A; params->pins[3] = pin2B;
   params->pwm_frequency = (pwm_frequency==NOT_SET)?RENESAS_DEFAULT_PWM_FREQUENCY:pwm_frequency;
   bool success = true;
-  success = configureTimerPin(params, 0);
-  if (success)
-    success = configureTimerPin(params, 1);
-  if (success)
-    success = configureTimerPin(params, 2);
-  if (success)
-    success = configureTimerPin(params, 3);
+  success = configureTimerPin(params, 0, SIMPLEFOC_PWM_ACTIVE_HIGH);
+  success &= configureTimerPin(params, 1, SIMPLEFOC_PWM_ACTIVE_HIGH);
+  success &= configureTimerPin(params, 2, SIMPLEFOC_PWM_ACTIVE_HIGH);
+  success &= configureTimerPin(params, 3, SIMPLEFOC_PWM_ACTIVE_HIGH);
   if (success)
     success = startTimerChannels(params, 4);
   if (!success)
@@ -328,10 +366,38 @@ void* _configure4PWM(long pwm_frequency, const int pin1A, const int pin1B, const
 
 
 void* _configure6PWM(long pwm_frequency, float dead_zone, const int pinA_h, const int pinA_l,  const int pinB_h, const int pinB_l, const int pinC_h, const int pinC_l){
-  GenericDriverParams* params = new GenericDriverParams {
-    .pins = { pinA_h, pinA_l, pinB_h, pinB_l, pinC_h, pinC_l },
-    .pwm_frequency = pwm_frequency
-  };
+  RenesasHardwareDriverParams* params = new RenesasHardwareDriverParams;
+  params->pins[0] = pinA_h; params->pins[1] = pinA_l; params->pins[2] = pinB_h; params->pins[3] = pinB_l; params->pins[4] = pinC_h; params->pins[5] = pinC_l;
+  params->pwm_frequency = (pwm_frequency==NOT_SET)?RENESAS_DEFAULT_PWM_FREQUENCY:pwm_frequency;
+  params->dead_zone = (dead_zone==NOT_SET)?RENESAS_DEFAULT_DEAD_ZONE:dead_zone;
+
+  bool success = true;
+  if (isHardware6Pwm(pinA_h, pinA_l)) {
+    success &= configureTimerPin(params, 0, SIMPLEFOC_PWM_HIGHSIDE_ACTIVE_HIGH, true, !(SIMPLEFOC_PWM_LOWSIDE_ACTIVE_HIGH));
+  }
+  else {
+    success &= configureTimerPin(params, 0, SIMPLEFOC_PWM_HIGHSIDE_ACTIVE_HIGH);
+    success &= configureTimerPin(params, 1, !(SIMPLEFOC_PWM_LOWSIDE_ACTIVE_HIGH)); // reverse polarity on low side gives desired active high/low behaviour
+  }
+  if (isHardware6Pwm(pinB_h, pinB_l)) {
+    success &= configureTimerPin(params, 2, SIMPLEFOC_PWM_HIGHSIDE_ACTIVE_HIGH, true, !(SIMPLEFOC_PWM_LOWSIDE_ACTIVE_HIGH));
+  }
+  else {
+    success &= configureTimerPin(params, 2, SIMPLEFOC_PWM_HIGHSIDE_ACTIVE_HIGH);
+    success &= configureTimerPin(params, 3, !(SIMPLEFOC_PWM_LOWSIDE_ACTIVE_HIGH));
+  }
+  if (isHardware6Pwm(pinC_h, pinC_l)) {
+    success &= configureTimerPin(params, 4, SIMPLEFOC_PWM_HIGHSIDE_ACTIVE_HIGH, true, !(SIMPLEFOC_PWM_LOWSIDE_ACTIVE_HIGH));
+  }
+  else {
+    success &= configureTimerPin(params, 4, SIMPLEFOC_PWM_HIGHSIDE_ACTIVE_HIGH);
+    success &= configureTimerPin(params, 5, !(SIMPLEFOC_PWM_LOWSIDE_ACTIVE_HIGH));
+  }
+
+  if (success)
+    success = startTimerChannels(params, 6);
+  if (!success)
+    return SIMPLEFOC_DRIVER_INIT_FAILED;
   return params;
 }
 
@@ -364,24 +430,18 @@ void _writeDutyCycle2PWM(float dc_a,  float dc_b, void* params){
 void _writeDutyCycle3PWM(float dc_a,  float dc_b, float dc_c, void* params){
   RenesasTimerConfig* t = ((RenesasHardwareDriverParams*)params)->timer_config[0];
   uint32_t duty_cycle_counts = (uint32_t)(dc_a * (float)(t->timer_cfg.period_counts));
-  //SimpleFOCDebug::println("Duty A: ", (int)duty_cycle_counts);
   if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts, t->duty_pin) != FSP_SUCCESS) {
       // error
-      Serial.println("pwm set error A");
   }
   t = ((RenesasHardwareDriverParams*)params)->timer_config[1];
   duty_cycle_counts = (uint32_t)(dc_b * (float)(t->timer_cfg.period_counts));
-  //SimpleFOCDebug::println("Duty B: ", (int)duty_cycle_counts);
   if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts, t->duty_pin) != FSP_SUCCESS) {
       // error
-      Serial.println("pwm set error B");
   }
   t = ((RenesasHardwareDriverParams*)params)->timer_config[2];
   duty_cycle_counts = (uint32_t)(dc_c * (float)(t->timer_cfg.period_counts));
-  //SimpleFOCDebug::println("Duty C: ", (int)duty_cycle_counts);
   if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts, t->duty_pin) != FSP_SUCCESS) {
       // error
-      Serial.println("pwm set error C");
   }
 }
 
@@ -410,7 +470,50 @@ void _writeDutyCycle4PWM(float dc_1a,  float dc_1b, float dc_2a, float dc_2b, vo
 }
 
 
+  // TODO phase-state
 void _writeDutyCycle6PWM(float dc_a,  float dc_b, float dc_c, PhaseState *phase_state, void* params){
+  RenesasTimerConfig* t = ((RenesasHardwareDriverParams*)params)->timer_config[0];
+  uint32_t dt = (uint32_t)(((RenesasHardwareDriverParams*)params)->dead_zone * (float)(t->timer_cfg.period_counts));
+  uint32_t duty_cycle_counts = (uint32_t)(dc_a * (float)(t->timer_cfg.period_counts));
+  bool hw_deadtime = ((RenesasHardwareDriverParams*)params)->channels[0] == ((RenesasHardwareDriverParams*)params)->channels[1];
+  uint32_t dt_act = (duty_cycle_counts>0 && !hw_deadtime)?dt:0;
+  if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts - dt_act, t->duty_pin) != FSP_SUCCESS) {
+      // error
+  }
+  if (!hw_deadtime) {
+    t = ((RenesasHardwareDriverParams*)params)->timer_config[1];
+    if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts + dt_act, t->duty_pin) != FSP_SUCCESS) {
+        // error
+    }    
+  }
+
+  t = ((RenesasHardwareDriverParams*)params)->timer_config[2];
+  duty_cycle_counts = (uint32_t)(dc_b * (float)(t->timer_cfg.period_counts));
+  hw_deadtime = ((RenesasHardwareDriverParams*)params)->channels[2] == ((RenesasHardwareDriverParams*)params)->channels[3];
+  dt_act = (duty_cycle_counts>0 && !hw_deadtime)?dt:0;
+  if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts - dt_act, t->duty_pin) != FSP_SUCCESS) {
+      // error
+  }
+  if (!hw_deadtime) {
+    t = ((RenesasHardwareDriverParams*)params)->timer_config[3];
+    if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts + dt_act, t->duty_pin) != FSP_SUCCESS) {
+        // error
+    }    
+  }
+
+  t = ((RenesasHardwareDriverParams*)params)->timer_config[4];
+  duty_cycle_counts = (uint32_t)(dc_c * (float)(t->timer_cfg.period_counts));
+  hw_deadtime = ((RenesasHardwareDriverParams*)params)->channels[4] == ((RenesasHardwareDriverParams*)params)->channels[5];
+  dt_act = (duty_cycle_counts>0 && !hw_deadtime)?dt:0;
+  if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts, t->duty_pin) != FSP_SUCCESS) {
+      // error
+  }
+  if (!hw_deadtime) {
+    t = ((RenesasHardwareDriverParams*)params)->timer_config[5];
+    if (R_GPT_DutyCycleSet(&(t->ctrl), duty_cycle_counts + dt_act, t->duty_pin) != FSP_SUCCESS) {
+        // error
+    }    
+  }
 
 }
 

src/drivers/hardware_specific/renesas/renesas.h

@@ -11,6 +11,7 @@
 #define SIMPLEFOC_RENESAS_DEBUG
 
 #define RENESAS_DEFAULT_PWM_FREQUENCY 24000
+#define RENESAS_DEFAULT_DEAD_ZONE 0.05f
 
 struct RenesasTimerConfig;