module_universal_io/fw/modules/io/input.c

#include "at32f403a_407.h"
#include "input.h"
#include "settings_api.h"
#include "FreeRTOS.h"
#include "task.h"
#include "mux.h"
#include "output.h"
#include <stdio.h>


// *port; pin; mode; port_source; pin_source; deb_counter; p_flag; cnt;
din_t inputs[DI_NUMBER] = {
    {GPIOB, GPIO_PINS_11, 0, 0, 0, false, false}, // 1   
    {GPIOB, GPIO_PINS_10, 0, 0, 0, false, false}, // 2
    {GPIOE, GPIO_PINS_14, 0, 0, 0, false, false}, // 3 перенесли {GPIOB, GPIO_PINS_1,  1, GPIO_PORT_SOURCE_GPIOB, GPIO_PINS_SOURCE1,  0},
    {GPIOE, GPIO_PINS_15, 0, 0, 0, false, false}, // 4 перенесли {GPIOB, GPIO_PINS_0,  1, GPIO_PORT_SOURCE_GPIOB, GPIO_PINS_SOURCE0,  0},
    {GPIOA, GPIO_PINS_3,  0, 0, 0, false, false}, // 5
    {GPIOA, GPIO_PINS_2,  0, 0, 0, false, false}, // 6
    {GPIOA, GPIO_PINS_1,  0, 0, 0, false, false}, // 7
    {GPIOA, GPIO_PINS_0,  0, 0, 0, false, false}  // 8
};


//
void in_init(din_t *input)
{
    gpio_init_type gpio_init_struct;

    gpio_default_para_init(&gpio_init_struct);
        
    gpio_init_struct.gpio_pull           = GPIO_PULL_NONE;  
    gpio_init_struct.gpio_mode           = GPIO_MODE_INPUT;  
    gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    gpio_init_struct.gpio_pins           = input->pin;
    gpio_init(input->port, &gpio_init_struct);

#if 0    
    // Вход
    if (input->mode == 0)
    {
        gpio_default_para_init(&gpio_init_struct);
        
        gpio_init_struct.gpio_pull           = GPIO_PULL_NONE;  
        gpio_init_struct.gpio_mode           = GPIO_MODE_INPUT;  
        gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
        gpio_init_struct.gpio_pins           = input->pin;
        gpio_init(input->port, &gpio_init_struct); 
    }
    // Счетный вход
    else if (input->mode == 1)
    {
    }
#endif
}

//
void in_exint_init(void)
{
    exint_init_type exint_init_struct;
    
    gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOB, GPIO_PINS_SOURCE11); // 11
    gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOB, GPIO_PINS_SOURCE10); // 10
    gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOE, GPIO_PINS_SOURCE14); // 14
    gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOE, GPIO_PINS_SOURCE15); // 15
    gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOA, GPIO_PINS_SOURCE3);  // 3
    gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOA, GPIO_PINS_SOURCE2);  // 2
    gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOA, GPIO_PINS_SOURCE1);  // 1
    gpio_exint_line_config(GPIO_PORT_SOURCE_GPIOA, GPIO_PINS_SOURCE0);  // 0
    
    exint_default_para_init(&exint_init_struct);
    
    exint_init_struct.line_enable = TRUE;
    exint_init_struct.line_mode = EXINT_LINE_INTERRUPUT;
    exint_init_struct.line_select = EXINT_LINE_0 | EXINT_LINE_1 | EXINT_LINE_2 |
                                    EXINT_LINE_3 | EXINT_LINE_10 | 
                                    EXINT_LINE_11| EXINT_LINE_14 | EXINT_LINE_15; 
    
    exint_init_struct.line_polarity = EXINT_TRIGGER_BOTH_EDGE;
    exint_init(&exint_init_struct);
    
    exint_flag_clear(EXINT_LINE_0);
    exint_flag_clear(EXINT_LINE_1);
    exint_flag_clear(EXINT_LINE_2);
    exint_flag_clear(EXINT_LINE_3);
    exint_flag_clear(EXINT_LINE_10);
    exint_flag_clear(EXINT_LINE_11);
    exint_flag_clear(EXINT_LINE_14);
    exint_flag_clear(EXINT_LINE_15);
    
    nvic_irq_enable(EXINT0_IRQn, 5, 0);
    nvic_irq_enable(EXINT1_IRQn, 5, 0);
    nvic_irq_enable(EXINT2_IRQn, 5, 0);
    nvic_irq_enable(EXINT3_IRQn, 5, 0);
    nvic_irq_enable(EXINT15_10_IRQn, 5, 0);
}

//
void in_set(void)
{
    for (int i = 0; i < DI_NUMBER; i++)
    {
        if ((settings.di_mode_bits & (1 << i)) != inputs[i].mode) 
        {
            inputs[i].mode = settings.di_mode_bits & (1 << i);
            if (inputs[i].mode == 0) 
            {
                inputs[i].cnt = 0;
                inputs[i].p_flag = false;
                input_cnt[i] = 0;
            }
            else
            {
                input_state_bit &= ~(1 << i);
            }
        }
    }
}

//
uint8_t in_get(uint8_t channel)
{
    uint8_t ret = 0;
    
    ret = (uint8_t)(input_state_bit >> channel & 1);
    
    return  ret;
}

//
void io_test(void)
{
#if 0  
    printf("IN_1: %u IN_2: %u IN_3: %u IN_4: %u IN_5: %u IN_6: %u IN_7: %u IN_8: %u\r\n", 
           gpio_input_data_bit_read(inputs[0].port, inputs[0].pin),
           gpio_input_data_bit_read(inputs[1].port, inputs[1].pin),
           gpio_input_data_bit_read(inputs[2].port, inputs[2].pin),
           gpio_input_data_bit_read(inputs[3].port, inputs[3].pin),
           gpio_input_data_bit_read(inputs[4].port, inputs[4].pin),
           gpio_input_data_bit_read(inputs[5].port, inputs[5].pin),
           gpio_input_data_bit_read(inputs[6].port, inputs[6].pin), 
           gpio_input_data_bit_read(inputs[7].port, inputs[7].pin));
#endif    
    
    printf("IN_1: %u IN_2: %u IN_3: %u IN_4: %u IN_5: %u IN_6: %u IN_7: %u IN_8: %u\r\n", 
           input_cnt[0], input_cnt[1], input_cnt[2], input_cnt[3], 
           input_cnt[4], input_cnt[5], input_cnt[6], input_cnt[7]);
    
}

// Периодический опрос входов
void input_task(void *params)
{
    for (;;)
    {
        
        for (int i = 0; i < DI_NUMBER; i++)
        {
            // Режим обычного входа
            if (inputs[i].mode == 0)
            {
                input_state[i] = (uint16_t)gpio_input_data_bit_read(inputs[i].port, inputs[i].pin);
                
                if (!input_state[i]) {
                    input_state_bit &= ~(1 << i); // снять бит
                    leds[i].state = LED_OFF;
                }
                else {
                    input_state_bit |= input_state[i] << i;
                    leds[i].state = LED_ON;
                }
            }
        }
        
       
        for (int i = 0; i < DO_NUMBER; i++)
        {                           
            load_state[i] = (uint16_t)gpio_input_data_bit_read(load_sens[i].port, load_sens[i].pin);
            
            // Текущее состояние датчиков нагрузки.
            if (!load_state[i]) {
                load_state_bit &= ~(1 << i);  // снять бит
            }
            else {
                load_state_bit |= 1 << i;
            }
            
            // Установка битов достоверности
            // Если 0 (выход разомкнут), то состояние достоверно и нужно 
            // выставить соответствующий бит
            if (!(output_state_bit & (1 << i))) {
                credibility_state_bit |= 1 << i;
            }
            else { 
                credibility_state_bit &= ~(1 << i);
            }  
        }
            
        vTaskDelay(100);
    }
}

//
void debounce(void)
{
    for (int i = 0; i < DI_NUMBER; i++)
    {
        if ((inputs[i].p_flag) && (inputs[i].mode == 0)){
            if (++inputs[i].cnt == settings.di_debounce[i]) {
                inputs[i].cnt = 0;
                inputs[i].p_flag = false;
                
                input_state[i] = (uint16_t)gpio_input_data_bit_read(inputs[i].port, inputs[i].pin);
                
                if (!input_state[i]) {
                    input_state_bit &= ~(1 << i); // снять бит
                    leds[i].state = LED_OFF;
                }
                else {
                    input_state_bit |= input_state[i] << i;
                    leds[i].state = LED_ON;
                }
            }
        }
    }
}

// IN_8 GPIOA_0
void EXINT0_IRQHandler(void)
{
    if (exint_flag_get(EXINT_LINE_0) != RESET) 
    {
        exint_flag_clear(EXINT_LINE_0);
        if (inputs[7].mode == 0)
            inputs[7].p_flag = true;
        else { 
            if (inputs[7].cnt_flag) {
                input_cnt[7]++;
                inputs[7].cnt_flag = false;
            }
            else
                inputs[7].cnt_flag = true;
        }
    }
}

// IN_7 GPIOA_1
void EXINT1_IRQHandler(void)
{
    if(exint_flag_get(EXINT_LINE_1) != RESET) 
    {
        exint_flag_clear(EXINT_LINE_1);
        if (inputs[6].mode == 0)
            inputs[6].p_flag = true;
        else { 
            if (inputs[6].cnt_flag) {
                input_cnt[6]++;
                inputs[6].cnt_flag = false;
            }
            else
                inputs[6].cnt_flag = true;
        }
    }
}

// IN_6 GPIOA_2
void EXINT2_IRQHandler(void)
{
    if(exint_flag_get(EXINT_LINE_2) != RESET) 
    {
        exint_flag_clear(EXINT_LINE_2);
        if (inputs[5].mode == 0)
            inputs[5].p_flag = true;
        else { 
            if (inputs[5].cnt_flag) {
                input_cnt[5]++;
                inputs[5].cnt_flag = false;
            }
            else
                inputs[5].cnt_flag = true;
        }
    }
}

// IN_5 GPIOA_3
void EXINT3_IRQHandler(void)
{
    if(exint_flag_get(EXINT_LINE_3) != RESET) 
    {
        exint_flag_clear(EXINT_LINE_3);
        if (inputs[4].mode == 0)
            inputs[4].p_flag = true;
        else { 
            if (inputs[4].cnt_flag) {
                input_cnt[4]++;
                inputs[4].cnt_flag = false;
            }
            else
                inputs[4].cnt_flag = true;
        }
    }
}

// IN_1, IN_2, IN_3, IN_4
void EXINT15_10_IRQHandler(void)
{
    // IN_2 GPIOB_10
    if (exint_flag_get(EXINT_LINE_10) != RESET)  
    {
        exint_flag_clear(EXINT_LINE_10);
        if (inputs[1].mode == 0)
            inputs[1].p_flag = true;
        else { 
            if (inputs[1].cnt_flag) {
                input_cnt[1]++;
                inputs[1].cnt_flag = false;
            }
            else
                inputs[1].cnt_flag = true;
        }
    }
    // IN_1 GPIOB_11
    else if (exint_flag_get(EXINT_LINE_11) != RESET)  
    {
        exint_flag_clear(EXINT_LINE_11);
        if (inputs[0].mode == 0)
            inputs[0].p_flag = true;
        else { 
            if (inputs[0].cnt_flag) {
                input_cnt[0]++;
                inputs[0].cnt_flag = false;
            }
            else
                inputs[0].cnt_flag = true;
        }
    }
    // IN_3 GPIOE_14
    else if (exint_flag_get(EXINT_LINE_14) != RESET)  
    {
        exint_flag_clear(EXINT_LINE_14);
        if (inputs[2].mode == 0)
            inputs[2].p_flag = true;
        else { 
            if (inputs[2].cnt_flag) {
                input_cnt[2]++;
                inputs[2].cnt_flag = false;
            }
            else
                inputs[2].cnt_flag = true;
        }
    }
    // IN_4 GPIOE_15
    else if (exint_flag_get(EXINT_LINE_15) != RESET) 
    {
        exint_flag_clear(EXINT_LINE_15);
        if (inputs[3].mode == 0)
            inputs[3].p_flag = true;
        else { 
            if (inputs[3].cnt_flag) {
                input_cnt[3]++;
                inputs[3].cnt_flag = false;
            }
            else
                inputs[3].cnt_flag = true;
        }
    }    
}