new aproach for deactivating generators, not finshed yet

main/GPIO.c

@@ -18,18 +18,14 @@ static volatile int64_t last_AB_time = 0;
 
 
 //internal Encoder
-static void IRAM_ATTR enc_in_a_isr_handler(void *arg);
-static void IRAM_ATTR enc_in_b_isr_handler(void *arg);
 static void IRAM_ATTR enc_in_isr_handler(void *arg);
 static void IRAM_ATTR enc_in_but_isr_handler(void *arg);
 
 static volatile int16_t enc_in_counter = 0;
-static volatile int64_t last_interrupt_time_a = 0; // Entprellungs-Timer
-static volatile int64_t last_interrupt_time_b = 0; // Entprellungs-Timer
 static volatile int64_t last_interrupt_time = 0;
 static volatile uint16_t last_interrupt_time_but = 0;
 static volatile bool enc_in_button_state = false;
-
+static volatile uint8_t last_state = 0;
 
 /*############################################*/
 /*############### GPIO-Setup #################*/
@@ -163,35 +159,7 @@ int get_direction(){//-1=Error,0=right,1=left
 /*############################################*/
 /*############ Internal Encoder ##############*/
 /*############################################*/
-static void IRAM_ATTR enc_in_a_isr_handler(void *arg) {
-    uint64_t interrupt_time = esp_timer_get_time();
-    
-    // Entprellung: Verhindert die Erfassung von Störungen aufgrund von Prellung
-    if (interrupt_time - last_interrupt_time_a > (CONFIG_IN_ENCODER_DEBOUNCE_TIME)) {  //  Entprellungszeit
-        last_interrupt_time_a = interrupt_time; // Entprellzeit zurücksetzen
-        // Bestimmen der Richtung anhand des Zustands von Pin A und B
-        if (gpio_get_level(CONFIG_IN_ENC_A_GPIO)==gpio_get_level(CONFIG_IN_ENC_B_GPIO)) {
-            enc_in_counter++; // Drehung nach links
-        }
-        
-    }
-}
 
-static void IRAM_ATTR enc_in_b_isr_handler(void *arg) {
-   uint64_t interrupt_time = esp_timer_get_time();
-    
-    // Entprellung: Verhindert die Erfassung von Störungen aufgrund von Prellung
-    if (interrupt_time - last_interrupt_time_b > (CONFIG_IN_ENCODER_DEBOUNCE_TIME)) {  //  Entprellungszeit
-        last_interrupt_time_b = interrupt_time; // Entprellzeit zurücksetzen
-        // Bestimmen der Richtung anhand des Zustands von Pin A und B
-        if (gpio_get_level(CONFIG_IN_ENC_A_GPIO)==gpio_get_level(CONFIG_IN_ENC_B_GPIO)) {
-            enc_in_counter--;
-        }
-
-    }
-}
-
-static volatile uint8_t last_state = 0;
 
 static void IRAM_ATTR enc_in_isr_handler(void *arg) {
     static uint64_t last_interrupt_time = 0;
@@ -206,10 +174,10 @@ static void IRAM_ATTR enc_in_isr_handler(void *arg) {
         if ((interrupt_time - last_interrupt_time) > CONFIG_IN_ENCODER_DEBOUNCE_TIME) {
             if ((last_state == 0b01 && current_state == 0b11) || 
                 (last_state == 0b10 && current_state == 0b00)) {
-                enc_in_counter++;  // Vorwärtsdrehen
+                enc_in_counter--;  // Vorwärtsdrehen
             } else if ((last_state == 0b10 && current_state == 0b11) || 
                        (last_state == 0b01 && current_state == 0b00)) {
-                enc_in_counter--;  // Rückwärtsdrehen
+                enc_in_counter++;  // Rückwärtsdrehen
             }
             last_state = current_state;  // Zustand aktualisieren
             last_interrupt_time = interrupt_time;

main/app_main.c

@@ -48,11 +48,12 @@ void app_main(void)
     configure_GPIO_dir();
     SSD1306_t *dev_pt = configure_OLED();
     mcpwm_init();
-    set_mcpwm_output(PHASE_U,PHASE_V);
+    set_mcpwm_output(PHASE_U, PHASE_V, PHASE_W);
     set_enc_in_counter(menu_counter);
     mcpwm_freq = 40000;
     set_mcpwm_duty(duty);
-    set_mcpwm_frequenzy(mcpwm_freq);
+    set_mcpwm_frequency(mcpwm_freq);
+    set_mcpwm_output(PHASE_U, PHASE_W, PHASE_V);
     
     //gpio_set_level(CONFIG_HIN_V_GPIO, 1);
     while (1) {

main/include/mcpwm.h

@@ -9,9 +9,9 @@ typedef enum {
 } Phase;
 
 void mcpwm_init();
-esp_err_t set_mcpwm_output(Phase highside, Phase lowside);
+esp_err_t set_mcpwm_output(Phase highside, Phase lowside, Phase inactive);
 esp_err_t set_mcpwm_duty(float duty);
-esp_err_t set_mcpwm_frequenzy(uint16_t frequenzy);
+esp_err_t set_mcpwm_frequency(uint16_t frequency);
 void get_comps(mcpwm_cmpr_handle_t comps[3]);
 float get_duty();
 #endif

main/mcpwm.c

@@ -27,6 +27,8 @@ static mcpwm_gen_handle_t generator_W_LIN = NULL;
 
 static Phase HighsidePhase;
 static Phase LowsidePhase;
+static Phase InactivePhase;
+
 uint32_t periode_ticks = CONFIG_TIMER_BASE_FREQ/CONFIG_FREQ_PWM;
 float duty = CONFIG_DUTY_PWM;
 /*############################################*/
@@ -47,6 +49,9 @@ void mcpwm_init(){
         .resolution_hz = CONFIG_TIMER_BASE_FREQ, //40MHz
         .period_ticks = periode_ticks,      //40MHz/2KHz = 20KHz
         .count_mode = MCPWM_TIMER_COUNT_MODE_UP_DOWN,
+        .flags ={
+            .update_period_on_empty = 1,
+        }
     };
     ESP_ERROR_CHECK(mcpwm_new_timer(&timer_config, &timer_U));
     ESP_ERROR_CHECK(mcpwm_new_timer(&timer_config, &timer_V));
@@ -177,6 +182,8 @@ static void set_gen(Phase phase){
     switch (phase) {
 
         case PHASE_U:
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_U_HIN, -1,true));
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_U_LIN, -1,true));
         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_compare_event(generator_U_HIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, comperator_U, 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)));
@@ -186,6 +193,8 @@ static void set_gen(Phase phase){
             break;
 
         case PHASE_V:
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_V_HIN, -1,true));
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_V_LIN, -1,true));
         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_compare_event(generator_V_HIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, comperator_V, 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)));
@@ -195,6 +204,8 @@ static void set_gen(Phase phase){
             break;
 
         case PHASE_W:
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_W_HIN, -1,true));
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_W_LIN, -1,true));
         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_compare_event(generator_W_HIN, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_DOWN, comperator_W, 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)));
@@ -243,12 +254,32 @@ static void set_highside(Phase highside){
             break;
     }
 }
+static void set_inactive(Phase inactive){
+    InactivePhase = inactive;
+    switch (inactive){
+        case PHASE_U:
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_U_HIN, 0,true));
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_U_LIN, 1,true));
+        break;
+        case PHASE_V:
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_V_HIN, 0,true));
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_V_LIN, 1,true));
+        break;
+        case PHASE_W:
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_W_HIN, 0,true));
+        ESP_ERROR_CHECK(mcpwm_generator_set_force_level(generator_W_LIN, 1,true));
+        break;
 
-
+        default:
-esp_err_t set_mcpwm_output(Phase highside, Phase lowside){
+            printf("Invalid phase selection\n");
+            break;
+    }
+}
+esp_err_t set_mcpwm_output(Phase highside, Phase lowside, Phase inactive){
     if (timer_U == NULL) {
         return ESP_ERR_INVALID_STATE; // Fehlerbehandlung, wenn mcpwm nicht initialisiert wurde
     }
+    set_inactive(inactive);
     set_highside(highside);
     set_gen(highside);
     set_lowside(lowside);
@@ -265,20 +296,14 @@ esp_err_t set_mcpwm_duty(float new_duty){
     return ESP_OK;
 }
 
-esp_err_t set_mcpwm_frequenzy(uint16_t frequency){
+esp_err_t set_mcpwm_frequency(uint16_t frequency){
 
     if (timer_U == NULL) {
         return ESP_ERR_INVALID_STATE; // Fehlerbehandlung, wenn mcpwm nicht initialisiert wurde
     }
     periode_ticks = CONFIG_TIMER_BASE_FREQ/frequency;
 
-    // Timer stoppen, wenn er läuft
-    ESP_ERROR_CHECK(mcpwm_timer_disable(timer_U));
-    ESP_ERROR_CHECK(mcpwm_timer_disable(timer_V));
-    ESP_ERROR_CHECK(mcpwm_timer_disable(timer_W));
-
     // Neue Konfiguration anwenden
-    
     ESP_ERROR_CHECK(mcpwm_timer_set_period(timer_U, periode_ticks));
     ESP_ERROR_CHECK(mcpwm_timer_set_period(timer_V, periode_ticks));
     ESP_ERROR_CHECK(mcpwm_timer_set_period(timer_W, periode_ticks));
@@ -286,11 +311,6 @@ esp_err_t set_mcpwm_frequenzy(uint16_t frequency){
     // dutycycle an neue Frequenz anpassen
     set_mcpwm_duty(duty);
 
-    // Timer wieder starten
-    ESP_ERROR_CHECK(mcpwm_timer_enable(timer_U));
-    ESP_ERROR_CHECK(mcpwm_timer_enable(timer_V));
-    ESP_ERROR_CHECK(mcpwm_timer_enable(timer_W));
-
     return ESP_OK;
 }