SmartPDCode/truing_control/STS/HARDWARE/Electricity/Electricity.c

/*********************************************************************************************************
* Module   : Electricity.c
* Abstract : Electricity modules.
* Version  : 1.0.0
* Author   : Leopul(COPYRIGHT 2025 - 2027 Leopul. All rights reserved.)
* Complete : 2025-02-16
* Content  : None
* Note     : None
*********************************************************************************************************/


#include "Electricity.h"
#include "Uart1.h"
#include "Hlw8110.h"
#include "SysTick.h"
#include "main.h"

void electricity_read(uint8_t channel);
static void check_wanning(uint8_t channel);
void electricity_init()
{
	InitCH448F();
	InitUART1(9600);
	
	for(uint8_t i = 0; i < 3;i++)
	{
		select_channel(i);
		DelayNus(50);
		Init_HLW8110();
	}
	sts_data_t *data = get_sts();
	data->read_ele = electricity_read;
	data->check_wanning = check_wanning;
}


extern float   F_AC_V;												
extern float   F_AC_I;													
extern float   F_AC_P;													
extern float   F_AC_LINE_Freq;     							
extern float   F_AC_E;													
extern float   F_AC_PF;													
extern float   F_Angle;

extern uint32_t read_ele_count;
extern uint8_t read_ele_flag;
void electricity_read(uint8_t channel)
{
	electricity_t ele = {0};
	sts_data_t *data = get_sts();
	select_channel(channel);
	if(channel == 0)
	{
		Calculate_HLW8110_MeterData(data->m_data.output_i_k,data->m_data.output_v_k);
	}else
	{
		Calculate_HLW8110_MeterData(data->m_data.input_i_k[channel-1],data->m_data.input_v_k[channel-1]);
	}
	
	if(F_AC_V < 6.0)
	{
			F_AC_V = 0.0;
			F_AC_I = 0.0;
			F_AC_P = 0.0;
			F_AC_LINE_Freq = 0.0;
			F_AC_PF = 0.0;
	}else if(F_AC_PF < 0.1 || F_AC_PF > 1 || F_AC_P < 1)
	{
			F_AC_I = 0.0;
			F_AC_P = 0.0;
			F_AC_PF = 0.0;
	}else if(F_AC_LINE_Freq > 100)
	{
			F_AC_LINE_Freq = 0.0;
	}
	
	if(channel == 0)
	{
		data->m_data.out_power.voltage = F_AC_V * 1000;
		data->m_data.out_power.current = F_AC_I * 1000;
		
		data->m_data.out_power.power = F_AC_P* 1000;
		data->m_data.out_power.freq = F_AC_LINE_Freq * 1000;
		data->m_data.out_power.factor = F_AC_PF * 1000;
		data->iic_consumer += F_AC_E;
		data->m_data.out_power.consumer = data->iic_consumer * 1000;
	}else
	{
		data->m_data.input[channel-1].voltage = F_AC_V * 1000;
		data->m_data.input[channel-1].freq = F_AC_LINE_Freq * 1000;
	}
}

static void check_voltage_max(uint8_t channel)
{
	sts_data_t *data = get_sts();
	if(channel == CH448_CHANNEL_1)
	{
		if(IS_VOLTAGE_MAX_EN(data->output_wanning_en)) {
			if(data->m_data.out_power.voltage > data->m_data.output_th.voltage_max)
			{
				SET_WANNING_VOLTAGE_MAX(data->m_data.output_waning.waning);
				if(!data->o_beep.o_t.o_v_max)
				{
					data->o_beep.o_t.o_v_max =1;
					data->o_beep_flag.o_t.o_v_max =1;
					data->beep_count = data->wanning_count;
				}
				if(IS_OVERFUNC_VOLTAGE_MAX(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
				UNSET_WANNING_VOLTAGE_MAX(data->m_data.output_waning.waning);
				if(data->o_beep.o_t.o_v_max)
				{
					data->o_beep.o_t.o_v_max = 0;
					data->o_beep_flag.o_t.o_v_max = 0;
				}
			}		
		}
	}else
	{
		uint8_t chn = channel-1;
		if(IS_VOLTAGE_MAX_EN(data->input_wanning_en[chn])) {
			if(data->m_data.input[chn].voltage > data->m_data.input_th[chn].voltage_max)
			{
				if(!data->i_beep[chn].i_t.i_v_max)
				{
					data->i_beep[chn].i_t.i_v_max =1;
					data->i_beep_flag[chn].i_t.i_v_max =1;
					data->beep_count = data->wanning_count;
				}
				SET_WANNING_VOLTAGE_MAX(data->m_data.input_wanning.waning[chn]);
			}else
			{
				UNSET_WANNING_VOLTAGE_MAX(data->m_data.input_wanning.waning[chn]);
				data->i_beep[chn].i_t.i_v_max =0;
			  data->i_beep_flag[chn].i_t.i_v_max =0;
			}		
		}		
	}
}

static void check_voltage_min(uint8_t channel)
{
	sts_data_t *data = get_sts();
	if(channel == CH448_CHANNEL_1)
	{
		if(IS_VOLTAGE_MIN_EN(data->output_wanning_en)) {
			if(data->m_data.out_power.voltage < data->m_data.output_th.voltage_min)
			{
				if(!data->o_beep.o_t.o_v_max)
				{
					data->o_beep.o_t.o_v_min =1;
					data->o_beep_flag.o_t.o_v_min =1;
					data->beep_count = data->wanning_count;
				}
				SET_WANNING_VOLTAGE_MIN(data->m_data.output_waning.waning);
				if(IS_OVERFUNC_VOLTAGE_MIN(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
					data->o_beep.o_t.o_v_min = 0;
					data->o_beep_flag.o_t.o_v_min = 0;
				UNSET_WANNING_VOLTAGE_MIN(data->m_data.output_waning.waning);
			}		
		}
	}else
	{
		uint8_t chn = channel-1;
		if(IS_VOLTAGE_MIN_EN(data->input_wanning_en[chn])) {
			if(data->m_data.input[chn].voltage < data->m_data.input_th[chn].voltage_min)
			{
				if(!data->i_beep[chn].i_t.i_v_min)
				{
					data->i_beep[chn].i_t.i_v_min =1;
					data->i_beep_flag[chn].i_t.i_v_min =1;
					data->beep_count = data->wanning_count;
				}
				SET_WANNING_VOLTAGE_MIN(data->m_data.input_wanning.waning[chn]);
			}else
			{
				UNSET_WANNING_VOLTAGE_MIN(data->m_data.input_wanning.waning[chn]);
					data->i_beep[chn].i_t.i_v_min =0;
					data->i_beep_flag[chn].i_t.i_v_min =0;
			}		
		}		
	}
}


static void check_current_max(uint8_t channel)
{
	sts_data_t *data = get_sts();
	if(channel == CH448_CHANNEL_1)
	{
		if(IS_CURRENT_MAX_EN(data->output_wanning_en)) {
			if(data->m_data.out_power.current > data->m_data.output_th.current_max)
			{
				SET_WANNING_CURRENT_MAX(data->m_data.output_waning.waning);
				if(!data->o_beep.o_t.o_i_max)
				{
					data->o_beep.o_t.o_i_max =1;
					data->o_beep_flag.o_t.o_i_max =1;
					data->beep_count = data->wanning_count;
				}
				if(IS_OVERFUNC_CURRENT_MAX(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
				data->o_beep.o_t.o_i_max =0;
				data->o_beep_flag.o_t.o_i_max =0;
				UNSET_WANNING_CURRENT_MAX(data->m_data.output_waning.waning);
			}		
		}
	}
}

static void check_power_max(uint8_t channel)
{
	sts_data_t *data = get_sts();
	if(channel == CH448_CHANNEL_1)
	{
		if(IS_POWER_MAX_EN(data->output_wanning_en)) {
			if(data->m_data.out_power.power > data->m_data.output_th.power_max)
			{
				if(!data->o_beep.o_t.o_p_max)
				{
					data->o_beep.o_t.o_p_max =1;
					data->o_beep_flag.o_t.o_p_max =1;
					data->beep_count = data->wanning_count;
				}
				SET_WANNING_POWER_MAX(data->m_data.output_waning.waning);
				if(IS_OVERFUNC_POWER_MAX(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
					data->o_beep.o_t.o_p_max = 0;
					data->o_beep_flag.o_t.o_p_max = 0;
				UNSET_WANNING_POWER_MAX(data->m_data.output_waning.waning);
			}		
		}
	}
}

static void check_consumer_max(uint8_t channel)
{
	sts_data_t *data = get_sts();
	if(channel == CH448_CHANNEL_1)
	{
		if(IS_CONSUMER_MAX_EN(data->output_wanning_en)) {
			if(data->m_data.out_power.consumer > data->m_data.output_th.consumer_max)
			{
				if(!data->o_beep.o_t.o_c_max)
				{
					data->o_beep.o_t.o_c_max =1;
					data->o_beep_flag.o_t.o_c_max =1;
					data->beep_count = data->wanning_count;
				}
				SET_WANNING_CONSUMER_MAX(data->m_data.output_waning.waning);
				if(IS_OVERFUNC_CONSUMER_MAX(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
					data->o_beep.o_t.o_c_max =0;
					data->o_beep_flag.o_t.o_c_max =0;
				UNSET_WANNING_CONSUMER_MAX(data->m_data.output_waning.waning);
			}		
		}
	}
}

static void check_freq_max(uint8_t channel)
{
	sts_data_t *data = get_sts();
	if(channel != CH448_CHANNEL_1)
	{
		uint8_t chn = channel -1;
		if(chn > CH448_CHANNEL_3)
			return;
		if(IS_FREQ_MAX_EN(data->input_wanning_en[chn])) {
			if(data->m_data.input[chn].freq > data->m_data.input_th[chn].freq_max)
			{
				if(!data->i_beep[chn].i_t.i_hz_max)
				{
					data->i_beep[chn].i_t.i_hz_max =1;
					data->i_beep_flag[chn].i_t.i_hz_max =1;
					data->beep_count = data->wanning_count;
				}
				SET_WANNING_FREQ_MAX(data->m_data.input_wanning.waning[chn]);
			}else
			{
					data->i_beep[chn].i_t.i_hz_max =0;
					data->i_beep_flag[chn].i_t.i_hz_max =0;
				UNSET_WANNING_FREQ_MAX(data->m_data.input_wanning.waning[chn]);
			}		
		}
	}
}

static void check_freq_min(uint8_t channel)
{
	sts_data_t *data = get_sts();
	if(channel != CH448_CHANNEL_1)
	{
		uint8_t chn = channel - 1;
		if(chn > CH448_CHANNEL_3)
			return;
		if(IS_FREQ_MIN_EN(data->input_wanning_en[chn])) {
			if(data->m_data.input[chn].freq < data->m_data.input_th[chn].freq_min)
			{
				if(!data->i_beep[chn].i_t.i_hz_min)
				{
					data->i_beep[chn].i_t.i_hz_min =1;
					data->i_beep_flag[chn].i_t.i_hz_min =1;
					data->beep_count = data->wanning_count;
				}
				SET_WANNING_FREQ_MIN(data->m_data.input_wanning.waning[chn]);
			}else
			{
					data->i_beep[chn].i_t.i_hz_min =0;
					data->i_beep_flag[chn].i_t.i_hz_min =0;
				UNSET_WANNING_FREQ_MIN(data->m_data.input_wanning.waning[chn]);
			}		
		}
	}
}

static void check_wanning(uint8_t channel)
{
	check_voltage_max(channel);
	check_voltage_min(channel);
	check_current_max(channel);
	check_power_max(channel);
	check_consumer_max(channel);
	check_freq_max(channel);
	check_freq_min(channel);
}