SmartPDCode/control/NEW_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};
	select_channel(channel);
	//DelayNus(50);
	Check_WriteReg_Success();
//	read_ele_flag = 1;
//	read_ele_count = 0;
	Calculate_HLW8110_MeterData();
//	read_ele_flag = 0;
//	ele.voltage = read_hlw8110_v();
//	ele.current = read_hlw8110_i();
//	ele.consumer = read_hlw8110_e();
//	ele.power = read_hlw8110_p();
//	ele.freq = read_hlw8110_freq();
//	ele.factor = read_hlw8110_pf();
	
	sts_data_t *data = get_sts();
	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;
		data->m_data.out_power.angle = F_Angle *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(IS_OVERFUNC_VOLTAGE_MAX(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
				UNSET_WANNING_VOLTAGE_MAX(data->m_data.output_waning.waning);
			}		
		}
	}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)
			{
				SET_WANNING_VOLTAGE_MAX(data->m_data.input_wanning.waning[chn]);
			}else
			{
				UNSET_WANNING_VOLTAGE_MAX(data->m_data.input_wanning.waning[chn]);
			}		
		}		
	}
}

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)
			{
				SET_WANNING_VOLTAGE_MIN(data->m_data.output_waning.waning);
				if(IS_OVERFUNC_VOLTAGE_MIN(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
				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)
			{
				SET_WANNING_VOLTAGE_MIN(data->m_data.input_wanning.waning[chn]);
			}else
			{
				UNSET_WANNING_VOLTAGE_MIN(data->m_data.input_wanning.waning[chn]);
			}		
		}		
	}
}


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(IS_OVERFUNC_CURRENT_MAX(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
				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)
			{
				SET_WANNING_POWER_MAX(data->m_data.output_waning.waning);
				if(IS_OVERFUNC_POWER_MAX(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
				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)
			{
				SET_WANNING_CONSUMER_MAX(data->m_data.output_waning.waning);
				if(IS_OVERFUNC_CONSUMER_MAX(data->m_data.over_func))
				{
					data->close_output();
				}
			}else
			{
				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)
			{
				SET_WANNING_FREQ_MAX(data->m_data.input_wanning.waning[chn]);
			}else
			{
				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)
			{
				SET_WANNING_FREQ_MIN(data->m_data.input_wanning.waning[chn]);
			}else
			{
				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);
}