MCPWM now working

dependencies.lock

@@ -2,7 +2,7 @@ dependencies:
   idf:
     source:
       type: idf
-    version: 5.3.0
+    version: 5.3.1
 manifest_hash: 482e2222071e855d99a96f5a61a37a4f589f24e7994d6610de1e65027e5a15a9
 target: esp32
 version: 2.0.0

main/CMakeLists.txt

@@ -1,3 +1,3 @@
 idf_component_register(SRCS "functions.c" "app_main.c"
                        INCLUDE_DIRS "include""${CMAKE_SOURCE_DIR}""."
-                       REQUIRES ssd1306 driver esp_adc soc)
+                       REQUIRES ssd1306 driver esp_adc hal)

main/app_main.c

@@ -19,9 +19,7 @@ void app_main(void)
     configure_GPIO_dir(TAG);
     adc_oneshot_unit_handle_t adc1_handle = configure_ADC1(TAG);    
     SSD1306_t *dev_pt = configure_OLED(TAG);
-    
+    conf_mcpwm_timers();
-    set_PWM_Timer();
-    set_PWM();
     int i =3;
     
     //gpio_set_level(CONFIG_HIN_V_GPIO, 1);

main/functions.c

@@ -7,7 +7,7 @@ adc_cali_handle_t cali_handle= NULL;
 /*############################################*/
 void configure_GPIO_dir(const char *TAG)
 {
-    /* reset every used GPIO-pin */
+    /* reset every used GPIO-pin *
     gpio_reset_pin(CONFIG_HIN_U_GPIO);
     gpio_reset_pin(CONFIG_HIN_V_GPIO);
     gpio_reset_pin(CONFIG_HIN_W_GPIO);
@@ -15,7 +15,7 @@ void configure_GPIO_dir(const char *TAG)
     gpio_reset_pin(CONFIG_LIN_U_GPIO);
     gpio_reset_pin(CONFIG_LIN_V_GPIO);
     gpio_reset_pin(CONFIG_LIN_W_GPIO);
-
+*/
     gpio_reset_pin(CONFIG_HALL_A_GPIO);
     gpio_reset_pin(CONFIG_HALL_B_GPIO);
     gpio_reset_pin(CONFIG_HALL_C_GPIO);
@@ -30,7 +30,7 @@ void configure_GPIO_dir(const char *TAG)
     gpio_reset_pin(CONFIG_EXT_ENC_RIGHT_GPIO);
     gpio_reset_pin(CONFIG_RFE_GPIO);
 
-    /* Set the GPIO as a push/pull output */
+    /* Set the GPIO as a push/pull output
     gpio_set_direction(CONFIG_HIN_U_GPIO, GPIO_MODE_OUTPUT);
     gpio_set_direction(CONFIG_HIN_V_GPIO, GPIO_MODE_OUTPUT);
     gpio_set_direction(CONFIG_HIN_W_GPIO, GPIO_MODE_OUTPUT);
@@ -38,7 +38,7 @@ void configure_GPIO_dir(const char *TAG)
     gpio_set_direction(CONFIG_LIN_U_GPIO, GPIO_MODE_OUTPUT);
     gpio_set_direction(CONFIG_LIN_V_GPIO, GPIO_MODE_OUTPUT);
     gpio_set_direction(CONFIG_LIN_W_GPIO, GPIO_MODE_OUTPUT);
-
+*/
     gpio_set_direction(CONFIG_HALL_A_GPIO, GPIO_MODE_INPUT);
     gpio_set_direction(CONFIG_HALL_B_GPIO, GPIO_MODE_INPUT);
     gpio_set_direction(CONFIG_HALL_C_GPIO, GPIO_MODE_INPUT);
@@ -298,36 +298,211 @@ void W_V_start(int duty)
 /*############################################*/
 /*############### MCPWM-Setup ################*/
 /*############################################*/
-void set_mcpwm_U_V(){
+void conf_mcpwm_timers(){
-    mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, CONFIG_HIN_U_GPIO);
+    ESP_LOGI("MCPWM","started");
-    mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0B, CONFIG_LIN_U_GPIO);
+   mcpwm_timer_handle_t timer_U = NULL;
-    mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM1A, CONFIG_HIN_V_GPIO);
+   mcpwm_timer_handle_t timer_V = NULL;
-    mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM1B, CONFIG_LIN_V_GPIO);
+   mcpwm_timer_handle_t timer_W = NULL;
-
+//creating timer configs and linking them with the timers
-    mcpwm_config_t pwm_config_U = {
+    mcpwm_timer_config_t timer_U_config = 
-        .frequency = 20000,
+    {
-        .cmpr_a = 50.0,
+        .group_id = 0,
-        .cmpr_b = 50.0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
-        .counter_mode = MCPWM_UP_DOWN_COUNTER,
+        .resolution_hz = 40000000, // 1MHz Auflösung
-        .duty_mode = MCPWM_DUTY_MODE_0,
+        .period_ticks = 2000,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
     };
-    //Initialisierung von Halbbrücke U (Timer 0)
+    ESP_ERROR_CHECK(mcpwm_new_timer(&timer_U_config, &timer_U));
-    mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_0, &pwm_config_U);
+
-     mcpwm_config_t pwm_config_V = {
+    mcpwm_timer_config_t timer_V_config = 
-        .frequency = 20000,
+    {
-        .cmpr_a = 50.0,
+        .group_id = 0,
-        .cmpr_b = 50.0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
-        .counter_mode = MCPWM_UP_DOWN_COUNTER,
+        .resolution_hz = 40000000, // 1MHz Auflösung
-        .duty_mode = MCPWM_DUTY_MODE_0,
+        .period_ticks = 2000,
-    };
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
-    //Initialisierung von Halbbrücke V (Timer 1)
+    };
-    mcpwm_init(MCPWM_UNIT_0, MCPWM_TIMER_1, &pwm_config_V);
+    ESP_ERROR_CHECK(mcpwm_new_timer(&timer_V_config, &timer_V));
-    mcpwm_sync_enable(MCPWM_UNIT_0, MCPWM_TIMER_1, MCPWM_SELECT_TIMER0_SYNC, 13);
+
+    mcpwm_timer_config_t timer_W_config = 
+    {
+        .group_id = 0,
+        .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
+        .resolution_hz = 40000000, // 1MHz Auflösung
+        .period_ticks = 2000,
+        .count_mode = MCPWM_TIMER_COUNT_MODE_UP,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_timer(&timer_W_config, &timer_W));
+
+    ESP_ERROR_CHECK(mcpwm_timer_enable(timer_U));
+    ESP_ERROR_CHECK(mcpwm_timer_start_stop(timer_U,MCPWM_TIMER_START_NO_STOP));
+    ESP_ERROR_CHECK(mcpwm_timer_enable(timer_V));
+    ESP_ERROR_CHECK(mcpwm_timer_start_stop(timer_V,MCPWM_TIMER_START_NO_STOP));
+    ESP_ERROR_CHECK(mcpwm_timer_enable(timer_W));
+    ESP_ERROR_CHECK(mcpwm_timer_start_stop(timer_W,MCPWM_TIMER_START_NO_STOP));
+
+
+//set Timer_U as an sync_signal
+    mcpwm_sync_handle_t sync_signal = NULL;
+    mcpwm_timer_sync_src_config_t sync_src_config = 
+    {
+        .flags.propagate_input_sync = false,
+        .timer_event = MCPWM_TIMER_EVENT_EMPTY,
+
+    };
+    ESP_ERROR_CHECK(mcpwm_new_timer_sync_src(timer_U,&sync_src_config, &sync_signal));
+//set Timer_V as an Slave of Timer_U with another phase 
+    mcpwm_timer_sync_phase_config_t sync_phase_V_config = 
+    {
+        .sync_src = sync_signal,
+        .count_value = 667, //120 degree delayed
+    };
+    ESP_ERROR_CHECK(mcpwm_timer_set_phase_on_sync(timer_V,&sync_phase_V_config));
+//set Timer_W as an Slave of Timer_U with another phase 
+    mcpwm_timer_sync_phase_config_t sync_phase_W_config = 
+    {
+        .sync_src = sync_signal,
+        .count_value = 1333, //240 degree delayed
+    };
+    ESP_ERROR_CHECK(mcpwm_timer_set_phase_on_sync(timer_W,&sync_phase_W_config));    
+
+//create Operators
+    mcpwm_oper_handle_t operator_U = NULL;
+    mcpwm_oper_handle_t operator_V = NULL;
+    mcpwm_oper_handle_t operator_W = NULL; 
+    //Operator for Timer_U
+    mcpwm_operator_config_t operator_U_config = 
+    {
+        .group_id=0,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_operator(&operator_U_config,&operator_U));
+    //Operator for Timer_V
+    mcpwm_operator_config_t operator_V_config = 
+    {
+        .group_id=0,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_operator(&operator_V_config,&operator_V));
+    //Operator for Timer_W
+    mcpwm_operator_config_t operator_W_config = 
+    {
+        .group_id=0,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_operator(&operator_W_config,&operator_W));
+    
+    //connect PWM-Signals with Timers
+    ESP_ERROR_CHECK(mcpwm_operator_connect_timer(operator_U, timer_U));
+    ESP_ERROR_CHECK(mcpwm_operator_connect_timer(operator_V, timer_V));
+    ESP_ERROR_CHECK(mcpwm_operator_connect_timer(operator_W, timer_W));
+
+    //create PWM-Signals
+    mcpwm_cmpr_handle_t comperator_U = NULL;
+    mcpwm_cmpr_handle_t comperator_V = NULL;
+    mcpwm_cmpr_handle_t comperator_W = NULL;
+
+    mcpwm_comparator_config_t comparator_U_config = {
+        .flags.update_cmp_on_tez = true,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_comparator(operator_U, &comparator_U_config,&comperator_U));
+    ESP_ERROR_CHECK(mcpwm_comparator_set_compare_value(comperator_U, 1000));//=50% Duty cycle
+
+    mcpwm_comparator_config_t comparator_V_config = {
+        .flags.update_cmp_on_tez = true,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_comparator(operator_V, &comparator_V_config,&comperator_V));
+    ESP_ERROR_CHECK(mcpwm_comparator_set_compare_value(comperator_V, 1000));//=50% Duty cycle
+
+    mcpwm_comparator_config_t comparator_W_config = {
+        .flags.update_cmp_on_tez = true,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_comparator(operator_W, &comparator_W_config,&comperator_W));
+    ESP_ERROR_CHECK(mcpwm_comparator_set_compare_value(comperator_W, 1000));//=50% Duty cycle
+//create generators for every pin
+    mcpwm_gen_handle_t generator_U_HIN = NULL;
+    mcpwm_gen_handle_t generator_V_HIN = NULL;
+    mcpwm_gen_handle_t generator_W_HIN = NULL;
+    mcpwm_gen_handle_t generator_U_LIN = NULL;
+    mcpwm_gen_handle_t generator_V_LIN = NULL;
+    mcpwm_gen_handle_t generator_W_LIN = NULL;
+    //HIN Pins
+    //HIN_U
+    mcpwm_generator_config_t generator_U_HIN_config ={
+        .gen_gpio_num = CONFIG_HIN_U_GPIO,
+        .flags.pull_down = 1,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_generator(operator_U, &generator_U_HIN_config, &generator_U_HIN));
+
+    //HIN_V
+    mcpwm_generator_config_t generator_V_HIN_config ={
+        .gen_gpio_num = CONFIG_HIN_V_GPIO,
+        .flags.pull_down = 1,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_generator(operator_V, &generator_V_HIN_config, &generator_V_HIN));
+
+    //HIN_W
+    mcpwm_generator_config_t generator_W_HIN_config ={
+        .gen_gpio_num = CONFIG_HIN_W_GPIO,
+        .flags.pull_down = 1,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_generator(operator_W, &generator_W_HIN_config, &generator_W_HIN));
+
+    //LIN_U
+    mcpwm_generator_config_t generator_U_LIN_config ={
+        .gen_gpio_num = CONFIG_LIN_U_GPIO,
+        .flags.invert_pwm = 1,
+        .flags.pull_down = 1,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_generator(operator_U, &generator_U_LIN_config, &generator_U_LIN));
+
+    //LIN_V
+    mcpwm_generator_config_t generator_V_LIN_config ={
+        .gen_gpio_num = CONFIG_LIN_V_GPIO,
+        .flags.invert_pwm = 1,
+        .flags.pull_down = 1,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_generator(operator_V, &generator_V_LIN_config, &generator_V_LIN));
+
+     //LIN_W
+    mcpwm_generator_config_t generator_W_LIN_config ={
+        .gen_gpio_num = CONFIG_LIN_W_GPIO,
+        .flags.invert_pwm = 1,
+        .flags.pull_down = 1,
+    };
+    ESP_ERROR_CHECK(mcpwm_new_generator(operator_W, &generator_W_LIN_config, &generator_W_LIN));
+
+    
+
+   
+    
+    /*ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generator_V_LIN, generator_V_HIN,&deadtime_config));
+    ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generator_W_LIN, generator_W_HIN,&deadtime_config));*/
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_timer_event(generator_U_HIN, MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_compare_event(generator_U_HIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comperator_U, MCPWM_GEN_ACTION_LOW)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_timer_event(generator_U_LIN, MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_compare_event(generator_U_LIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comperator_U, MCPWM_GEN_ACTION_LOW)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_timer_event(generator_V_HIN, MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_compare_event(generator_V_HIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comperator_V, MCPWM_GEN_ACTION_LOW)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_timer_event(generator_V_LIN, MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_compare_event(generator_V_LIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comperator_V, MCPWM_GEN_ACTION_LOW)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_timer_event(generator_W_HIN, MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_compare_event(generator_W_HIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comperator_W, MCPWM_GEN_ACTION_LOW)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_timer_event(generator_W_LIN, MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH)));
+    ESP_ERROR_CHECK(mcpwm_generator_set_action_on_compare_event(generator_W_LIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comperator_W, MCPWM_GEN_ACTION_LOW)));
+    
+    mcpwm_dead_time_config_t deadtime_config = {
+        .posedge_delay_ticks = 20,
+        .negedge_delay_ticks = 0,
+    };
+
+    ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generator_U_HIN, generator_U_HIN,&deadtime_config));
+    ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generator_V_HIN, generator_V_HIN,&deadtime_config));
+    ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generator_W_HIN, generator_W_HIN,&deadtime_config));
+    deadtime_config.posedge_delay_ticks = 0;
+    deadtime_config.negedge_delay_ticks = 20;
+    ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generator_U_HIN, generator_U_LIN, &deadtime_config));
+    ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generator_V_HIN, generator_V_LIN, &deadtime_config));
+    ESP_ERROR_CHECK(mcpwm_generator_set_dead_time(generator_W_HIN, generator_W_LIN, &deadtime_config));
+    
 
-    //Totzeit für Halbbrücke U
-    mcpwm_deadtime_enable(MCPWM_UNIT_0, MCPWM_TIMER_0, MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE, 50, 50);//50ns steigende Flanke, 50ns fallende Flanke
-    //Totzeit für Halbbrücke V
-    mcpwm_deadtime_enable(MCPWM_UNIT_0, MCPWM_TIMER_1, MCPWM_ACTIVE_HIGH_COMPLIMENT_MODE, 50, 50); 
     }
 /*############################################*/
 /*################## MISC ####################*/

main/include/functions.h

@@ -13,9 +13,8 @@
 #include "esp_adc/adc_cali_scheme.h"
 #include "ssd1306.h"
 #include "esp_adc/adc_oneshot.h"
+#include "hal/mcpwm_types.h"
 #include "driver/mcpwm_prelude.h"
-#include "soc/mcpwm_reg.h"
-#include "soc/mcpwm_struct.h"
 
 #define HIN_U_CH 0
 #define HIN_V_CH 1
@@ -44,7 +43,7 @@ void U_W_start(int duty);
 void W_U_start(int duty);
 void V_W_start(int duty);
 void W_V_start(int duty);
-void set_mcpwm();
+void conf_mcpwm_timers();
 void parse_3pins(const char *TAG, const char *pin_string, int *pins);
 SSD1306_t *configure_OLED(const char *TAG);
 

sdkconfig

@@ -1,6 +1,6 @@
 #
 # Automatically generated file. DO NOT EDIT.
-# Espressif IoT Development Framework (ESP-IDF) 5.3.0 Project Configuration
+# Espressif IoT Development Framework (ESP-IDF) 5.3.1 Project Configuration
 #
 CONFIG_SOC_BROWNOUT_RESET_SUPPORTED="Not determined"
 CONFIG_SOC_TWAI_BRP_DIV_SUPPORTED="Not determined"
@@ -174,7 +174,7 @@ CONFIG_SOC_TIMER_GROUP_TOTAL_TIMERS=4
 CONFIG_SOC_TIMER_GROUP_SUPPORT_APB=y
 CONFIG_SOC_TOUCH_SENSOR_VERSION=1
 CONFIG_SOC_TOUCH_SENSOR_NUM=10
-CONFIG_SOC_TOUCH_SAMPLER_NUM=1
+CONFIG_SOC_TOUCH_SAMPLE_CFG_NUM=1
 CONFIG_SOC_TWAI_CONTROLLER_NUM=1
 CONFIG_SOC_TWAI_BRP_MIN=2
 CONFIG_SOC_TWAI_CLK_SUPPORT_APB=y
@@ -239,7 +239,7 @@ CONFIG_IDF_TOOLCHAIN="gcc"
 CONFIG_IDF_TARGET_ARCH_XTENSA=y
 CONFIG_IDF_TARGET_ARCH="xtensa"
 CONFIG_IDF_TARGET="esp32"
-CONFIG_IDF_INIT_VERSION="5.3.0"
+CONFIG_IDF_INIT_VERSION="5.3.1"
 CONFIG_IDF_TARGET_ESP32=y
 CONFIG_IDF_FIRMWARE_CHIP_ID=0x0000
 
@@ -725,6 +725,14 @@ CONFIG_SPI_MASTER_ISR_IN_IRAM=y
 CONFIG_SPI_SLAVE_ISR_IN_IRAM=y
 # end of ESP-Driver:SPI Configurations
 
+#
+# ESP-Driver:Touch Sensor Configurations
+#
+# CONFIG_TOUCH_CTRL_FUNC_IN_IRAM is not set
+# CONFIG_TOUCH_ISR_IRAM_SAFE is not set
+# CONFIG_TOUCH_ENABLE_DEBUG_LOG is not set
+# end of ESP-Driver:Touch Sensor Configurations
+
 #
 # ESP-Driver:UART Configurations
 #