SmartPDCode/truring_ctrl_upgrade/PDU-DC_ADA/hardware/electricity/electricity.c

#include "electricity.h"
#include "uart.h"
#include "common.h"
#include "board_cfg.h"
#include "relay.h"
#include "ADC.h"
#include "gd32e23x.h"
#include "IM1253E.h"
#include "stdbool.h"

static board_t *board = 0;
static void read_ele(uint8_t channel);
static void check_wanning(uint8_t in_out,uint8_t channel);
static void opt_over_func(uint8_t channel);
static void read_vatage(void);
static void read_current(void);
static void read_consumer(void);


extern unsigned char	B_Rx_Finish;
extern unsigned char	u8_RxBuf[64];
extern uint32_t DCPDU_Iin_Zero;
extern uint32_t DCPDU_Win_Zero;

#if SUPPORT_2_V_GA_CHN
	extern	uint16_t adc_original_value[ADC_CH_N+ADC_V_CHN];
	extern uint32_t adc_Avg_value[ADC_CH_N+ADC_V_CHN];
	extern uint16_t adc_data_zero[ADC_CH_N+ADC_V_CHN];
#else

	extern	uint16_t adc_original_value[ADC_CH_N];
	extern	uint32_t adc_Avg_value[ADC_CH_N];
	extern uint16_t adc_data_zero[ADC_CH_N];
#endif







void init_adc_parameter(void)
{
	board = get_board();
	while(!dma_flag_get(DMA_CH0,DMA_FLAG_FTF)){};
		dma_flag_clear(DMA_CH0,DMA_FLAG_FTF);	
	for(int i = 0;i < 8;i++)
	{
		adc_data_zero[i] = adc_original_value[i];
	}
#if SUPPORT_IM1253E
	board->flag_im1253_init = 1;
	board->flag_im1253_onlone = 0;
	do{
		Read_IM1253E_REG(Device_addr_IM1253E,V_REG_ADDR,8);
		uint8_t count = 5;
		do{
			if(B_Rx_Finish)
			{
				B_Rx_Finish = 0;
				uint8_t temp1 = 0;
				uint8_t temp2 = 0;
				uint32_t temp0 = 0;
				uint32_t temp_da[8] = {0};				
				uint8_t i = 0;
				uint8_t j = 0;				
				for(j = 0;j < 8;j++)
				{
					temp_da[j] = 0;
					for(i = 0;i < 4;i++)
					{
						temp1 = 8 * i;
						temp1 = 24 - temp1;
						temp2 = 4 * j;
						temp2 += 3;
						temp2 += i;
						temp0 = u8_RxBuf[temp2] << temp1;
						temp_da[j] += temp0;
					}
				}
				DCPDU_Iin_Zero = temp_da[1] / 10;
				DCPDU_Win_Zero = temp_da[2] / 10;		
				board->md_data.r_data.input.voltage = temp_da[0] / 10;
				for(i = 0;i < RelaySlaveChaNum;i++)
				{
					  board->md_data.r_data.output[i].voltage = board->md_data.r_data.input.voltage;
				}
				
				board->flag_im1253_init = 0;
				board->flag_im1253_onlone = 1;
				break;
			}
			DelayNms(5);
		}while(count --);
	}while(board->flag_im1253_init);
	
#else
	
	
	
#endif
}



void electricity_init(void)
{
	board = get_board();
#if SUPPORT_STM32_ADC
	uart1_config(115200);
	che442e_Init();
#elif SUPPORT_IM1253E
	uart1_config(4800);
#endif
	Init_ADC();
	board->read_valtage = read_vatage;
	board->read_current = read_current;
	board->check_wanning = check_wanning;
	board->opt_overfunc = opt_over_func;
	board->read_consumer = read_consumer;
}



static void read_vatage(void)
{
	board_t *board = get_board();
#if SUPPORT_IM1253E
	if(board->flag_read_im1253)
	{
		board->flag_read_im1253 = 0;
		if(board->flag_im1253_onlone)
		{
			Read_IM1253E_REG(Device_addr_IM1253E,V_REG_ADDR,8);
			uint32_t count = 5;
			do{
				if(B_Rx_Finish)
				{
					break;
				}
				DelayNms(3);
			}while(count --);
		}

		uint32_t temp_da[8] = {0};
		uint8_t temp1 = 0;
		uint8_t temp2 = 0;
		uint32_t temp0 = 0;
		static uint32_t recive_count = 0;
		if(B_Rx_Finish)
		{
			recive_count = 0;
			B_Rx_Finish = 0;
			for(int j = 0;j < 8;j++)
			{
				temp_da[j] = 0;
				for(int i = 0;i < 4;i++)
				{
					temp1 = 8 * i;
					temp1 = 24 - temp1;
					temp2 = 4 * j;
					temp2 += 3;
					temp2 += i;
					temp0 = u8_RxBuf[temp2] << temp1;
					temp_da[j] += temp0;
				}
			}
			board->md_data.r_data.input.voltage = temp_da[0] / 10;
			
			board->md_data.r_data.input.current = temp_da[1] / 10;
			if(board->md_data.r_data.input.current > DCPDU_Iin_Zero)
			{
				board->md_data.r_data.input.current -= DCPDU_Iin_Zero;
			}else
			{
				board->md_data.r_data.input.current = 0;
			}
			board->md_data.r_data.input.power   = temp_da[2] / 10;
			if(board->md_data.r_data.input.power > DCPDU_Win_Zero)
			{
				board->md_data.r_data.input.power -= DCPDU_Win_Zero;
			}else
			{
				board->md_data.r_data.input.power = 0;
			}

			board->md_data.r_data.input.consumer = board->input_store + temp_da[3] / 10;
			
		}else
		{
			recive_count ++;
			if(recive_count == 5)
			{
				board->md_data.r_data.input.voltage = 0;
				board->md_data.r_data.input.current = 0;
				board->md_data.r_data.input.power   = 0;
				board->md_data.r_data.input.consumer= board->input_store;
				recive_count = 0;
			}
		}
		for(int i = 0;i < RelaySlaveChaNum;i++)
				board->md_data.r_data.output[i].voltage = board->md_data.r_data.input.voltage;
	}
#else
	#if SUPPORT_STM32_ADC
			uint32_t voltage_chi_1 = 0;
			uint32_t voltage_chi_2 = 0;
			voltage_chi_1 = read_stm_voltage(STM32_ADC_V_1) ;
			//delay_ms(5);
#if SURPPORT_2_PT
			voltage_chi_2 = read_stm_voltage(STM32_ADC_V_2) ;
#endif
			board->md_data.r_data.input.voltage = voltage_chi_1 > voltage_chi_2 ? voltage_chi_1 : voltage_chi_2;

			for(int i = 0;i < PT_SUB_COUNT;i++)
			{
				board->md_data.r_data.output[i].voltage = voltage_chi_1;
			}
#if SURPPORT_2_PT
			for(int i = PT_SUB_COUNT;i < RelaySlaveChaNum;i++)
			{
				board->md_data.r_data.output[i].voltage = voltage_chi_2;
			}			
#endif

			
	#endif
	
#endif
}


static void read_consumer(void)
{
	board_t *board = get_board();
	for(int i = 0 ; i < RelaySlaveChaNum;i++)
	{
		float temp_w = board->md_data.r_data.output[i].power;
		temp_w /= 1000.0;
		temp_w /= 3600.0;
		board->dc_consumer[i] += temp_w;
		board->md_data.r_data.output[i].consumer = board->ele_restore[i] + (uint32_t)(board->dc_consumer[i]);
	}
}

extern bool adc_data_ok_flag;

static void read_current(void)
{
	board_t *board = get_board();
	//read_adc_val();
	if(adc_data_ok_flag == true)
	{
		for(int i = 0;i < RelaySlaveChaNum;i++)
		{
			if((board->md_data.r_data.rl_status & (1 << i)))
			{
				board->md_data.r_data.output[i].current = DC_I_calfunction(adc_Avg_value[i],i);
			}else
			{
				board->md_data.r_data.output[i].current = 0;
			}

			adc_Avg_value[i] = 0;
			uint32_t temp_v = board->md_data.r_data.output[i].voltage / 10;
			uint32_t temp_i = board->md_data.r_data.output[i].current / 10;
			board->md_data.r_data.output[i].power = (temp_v * temp_i) / 10;
			adc_data_ok_flag = false;
		}
	}
}





static void check_wanning(uint8_t in_out,uint8_t channel)
{
	if(in_out == ELE_INPUT)
	{
	}else
	{
			if(channel < RelaySlaveChaNum)
			{
				if(IS_VOLTAGE_MAX_EN(board->out_wanning_en[channel]) && 
								board->md_data.r_data.output[channel].voltage > board->md_data.rw_data.v_max[channel])
				{
					board->md_data.r_data.wanning[channel].v_max= WANNING_SET;
					if(board->md_data.rw_data.over_func[channel].v_max_over)
					{
						board->over_func[channel] = 1;
					}
				}else
				{
					board->md_data.r_data.wanning[channel].v_max= WANNING_UNSET;
				}
				
				if(IS_VOLTAGE_MIN_EN(board->out_wanning_en[channel]) && 
								board->md_data.r_data.output[channel].voltage < board->md_data.rw_data.v_min[channel])
				{
					board->md_data.r_data.wanning[channel].v_min = WANNING_SET;
					if(board->md_data.rw_data.over_func[channel].v_min_over)
					{
						board->over_func[channel] = 1;
					}
				}else
				{
					board->md_data.r_data.wanning[channel].v_min = WANNING_UNSET;
				}
				
				if(IS_CURRENT_MAX_EN(board->out_wanning_en[channel]) && 
								board->md_data.r_data.output[channel].current > board->md_data.rw_data.i_max[channel])
				{
					board->md_data.r_data.wanning[channel].i_max = WANNING_SET;
					if(board->md_data.rw_data.over_func[channel].i_max_over)
					{
						board->over_func[channel] = 1;
					}
				}else
				{
					board->md_data.r_data.wanning[channel].i_max = WANNING_UNSET;
				}

				if(IS_POWER_MAX_EN(board->out_wanning_en[channel]) && 
								board->md_data.r_data.output[channel].power > board->md_data.rw_data.p_max[channel])
				{
					board->md_data.r_data.wanning[channel].p_max = WANNING_SET;
					if(board->md_data.rw_data.over_func[channel].p_max_over)
					{
						board->over_func[channel] = 1;
					}
				}else
				{
					board->md_data.r_data.wanning[channel].p_max = WANNING_UNSET;
				}

				if(IS_CONSUMER_MAX_EN(board->out_wanning_en[channel]) && 
								board->md_data.r_data.output[channel].consumer > board->md_data.rw_data.c_max[channel])
				{
					board->md_data.r_data.wanning[channel].c_max = WANNING_SET;
					if(board->md_data.rw_data.over_func[channel].c_max_over)
					{
						board->over_func[channel] = 1;
					}
				}else
				{
					board->md_data.r_data.wanning[channel].c_max = WANNING_UNSET;
				}
			}
	}
}


static void opt_over_func(uint8_t channel)
{
	if(board->over_func[channel])
	{
		board->over_func[channel] = 0;
		if((board->md_data.r_data.rl_status & (1 << channel)) == (RELAY_OPEN << channel))
		{
				async_data da = {0};
				da.channel = channel;
				da.fire_or_zero = _FIRE;
				da.method = PROMPT_CTRL;
				da.reg = &board->relay_staging_staus[channel];
				da.status = RELAY_CLOSE;
				da.w_eep_flag = FLAG_N_W_EEP;
				set_relay_sta_async(&da);				
		}
	}
}