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;  // слово аварий входов

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};

uint16_t adc_raw_data[NUMBER_ADC_CH];

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};



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

// Установить режим измерения каналов с 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_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;
}  

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

//
void adc_get_two_channles(ANALOG_IN_t one, ANALOG_IN_t two)
{
    ai_connect_channel(one);
    vTaskDelay(1);
    MS5192T_SetChannel(MS5192T_CH_AIN1P_AIN1M);
    adc_raw_data[one] = MS5192T_SingleConversion();

    ai_connect_channel(two);
    vTaskDelay(1);
    MS5192T_SetChannel(MS5192T_CH_AIN2P_AIN2M);
    adc_raw_data[two] = 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[AN_INP_1], (double) adc_raw_data[AN_INP_1]*0.00001785305/0.0961538);
    printf("AN_INP_2: 0x%X, %f\r\n", adc_raw_data[AN_INP_2], (double) adc_raw_data[AN_INP_2]*0.00001785305/0.0961538);
    printf("AN_INP_3: 0x%X, %f\r\n", adc_raw_data[AN_INP_3], (double) adc_raw_data[AN_INP_3]*0.00001785305/0.0961538);
    printf("AN_INP_4: 0x%X, %f\r\n", adc_raw_data[AN_INP_4], (double) adc_raw_data[AN_INP_4]*0.00001785305/0.0961538);
    printf("AN_INP_5: 0x%X, %f\r\n", adc_raw_data[AN_INP_5], (double) adc_raw_data[AN_INP_5]*0.00001785305/0.0961538);
    printf("AN_INP_6: 0x%X, %f\r\n", adc_raw_data[AN_INP_6], (double) adc_raw_data[AN_INP_6]*0.00001785305/0.0961538);
    printf("AN_INP_7: 0x%X, %f\r\n", adc_raw_data[AN_INP_7], (double) adc_raw_data[AN_INP_7]*0.00001785305/0.0961538);
    printf("AN_INP_8: 0x%X, %f\r\n", adc_raw_data[AN_INP_8], (double) adc_raw_data[AN_INP_8]*0.00001785305/0.0961538);
    printf("AN_INP_9: 0x%X, %f\r\n", adc_raw_data[AN_INP_9], (double) adc_raw_data[AN_INP_9]*0.00001785305/0.0961538);
    printf("AN_INP_10: 0x%X, %f\r\n", adc_raw_data[AN_INP_10], (double) adc_raw_data[AN_INP_10]*0.00001785305/0.0961538);
    printf("AN_INP_11: 0x%X, %f\r\n", adc_raw_data[AN_INP_11], (double) adc_raw_data[AN_INP_11]*0.00001785305/0.0961538);
    printf("AN_INP_12: 0x%X, %f\r\n", adc_raw_data[AN_INP_12], (double) adc_raw_data[AN_INP_12]*0.00001785305/0.0961538);
    printf("V_ISO_CL: 0x%X, %f\r\n", adc_raw_data[V_ISO_CL], (double) adc_raw_data[V_ISO_CL]*0.00001785305/0.0961538);
    printf("V_ISO: 0x%X, %f\r\n", adc_raw_data[V_ISO], (double) adc_raw_data[V_ISO]*0.00001785305/0.0961538);
    printf("CRNT_LIM_U_BFR_R: 0x%X, %f\r\n", adc_raw_data[CRNT_LIM_U_BFR_R], (double) adc_raw_data[CRNT_LIM_U_BFR_R]*0.00001785305/0.0961538);
    printf("CRNT_LIM_U_ABFR_R: 0x%X, %f\r\n", adc_raw_data[CRNT_LIM_U_ABFR_R], (double) adc_raw_data[CRNT_LIM_U_ABFR_R]*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_NUMBER; i++)
    {
        
    }  
      
#if 0  
    for (int i = 0; i < DI_NUMBER; i++)
    {
        if ((settings.di_mode_bits & (1 << i)) != d_inputs[i].mode) 
        {
            d_inputs[i].mode = settings.di_mode_bits & (1 << i);
            if (d_inputs[i].mode == 0) 
            {
                d_inputs[i].cnt = 0;
                d_inputs[i].p_flag = false;
                di_cnt[i] = 0;
            }
            else
            {
                di_state_bit &= ~(1 << i);
            }
        }
    }
#endif
}

// Утсновить режим измерения канала (ток или напряжение)
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)
{
    //uint16_t foo = 0x800;
#if 0    
    // Управление индикацией вкл/выкл входов
    for (uint8_t i = 0; i < AI_NUMBER; i++) {
        if (settings.ai_state_bits & (1 << i)) {
            
        }
    }
#endif  
    
    // Управление индикацией аварий (12 красных LED) (слово ai_alarm)
    for (uint8_t i = 0; i < AI_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