module_universal_io/fw/modules/io/analog_input.c

#include "at32f403a_407.h"
#include "analog_input.h"
#include "shift_reg.h"
#include "utility.h"
#include "FreeRTOS.h"
#include "task.h"
#include "settings_api.h"
#include "adc_transport.h"
#include "ms5192t.h"
#include "monitoring.h"
#include "mux.h"
#include <stdio.h>

#undef DBG
#define DBG if(1)

#if defined (MAI_12)  

//uint16_t ai_state_bit;

uint8_t ai_mux;     // выход сдвигового регистра U1010 (управляет MUX 301, 401)
                    // мультиплексоры отвечат за коммутацию аналоговых входов и АЦП

uint16_t ai_mode;   // режим измерения аналоговых каналов (ток или напряжение)
                    // 0000 0000 0000 0000 
                    // младшие 6 (с 1..6) бит - каналы с 1 по 6 соответственно
                    // биты 9..14 - каналы с 7 по 12 соответственно

uint16_t ai_alarm;  // слово аварий входов

uint16_t ai_gain[AI_COMMON_NUMBER]; // массив коэффициентов усиленя (modbus)

#if 0
ANALOG_IN_t channel_name[NUMBER_ADC_CH] = {AN_INP_1, AN_INP_2, AN_INP_3, 
                                           AN_INP_4, AN_INP_5, AN_INP_6,
                                           V_ISO_CL, V_ISO, 
                                           AN_INP_7, AN_INP_8, AN_INP_9,
                                           AN_INP_10, AN_INP_11, AN_INP_12,
                                           CRNT_LIM_U_BFR_R, CRNT_LIM_U_ABFR_R};
#endif


uint16_t adc_raw_data[AI_ALL_NUMBER];


led_t ai_alarm_led[12] = {IO_1_R, IO_2_R, IO_3_R, IO_4_R, 
                          IO_5_R, IO_6_R, IO_7_R, IO_8_R, 
                          IO_9_R, IO_10_R, IO_11_R, IO_12_R};

led_t ai_input_led[12] = {IO_1_G, IO_2_G, IO_3_G, IO_4_G, 
                          IO_5_G, IO_6_G, IO_7_G, IO_8_G, 
                          IO_9_G, IO_10_G, IO_11_G, IO_12_G};

uint16_t ai_state_bit;  // состояние аналоговых входов (вкл/выкл) битовое поле




//
void ai_init(void)
{
    // Зеленые LED сигнализируют (вкл/выкл) входов.
    ai_led_update();    
    
    // Сдвиговые регистры
    sh_init();          
    
    // Режим измерения
    ai_set_meas_mode();
    
    // Питание внешних датчиков
    ai_ext_sens_power(settings.ext_sens_power); 
    
    // Внешинй ADC
    ai_adc_init();
    
    // Modbus параметры
    ai_init_modbus_params();
}

//
void ai_init_modbus_params(void)
{
    for (uint8_t i = 0; i < AI_COMMON_NUMBER/2; i++)
    {
        ai_gain[i] = settings.ai[i].gain_factor;
        ai_gain[i + 6] = settings.ai[i + 8].gain_factor;
    }

#if 0
    // для теста
    for (uint8_t i = 0; i < AI_COMMON_NUMBER; i++)
    {
        ai_gain[i] = i + 10;
    }
#endif    
}   

// Управление LED для 12-и основных входов
void ai_led_update(void)
{
    for (int i = 0; i < AI_COMMON_NUMBER; i++) 
    {
        if (settings.ai[i].state) {
            leds[ai_input_led[i]].state = LED_ON;
        }
        else {
            leds[ai_input_led[i]].state = LED_OFF;
        }
    }
}

// Установить режим измерения каналов с 1 по 12.
void ai_set_meas_mode(void)
{
#if 0  
    for (uint8_t i = 1; i < 13; i++)
    {
        if (settings.ai_mode_bits & (1 << (i - 1)))
            ai_set_mode_word((MEAS_CHAN_MODE_t)1, i);
        else
            ai_set_mode_word((MEAS_CHAN_MODE_t)0, i);
    }
#endif
    for (int i = 0; i < AI_COMMON_NUMBER; i++)
    {
        if (settings.ai[i].mode)
            ai_set_mode_word((MEAS_CHAN_MODE_t)1, i);
    }
}   

// Настройка внешнего ADC
bool ai_adc_init(void)
{
    uint8_t ret;
    unsigned long value;
    
    adc_gpio_init();
    
    for (uint32_t i = 0; i < 100; i++) {
        MS5192T_Reset();
        ret = MS5192T_Init();
        DBG printf("ADC init status: %s\r\n", ret == 1 ? "OK" : "FAILED");
        if (ret == 1)
           break;
        vTaskDelay(10);
    }
        
    if (!ret) {
        mon_set_err(ERR_WORD_1, ADC_ERR, true);
        return false;
    }
    
    // Запрос регистра конфигурации для (0x710 - значение по умолчанию)
    value = MS5192T_GetRegisterValue(MS5192T_REG_CONF, 2, 1);
    DBG printf("ADC cfg reg: 0x%X: ", value);
    DBG print_binary_half_word((uint16_t)value);
    
    // Коэф-т усиления: 1
    DBG printf("ADC. Set gain rate 1\r\n");
    MS5192T_SetGain(MS5192T_GAIN_1);
    value = MS5192T_GetRegisterValue(MS5192T_REG_CONF, 2, 1);
    DBG printf("ADC cfg reg: 0x%X: ", value);
    DBG print_binary_half_word((uint16_t)value);
    
    // Униполярный режим
    DBG printf("Set unipolar input mode...\r\n");
    MS5192T_SetPolar(MS5192T_CONF_UNIPOLAR);
    value = MS5192T_GetRegisterValue(MS5192T_REG_CONF, 2, 1);
    DBG printf("ADC cfg reg: 0x%X: ", value);
    DBG print_binary_half_word((uint16_t)value);
    
    // Регистр статуса
    value = MS5192T_GetRegisterValue(MS5192T_REG_STAT, 1, 1);
    DBG printf("ADC status reg: 0x%X: ", value);
    DBG print_binary_byte((uint8_t)value);
    
    // Установка внутреннего опорного напряжения
    MS5192T_SetIntReference(MS5192T_REFSEL_INT); // select internal 1.17V reference
    value = MS5192T_GetRegisterValue(MS5192T_REG_CONF, 2, 1);
    DBG printf("ADC cfg reg: 0x%X: ", value);
    DBG print_binary_half_word((uint16_t)value);
    
    // Регистр режима (MODE register)
    value = MS5192T_GetRegisterValue(MS5192T_REG_MODE, 2, 1);
    DBG printf("ADC mode reg: 0x%X: ", value);
    DBG print_binary_half_word((uint16_t)value);
    
    // Установить update rate
    DBG printf("Set update rate.\r\n");
    MS5192T_SetUpdateRate(MS5192T_UP_RATE_500);
    value = MS5192T_GetRegisterValue(MS5192T_REG_MODE, 2, 1);
    DBG printf("ADC mode reg: 0x%X: ", value);
    DBG print_binary_half_word((uint16_t)value);
    
    // Калибровка 
    
    // 1 - ый канал
    MS5192T_Calibrate(MS5192T_MODE_CAL_INT_ZERO, MS5192T_CH_AIN1P_AIN1M); 
    MS5192T_Calibrate(MS5192T_MODE_CAL_INT_FULL, MS5192T_CH_AIN1P_AIN1M); 
    
    // 2 - ой канал
    MS5192T_Calibrate(MS5192T_MODE_CAL_INT_ZERO, MS5192T_CH_AIN2P_AIN2M); 
    MS5192T_Calibrate(MS5192T_MODE_CAL_INT_FULL, MS5192T_CH_AIN2P_AIN2M); 
          
    return true;
}  

// Оцифровка всех 16-и каналов (входы + дополнительные каналы)
void ai_processing(void)
{
    // все 16 каналов
    for (uint8_t i = 0; i < 8; i++)
    {
        adc_meas_two_channels(settings.ai[i], settings.ai[i + 8], i);
    }
    
#if 0    
    printf("end\r\n");
    adc_print_data();
    printf("end\r\n");  
#endif
}

//
void adc_meas_two_channels(ai_t one, ai_t two, uint8_t data_index)
{
    // 1 - ый канал
    if (one.state == 0) {
        DBG printf("[one] channel name: %u off, data_index: %u\r\n", one.name, data_index);
    }
    else {
        DBG printf("[one] channel name: %u on, data_index: %u\r\n", one.name, data_index);
        
        ai_connect_channel(one.name);
        vTaskDelay(1);
        MS5192T_SetChannel(MS5192T_CH_AIN1P_AIN1M);
        adc_raw_data[data_index] = MS5192T_SingleConversion();
    }            
        
    // 2 - ой канал
    if (two.state == 0) {
        DBG printf("[two] channel name: %u off, data_index: %u\r\n", two.name, data_index + 8);
    }
    else {
        DBG printf("[two] channel name: %u on, data_index: %u\r\n", two.name, data_index + 8);
        
        ai_connect_channel(two.name);
        vTaskDelay(1);
        MS5192T_SetChannel(MS5192T_CH_AIN2P_AIN2M);
        adc_raw_data[data_index + 8] = MS5192T_SingleConversion();
    }
}

//
void adc_print_data(void)
{
    printf("\033[2J"); // Очистить
    printf("\033[H");  // Переместить курсор в левый верхний угол
    printf("AN_INP_1: 0x%X, %f\r\n", adc_raw_data[0],  (double) adc_raw_data[0]*0.00001785305/0.0961538);
    printf("AN_INP_2: 0x%X, %f\r\n", adc_raw_data[1],  (double) adc_raw_data[1]*0.00001785305/0.0961538);
    printf("AN_INP_3: 0x%X, %f\r\n", adc_raw_data[2],  (double) adc_raw_data[2]*0.00001785305/0.0961538);
    printf("AN_INP_4: 0x%X, %f\r\n", adc_raw_data[3],  (double) adc_raw_data[3]*0.00001785305/0.0961538);
    printf("AN_INP_5: 0x%X, %f\r\n", adc_raw_data[4],  (double) adc_raw_data[4]*0.00001785305/0.0961538);
    printf("AN_INP_6: 0x%X, %f\r\n", adc_raw_data[5],  (double) adc_raw_data[5]*0.00001785305/0.0961538);
    printf("AN_INP_7: 0x%X, %f\r\n", adc_raw_data[6],  (double) adc_raw_data[6]*0.00001785305/0.0961538);
    printf("AN_INP_8: 0x%X, %f\r\n", adc_raw_data[7],  (double) adc_raw_data[7]*0.00001785305/0.0961538);
    printf("AN_INP_9: 0x%X, %f\r\n", adc_raw_data[8],  (double) adc_raw_data[8]*0.00001785305/0.0961538);
    printf("AN_INP_10: 0x%X, %f\r\n", adc_raw_data[9], (double) adc_raw_data[9]*0.00001785305/0.0961538);
    printf("AN_INP_11: 0x%X, %f\r\n", adc_raw_data[10],(double) adc_raw_data[10]*0.00001785305/0.0961538);
    printf("AN_INP_12: 0x%X, %f\r\n", adc_raw_data[11],(double) adc_raw_data[11]*0.00001785305/0.0961538);
    printf("V_ISO_CL: 0x%X, %f\r\n", adc_raw_data[12], (double) adc_raw_data[12]*0.00001785305/0.0961538);
    printf("V_ISO: 0x%X, %f\r\n", adc_raw_data[13],    (double) adc_raw_data[13]*0.00001785305/0.0961538);
    printf("CRNT_LIM_U_BFR_R: 0x%X, %f\r\n", adc_raw_data[14], (double) adc_raw_data[14]*0.00001785305/0.0961538);
    printf("CRNT_LIM_U_ABFR_R: 0x%X, %f\r\n", adc_raw_data[15], (double) adc_raw_data[15]*0.00001785305/0.0961538);
}

// 
void adc_task(void *params)
{
    for (;;)
    {
        ai_alarm = sh_ai_mode(ai_mode);
        
        //ai_processing();
        
        ai_leds_processing();
        
        //vTaskDelay(10);
    }
}

// Подключить канал к АЦП
// Одновременно могут быть подключены только 2 канала из наборов:
// 1: AN_INP_1, AN_INP_2, AN_INP_3, AN_INP_4, AN_INP_5, AN_INP_6, V_ISO_CL, 
//    V_ISO
//
// 2: AN_INP_7, AN_INP_8, AN_INP_9, AN_INP_10, AN_INP_11, AN_INP_12, 
//    CRNT_LIM_U_BFR_R, CRNT_LIM_U_ABFR_R
void ai_connect_channel(uint8_t channel)
{
    if (channel < MUX_401_CH) 
    {
        ai_mux &= 0xF0;
    
        switch (channel)
        {
            case AN_INP_1: ai_mux |= 0x03; break; // U301 Y3
            case AN_INP_2: ai_mux |= 0x00; break; // U301 Y0
            case AN_INP_3: ai_mux |= 0x05; break; // U301 Y5
            case AN_INP_4: ai_mux |= 0x07; break; // U301 Y7
            case AN_INP_5: ai_mux |= 0x06; break; // U301 Y6
            case AN_INP_6: ai_mux |= 0x04; break; // U301 Y4
            case V_ISO_CL: ai_mux |= 0x01; break; // U301 Y1
            case V_ISO   : ai_mux |= 0x02; break; // U301 Y2
            default: break;
        }
    }
    else
    {
        ai_mux &= 0x87;
        
        switch (channel)
        {
            case AN_INP_7: ai_mux |= (0x04 << 4); break; // U401 Y4
            case AN_INP_8: ai_mux |= (0x06 << 4); break; // U401 Y6
            case AN_INP_9: ai_mux |= (0x07 << 4); break; // U401 Y7
            case AN_INP_10:ai_mux |= (0x05 << 4); break; // U401 Y5
            case AN_INP_11:ai_mux |= (0x02 << 4); break; // U401 Y2
            case AN_INP_12:ai_mux |= (0x01 << 4); break; // U401 Y1
            case CRNT_LIM_U_BFR_R: ai_mux  |= (0x00 << 4); break; // U401 Y0
            case CRNT_LIM_U_ABFR_R: ai_mux |= (0x03 << 4); break; // U401 Y3
            default: break;
        }
    }
    
    sh_ai_connect(ai_mux);
    
    //printf("Analog input connect register: ");
    //print_binary_byte(ai_mux);
}

// 
void ai_set(void)
{
    for (int i = 0; i < AI_COMMON_NUMBER; i++) 
    {
        if (((settings.ai_state_bits >> i) & 1) != settings.ai[i].state)
        {
            settings.ai[i].state = ((settings.ai_state_bits >> i) & 1);
            if (settings.ai[i].state == 0) {
                leds[ai_input_led[i]].state = LED_OFF;
            }
            else {
                leds[ai_input_led[i]].state = LED_ON;
            }
                
        }
    }
}

// Утсновить режим измерения канала (ток или напряжение)
void ai_set_mode(MEAS_CHAN_MODE_t mode, uint8_t channel)
{
    if (mode == MEAS_CURRENT) 
    {
        if (channel < 7)
            ai_mode |= (1 << (channel - 1));
        else
            ai_mode |= (1 << (channel + 1));
    }
    else
        if (channel < 7)
            ai_mode &= ~(1 << (channel - 1));
        else
            ai_mode &= ~(1 << (channel + 1));
          
    sh_ai_mode(ai_mode);
    
    //printf("Analog input mode: ");
    print_binary_half_word(ai_mode);
}

// Формируем слово режима работы каналов (ai_mode)
void ai_set_mode_word(MEAS_CHAN_MODE_t mode, uint8_t channel)
{
#if 0  
    if (mode == MEAS_CURRENT) 
    {
        if (channel < 7)
            ai_mode |= (1 << (channel - 1));
        else
            ai_mode |= (1 << (channel + 1));
    }
    else
        if (channel < 7)
            ai_mode &= ~(1 << (channel - 1));
        else
            ai_mode &= ~(1 << (channel + 1));
#endif
    if (mode == MEAS_CURRENT) 
    {
        if (channel < 7)
            ai_mode |= (1 << channel);
        else
            ai_mode |= (1 << channel);
    }
    else
        if (channel < 7)
            ai_mode &= ~(1 << channel);
        else
            ai_mode &= ~(1 << channel);
}

// Сигнал питания внешних датчиков
void ai_ext_sens_power(uint16_t state)
{
    if (state)
        ai_mux |= 0x80;
    else
        ai_mux &= ~(0x80);
}

// Управления LED
void ai_leds_processing(void)
{
    // Управление индикацией аварий (12 красных LED) (слово ai_alarm)
    for (uint8_t i = 0; i < AI_COMMON_NUMBER; i++) {
        if (ai_alarm & (1 << i)) {
            leds[ai_alarm_led[i]].state = LED_ON;
        }
        else {
            leds[ai_alarm_led[i]].state = LED_OFF;
        }
    }
}

//
void ai_connect_test(void)
{
    ai_connect_channel(AN_INP_1);
    ai_connect_channel(AN_INP_2);
    ai_connect_channel(AN_INP_3);
    ai_connect_channel(AN_INP_4);
    ai_connect_channel(AN_INP_5);
    ai_connect_channel(AN_INP_6);
    ai_connect_channel(V_ISO_CL);
    ai_connect_channel(V_ISO);
    
    ai_connect_channel(AN_INP_7);
    ai_connect_channel(AN_INP_8);
    ai_connect_channel(AN_INP_9);
    ai_connect_channel(AN_INP_10);
    ai_connect_channel(AN_INP_11);
    ai_connect_channel(AN_INP_12);
    ai_connect_channel(CRNT_LIM_U_BFR_R);
    ai_connect_channel(CRNT_LIM_U_ABFR_R);
}

//
void ai_mode_test(void)
{
    for (uint8_t i = 1; i < 13; i++)
    {
        ai_set_mode(MEAS_VOLTAGE, i);
    }
}

#endif