module_universal_io/fw/modules/io/digital_output.c

#include "at32f403a_407.h"
#include "digital_output.h"
#include "FreeRTOS.h"
#include "task.h"
#include "settings_api.h"
#include "io_utils.h"
#include "mux.h"
#include <stdio.h>

#if defined (MDIO_88)

uint16_t output_state_bit;
uint16_t output_state_save_bit;
uint16_t output_value_bit;
uint16_t output_value_save_bit;
uint16_t output_mode_bit;
uint16_t output_mode_save_bit;
uint16_t output_pwm[DO_NUMBER];
uint16_t output_pwm_save[DO_NUMBER];
uint16_t output_pwm_period[DO_NUMBER];
uint16_t output_pwm_period_save[DO_NUMBER];


out_t outputs[DO_NUMBER] = {
    {GPIOC, GPIO_PINS_12, 0, 0, 0, false, 0, 0},   // -
    {GPIOD, GPIO_PINS_2,  0, 0, 0, false, 0, 0},   // -
    {GPIOE, GPIO_PINS_6,  0, 0, 0, false, 0, 0},   // TMR9_CH2 (remap)
    {GPIOC, GPIO_PINS_1,  0, 0, 0, false, 0, 0},   // -
    {GPIOC, GPIO_PINS_11, 0, 0, 0, false, 0, 0},   // -
    {GPIOD, GPIO_PINS_3,  0, 0, 0, false, 0, 0},   // -
    {GPIOE, GPIO_PINS_5,  0, 0, 0, false, 0, 0},   // TMR9_CH1 (remap)
    {GPIOC, GPIO_PINS_2,  0, 0, 0, false, 0, 0}    // -
};


//
void do_init(void)
{
    // Таймер для выходов в режиме PWM
    di_out_pwm_tim_init();
    
    // Актуализация битовых полей (используюся для управления по modbus)
    
    // Состояние выходов вкл/выкл.
    do_update_field(&settings.dout[0].state, &output_state_bit);
    do_update_field(&settings.dout_save[0].state, &output_state_save_bit);
    
    // Режим работы выходов
    do_update_field(&settings.dout[0].mode, &output_mode_bit);
    do_update_field(&settings.dout_save[0].mode, &output_mode_save_bit);
    
    // Значение на выходах
    do_update_field(&settings.dout[0].value, &output_value_bit);
    do_update_field(&settings.dout_save[0].value, &output_value_save_bit);
    
    // Установить режим работы и состояние на всех выходах
    for (int i = 0; i < DO_NUMBER; i++)
    {
        do_gpio_init(&outputs[i], i);

        // Актуализация параметров PWM для modbus
        output_pwm[i] = settings.dout[i].pwm_duty;
        output_pwm_period[i] = settings.dout[i].pwm_period;
        
        output_pwm_save[i] = settings.dout_save[i].pwm_duty;
        output_pwm_period_save[i] = settings.dout_save[i].pwm_period;
         
        // Установка заданного режима и состояния выхода
        if (!save_mode_get())
            do_update(&settings.dout[i], i) ;
    }
}


// Заполняет битовые поля по значения в массивах
void do_update_field(uint8_t *param, uint16_t *field)
{
    for (int i = 0; i < DO_NUMBER; i++)
    {
        if (*param)
            *field |= 1 << i;
        else 
            *field &= ~(1 << i);
        
        param += sizeof(do_t);
    }  
}


// Настройка GPIO выходов
void do_gpio_init(out_t *out, uint8_t index)
{
    gpio_init_type gpio_init_struct;
    
    gpio_default_para_init(&gpio_init_struct);
    
    gpio_init_struct.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;  
    gpio_init_struct.gpio_pull           = GPIO_PULL_NONE;  
    gpio_init_struct.gpio_mode           = GPIO_MODE_OUTPUT;  
    gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    gpio_init_struct.gpio_pins           = out->pin;
    gpio_init(out->port, &gpio_init_struct); 
}




//
void do_set_common(void)
{
    bool flag = false;
    
    for (int i = 0; i < DO_NUMBER; i++)
    {
        // Изменилось состояние выходов
        if (settings.dout[i].state != (output_state_bit & (1 << i))) {
            settings.dout[i].state = (output_state_bit >> i) & 1;
        }
      
        // Изменилось значение на выходе
        if (settings.dout[i].value != (output_value_bit & (1 << i))) {
            settings.dout[i].value = (output_value_bit >> i) & 1;
            flag = true;
        }
        
        // Изменился режим работы
        if (settings.dout[i].mode != (output_mode_bit & (1 << i))) {
            settings.dout[i].mode = (output_mode_bit >> i) & 1;
            flag = true;
        }
                
        // Изменилось заполнение PWM
        if (settings.dout[i].pwm_duty != output_pwm[i]) {
            settings.dout[i].pwm_duty = output_pwm[i];
            flag = true;
        }
        
        // Изменился период PWM
        if (settings.dout[i].pwm_period != output_pwm_period[i]) {
            settings.dout[i].pwm_period = output_pwm_period[i];
            flag = true;
        }
        
        // Значение на выходе в безопасном режиме. Обновляем значения в настройках.
        settings.dout_save[i].value = (output_value_save_bit >> i) & 1;
        
        // Режим работы в безопасном режиме. Обновляем значения в настройках.
        settings.dout_save[i].mode = (output_mode_save_bit >> i) & 1;
        
        // Состояние выходов в безопасном режиме. Обновляем значения в настройках.
        settings.dout_save[i].state = (output_state_save_bit >> i) & 1;

        // Заполнение PWM в безопасном режие. Обновляем значение в настройках.
        settings.dout_save[i].pwm_duty = output_pwm_save[i];
        
        // Период PWM в безопасном режие. Обновляем значение в настройках.
        settings.dout_save[i].pwm_period = output_pwm_period_save[i];
        
        if (flag)
            do_update(&settings.dout[i], i);
    }
}


// Установка режима и значения на выходе
void do_update(do_t *out, uint8_t i)
{
    // Если выход выключен - ничего не меняем
    if (!out->state)
        return;
  
    uint8_t led_index = 0;
  
    // Режим ШИМ
    if (out->mode) {
        do_set_pwm(out->pwm_period, out->pwm_duty, i);
    }
    // Режим обычного выхода
    else {
        outputs[i].mode = 0;
        do_set_out(&outputs[i], out->value);
        
        if (i < 4)
            led_index = i + 8;
        else
            led_index = i - 4 + 24;
          
        if (out->value == 1)
            leds[led_index].state = LED_ON;
        else
            leds[led_index].state = LED_OFF;
    }
}


//
void do_set_pwm(uint16_t period, uint16_t duty, uint8_t index)
{
    uint16_t duty_calc;
  
    if (duty == 0)
        duty_calc = 0;
    else
        duty_calc = (duty*period/100 < 1) ? 1 : duty*period/100;
    
    outputs[index].pwm_flag = false;
    outputs[index].pwm_period_cnt = 0;
    outputs[index].pwm_duty_cnt = 0;
    outputs[index].pwm_period = period;
    outputs[index].pwm_duty = duty_calc;
    outputs[index].mode = 1;
}


// Дергает пином.
void do_set_out(out_t *out, uint8_t val)
{
    if (val) {
        gpio_bits_set(out->port, out->pin);
    }    
    else {
        gpio_bits_reset(out->port, out->pin);
    }
}


//
void out_as_pwm(void)
{
    uint32_t timer_period;
    uint16_t pwm_pulse;
    crm_clocks_freq_type crm_clocks_freq_struct = {0};
    tmr_output_config_type tmr_output_struct;
    
    crm_periph_clock_enable(CRM_TMR9_PERIPH_CLOCK, TRUE);
    
    crm_clocks_freq_get(&crm_clocks_freq_struct);
    
    //timer_period = (crm_clocks_freq_struct.sclk_freq / 10 ) - 1;
    
    timer_period = 24000 - 1;
    pwm_pulse = 125*timer_period/1000;
    
    tmr_base_init(TMR9, 24000 - 1, 1000 - 1);
    tmr_cnt_dir_set(TMR9, TMR_COUNT_UP);

    tmr_output_default_para_init(&tmr_output_struct);
    tmr_output_struct.oc_mode = TMR_OUTPUT_CONTROL_PWM_MODE_A;
    tmr_output_struct.oc_output_state = TRUE;
    tmr_output_struct.oc_polarity = TMR_OUTPUT_ACTIVE_HIGH;
    tmr_output_struct.oc_idle_state = TRUE;
    
    tmr_output_channel_config(TMR9, TMR_SELECT_CHANNEL_1, &tmr_output_struct);
    tmr_channel_value_set(TMR9, TMR_SELECT_CHANNEL_1, pwm_pulse);
    
    tmr_flag_clear(TMR9, TMR_OVF_FLAG);
    nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
    nvic_irq_enable(TMR1_BRK_TMR9_IRQn, 5, 0);
    
    //tmr_interrupt_enable(TMR9, TMR_OVF_INT, TRUE);
    tmr_interrupt_enable(TMR9, TMR_C1_INT, TRUE);
    
    tmr_counter_enable(TMR9, TRUE);
}


// Периодический контроль перехода в безопасный режим
void do_task(void *params)
{
    static bool update_flag = false;
    
    for (;;)
    {
        if (save_mode_get() && !update_flag)
        {
            for (int i = 0; i < DO_NUMBER; i++) 
            {
                do_update(&settings.dout_save[i], i) ;
                
                output_pwm[i] = output_pwm_save[i];
                output_pwm_period[i] = output_pwm_period_save[i];
            }
            
            do_update_field(&settings.dout_save[0].state, &output_state_bit);
            do_update_field(&settings.dout_save[0].mode, &output_mode_bit);
            do_update_field(&settings.dout_save[0].value, &output_value_bit);
            
            update_flag = true;
        }
        
        if (!save_mode_get())
            update_flag = false;

          
        vTaskDelay(100);
    }
}
      


// -------------------------------------------------------------------------- //
//                              PWM

// Таймер для выходов в режиме PWM. Частота 10Гц.
void di_out_pwm_tim_init(void)
{
    uint16_t prescaler_value = 0;
    uint16_t timer_period = 1000 - 1;
    gpio_init_type gpio_init_struct;
    
    gpio_default_para_init(&gpio_init_struct);
        
    gpio_init_struct.gpio_pins = GPIO_PINS_15;
    gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
    gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
    gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    gpio_init(GPIOB, &gpio_init_struct);

    crm_periph_clock_enable(CRM_TMR9_PERIPH_CLOCK, TRUE);
    
    prescaler_value = (uint16_t)(system_core_clock / 10000) - 1;
    tmr_base_init(TMR9, timer_period, prescaler_value);
    
    tmr_cnt_dir_set(TMR9, TMR_COUNT_UP);
    tmr_clock_source_div_set(TMR9, TMR_CLOCK_DIV1);
    
    nvic_irq_enable(TMR1_BRK_TMR9_IRQn, 5, 0);

    tmr_interrupt_enable(TMR9, TMR_OVF_INT, TRUE);
    
    tmr_counter_enable(TMR9, TRUE);
}


// Реализация программного PWM для цифровых выходов
inline void pwm_proc(void)
{
    for (int i = 0; i < DO_NUMBER; i++)
    {
        if (outputs[i].mode)    // режим PWM
        {
            if (outputs[i].pwm_period_cnt == outputs[i].pwm_period /*PWM_PERIOD_TEST*/) {
                outputs[i].pwm_period_cnt = 0;
            }
            if (outputs[i].pwm_period_cnt == 0) {
                outputs[i].pwm_flag = false;
                gpio_bits_set(outputs[i].port, outputs[i].pin);
                //gpio_bits_set(GPIOB, GPIO_PINS_15);
            }
            if (outputs[i].pwm_duty_cnt == outputs[i].pwm_duty /*PWM_DUTY_TEST*/) {
                outputs[i].pwm_duty_cnt = 0;
                gpio_bits_reset(outputs[i].port, outputs[i].pin);
                //gpio_bits_reset(GPIOB, GPIO_PINS_15);
                outputs[i].pwm_flag = true;
            }
            outputs[i].pwm_period_cnt++;
            if (outputs[i].pwm_flag == false) {
                outputs[i].pwm_duty_cnt++;
            }
        }
    }
}

// Реализация программного PWM для цифровых выходов
void TMR1_BRK_TMR9_IRQHandler(void)
{
    if(tmr_flag_get(TMR9, TMR_OVF_FLAG) != RESET)
    {
        tmr_flag_clear(TMR9, TMR_OVF_FLAG);
        //GPIOB->odt ^= GPIO_PINS_15;
        pwm_proc();
    }
}

#endif