/*
 * @Author: wujunchao wujunchao@wuxismart.com
 * @Date: 2024-12-24 08:18:26
 * @LastEditors: wujunchao wujunchao@wuxismart.com
 * @LastEditTime: 2025-03-20 15:01:22
 * @FilePath: \signal_generator\App\MUX_SIGNAL\mux_signal.c
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
/*
 * @Author: DaMingSY zxm5337@163.com
 * @Date: 2024-09-02 15:58:58
 * @LastEditors: DaMingSY zxm5337@163.com
 * @LastEditTime: 2024-11-28 10:21:04
 * @FilePath: \signal_generator\App\MUX_SIGNAL\mux_signal.c
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
#include "FreeRTOS.h"
#include "task.h"
#include "tim.h"
#include "mux_signal.h"
#include "dac.h"
#include "adc.h"
#include "rn7302.h"
#include <SIG24130.h>
#include "dac8552.h"
#include "ads1220.h"
#include "dac7811.h"
#include "apps_gather.h"

st_mux_signal mux_signal = {
    .channel = CHX_IN_MAX,
};

st_freq_signal freq_signal;

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
    if (&htim3 == htim)
    {
        if (freq_signal.capture_cnt >= 1)
        {
            HAL_TIM_IC_Stop_IT(&htim3, TIM_CHANNEL_4);
        }
        freq_signal.capture_buf[freq_signal.capture_cnt++] = HAL_TIM_ReadCapturedValue(&htim3, TIM_CHANNEL_4); // 获取当前的捕获值.
    }
}

void fun_get_freq(st_freq_signal *freq_signal, float *data_pv)
{
    if (!freq_signal || !data_pv)

        return;

    if (freq_signal->capture_cnt >= 1)
    {
        freq_signal->capture_cnt = 0;
        __HAL_TIM_SET_COUNTER(&htim3, 0);
        // freq_signal->duty_time = freq_signal->capture_buf[1] + freq_signal->over_cnt * 60000 - freq_signal->capture_buf[0];
        // freq_signal->freq = 1000000 / freq_signal->duty_time;
        freq_signal->duty_time = freq_signal->capture_buf[1] + freq_signal->over_cnt * 65535 - freq_signal->capture_buf[0];
        freq_signal->freq = 82944000 / freq_signal->duty_time;
        *data_pv = freq_signal->freq;
        freq_signal->over_cnt = 0;
    }
    else
    {
        HAL_TIM_Base_Start_IT(&htim3);
        HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_4);
    }
}

void hc138_channel_test(void)
{
    uint8_t i;
    for (i = 0; i < 10; i++)
    {
        HC138_SEL_CH(i);
        vTaskDelay(3000);
    }
    vTaskDelay(3000);
}

void pwr_cosume(BOOL rst, uint32_t ms)
{
    if (rst == TRUE || mux_signal.pwr_delay == 0)
        mux_signal.pwr_delay = xTaskGetTickCount();

    if (mux_signal.pwr_delay + ms > xTaskGetTickCount())
        return;
    else
        mux_signal.pwr_delay = xTaskGetTickCount();

    PWR_CTRL(GPIO_PIN_RESET);
    vTaskDelay(250);
    PWR_CTRL(GPIO_PIN_SET);
    vTaskDelay(250);
    PWR_CTRL(GPIO_PIN_RESET);
    vTaskDelay(250);
    PWR_CTRL(GPIO_PIN_SET);
    vTaskDelay(250);
    PWR_CTRL(GPIO_PIN_RESET);
}

// static void fun_pwr12_ctrl(uint8_t ch)
// {
//     static uint8_t lasht_ch;
//     BOOL ch_flag = FALSE;

//     if (ch != lasht_ch)
//     {
//         ch_flag = TRUE;
//         lasht_ch = ch;
//     }
//     if (ch_flag == TRUE)
//     {
//         ch_flag = FALSE;
//         //if ((ch == CH0_OUT_VOL_V) || (ch == CH2_OUT_CUR) || (ch == CH3_OUT_FRE) || (ch == CH4_OUT_RES))
//             //PWR12_CTRL(GPIO_PIN_SET);
//         //else
//             //PWR12_CTRL(GPIO_PIN_RESET);
//     }
// }

uint8_t pulse = 50;
float32 fre_set = 0;
float32 sv_prv = 0;
CHANNEL ch_prv = CHX_IN_MAX;
uint8_t mux_set_flag = 0;
void mux_signal_switch(st_mux_signal *mux_signal)
{
    //只有频道和设定值改变时才执行设定操作（不影响回采和输入采集）
    if( (mux_signal->channel != ch_prv)||(mux_signal->data_sv != sv_prv) )
    {
        ch_prv = mux_signal->channel;
        sv_prv = mux_signal->data_sv;
        mux_set_flag = 1;
    }
    else
    {
        mux_set_flag = 0;
    }

    //切换通道
    HC138_SEL_CH(mux_signal->channel);
    
    //执行通道对应的功能
    switch (mux_signal->channel)
    {
        case CH0_OUT_VOL_V:
        {
            if(mux_set_flag) dac_set_voltage(&mux_signal->data_sv);             //设定
            fun_proc_adc1_dma(&mux_signal->data_pv);                            //回采
        }
        break;

        case CH1_OUT_VOL_MV:
        {
            if(mux_set_flag) dac8552_operation(NULL, &mux_signal->data_sv);     //设定
            fun_get_sig16132_ch(4, &mux_signal->data_pv);                       //回采
        }
        break;

        case CH2_OUT_CUR:
        {
            if(mux_set_flag) dac8552_operation(&mux_signal->data_sv, NULL);     //设定
            fun_get_sig16132_ch(7, &mux_signal->data_pv);                       //回采
        }
        break;

        case CH3_OUT_FRE:
        {
            if( (tabdata.hart_enable == 0)&&(mux_set_flag) ) 
            {
                //freq_operation(mux_signal->data_sv, pulse, TIM_CHANNEL_2);
                frequence_output(mux_signal->data_sv, pulse, TIM_CHANNEL_2);    //设定
                fre_set = mux_signal->data_sv;
            }
        }
        break;

        case CH4_OUT_RES:
            if(mux_set_flag) fun_dac7811_operate(&mux_signal->data_sv);         //设定
        break;

        case CH5_EMPTY:
        break;

        case CH6_IN_VOL:
            fun_get_sig16132_ch(2, &mux_signal->data_pv);                       //输入采集
        break;

        case CH7_IN_MVOL:
            fun_get_sig16132_ch(3, &mux_signal->data_pv);                       //输入采集
        break;

        case CH8_IN_CUR:
            fun_get_sig16132_ch(5, &mux_signal->data_pv);                       //输入采集
        break;

        case CH9_IN_FRE:
            fun_get_freq(&freq_signal, &mux_signal->data_pv);                   //输入采集
        break;

        case CH10_IN_RTD:
		    fun_get_sig16132_ch(CH10_IN_RTD, &mux_signal->data_pv);             //输入采集
        break;

        case CH11_IN_TC:
            ads1220_operation(CH11_IN_TC, &mux_signal->data_pv);                //输入采集
        break;

        default:
        break;
    }
}

void frequence_output(uint32_t freq, uint8_t pulse, uint32_t chan)
{
    HAL_TIMEx_PWMN_Stop(&htim1, TIM_CHANNEL_2);                          
    HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_3);   

    if (freq <= 0 || freq >= 500000 || pulse <= 0 || pulse >= 100)       
    {                                                                    
      __HAL_TIM_SET_PRESCALER(&htim1, 1500-1);                           
      __HAL_TIM_SET_AUTORELOAD(&htim1, 55-1);                            
      __HAL_TIM_SET_COMPARE(&htim1, chan, 28-1);                         
      return;                                                             
    }         

    int fre_duty = 0;                                                    
    if(freq <= 650)                                   
    {                                                                    
      __HAL_TIM_SET_PRESCALER(&htim1, 1500-1);                           
      fre_duty = ( (float32)FREQ_SYS / (float32)1500.0 / (float32)freq + (float32)0.5 );  
    }                                                                    
    else                                                 
    {                                                                    
      __HAL_TIM_SET_PRESCALER(&htim1, 2-1);                              
      fre_duty = ( (float32)FREQ_SYS / (float32)2.0 / (float32)freq + (float32)0.5 );     
    }                    

    __HAL_TIM_SET_AUTORELOAD(&htim1, fre_duty -1);                       
    __HAL_TIM_SET_COMPARE(&htim1, chan, fre_duty * pulse / 100 - 1);      
    if( chan == TIM_CHANNEL_2)                                           
    {                                                                    
      HAL_TIMEx_PWMN_Start(&htim1, chan);                                
    }                                                                    
    else                                                                 
    {                                                                    
      HAL_TIM_PWM_Start(&htim1, chan);                                   
    }                        
}