SmartPDCode/truring_ctrl_upgrade/PDU-AC_ADA_NEW/common/common.c

#include "common.h"
#include "board_cfg.h"
#include "systick.h"
#include "string.h"

#if EEPROM_TEST		

#define TEST_ADDR  (120 * 32)
#define LENTH      (32)

#endif



void reset_config_for_eeprom(void)
{
	board_t *board = get_board();
	if(board)
	{
			for(uint8_t i = 0; i < MAX_CHANNEL;i++)
			{
				board->md_data.rw_data.open.delay_open[i]  = (1+i) *1000;
				board->md_data.rw_data.close.delay_close[i] = (1+i) *1000;
			}
		memset((void*)&board->md_data.rw_data.thr.th[0].v_top,0,sizeof(ac_rw_data_t)-sizeof(ac_delay_open_t)-sizeof(ac_delay_close_t));
		board->write_eeprom_page(EEPROM_OTHER_ADDR,(uint8_t *)&board->md_data.rw_data.open.delay_open[0], sizeof(ac_rw_data_t));
	}
}


void read_config_from_eeprom(void)
{
	board_t *board = get_board();
	if(board)
	{
		uint16_t device = 0;
		board->read_eeprom(EEPROM_DEVICES_ADDR,(uint8_t *)&device,EEPROM_DEVICES_LENTH);

		if(device != board->md_data.r_data.dev_chn)
		{
			//default write eeprom
			
			board->write_eeprom_page(EEPROM_STATUS_ADDR,(uint8_t *)&board->relay_staging_staus[0],2*RelaySlaveChaNum);
			for(uint8_t i = 0; i < RelaySlaveChaNum;i++)
			{
				board->md_data.rw_data.open.delay_open[i]  	= (1+i) * 1000;
				board->md_data.rw_data.close.delay_close[i] = (1+i) * 1000;
			}
			
			board->write_eeprom_page(EEPROM_OTHER_ADDR,(uint8_t *)&board->md_data.rw_data.open.delay_open[0], sizeof(ac_rw_data_t));
			iic_data chache={0};
			for(uint8_t i = 0 ; i < MAX_ROW;i++){
				board->write_eeprom_page(EEPROM_CONSUMER_ADDR +(CONSUM_PAGE*i),(uint8_t*)&chache.data[0],CONSUM_PAGE);
			}
			
			board->v_k[0] = 3135;
			board->v_k[1] = 3135;
			
			board->i_k[0] = 10000;
			board->i_k[1] = 10000;		
			board->write_eeprom_page(EEPROM_K_V_ADDR,(uint8_t *)&board->v_k[0],EEPROM_K_V_LEN);
			
			board->write_eeprom_page(EEPROM_K_I_ADDR,(uint8_t *)&board->i_k[0],EEPROM_K_I_LEN);
			
			
#if SUPPORT_MICRO_SWITCH
			board->write_eeprom_page(EEPROM_SELF_LOCK_STATUS,(uint8_t *)&board->val_key[0],EEPROM_SELF_LOCK_STATUS_LEN);
#endif
			
				
			board->write_eeprom_page(EEPROM_DEVICES_ADDR,(uint8_t *)&board->md_data.r_data.dev_chn,EEPROM_DEVICES_LENTH);
		}
		{
			//channel open or close
			board->read_eeprom_page(EEPROM_STATUS_ADDR,(uint8_t *)&board->relay_staging_staus[0],2*RelaySlaveChaNum);
			{
				for(int i = 0 ;i < RelaySlaveChaNum;i++)
				{
#ifndef SUPPORT_MON
		#if SUPPORT_CTRL2_LOCK2
					if(i < AVALIABLE_RELAY)
					{
						if(board->relay_staging_staus[i])
						{
							SET_RL_ON_DELAY_FLAG(board->relay_staging_staus[i]);
							CLEAR_RL_OFF_DELAY_FLAG(board->relay_staging_staus[i]);
							SET_RL_ORDER_FLAG(board->relay_staging_staus[i]);
						}
					}else
					{
						board->md_data.r_data.state.state[i].state = 1;
					}
					
		#else					
					if(board->relay_staging_staus[i])
					{
						SET_RL_ON_DELAY_FLAG(board->relay_staging_staus[i]);
						CLEAR_RL_OFF_DELAY_FLAG(board->relay_staging_staus[i]);
						SET_RL_ORDER_FLAG(board->relay_staging_staus[i]);
					}
		#endif
#else
					board->md_data.r_data.state.state[i].state = 1;
#endif
				}

			}
			board->read_eeprom_page(EEPROM_OTHER_ADDR,(uint8_t *)&board->md_data.rw_data.open.delay_open[0],sizeof(ac_rw_data_t));

			for(uint8_t i = 0 ; i < RelaySlaveChaNum;i++)
			{
				board->check_threshold(THRESHOLD_OUT,i);
			}
			
			board->read_eeprom_page(EEPROM_K_V_ADDR,(uint8_t *)&board->v_k[0],EEPROM_K_V_LEN);
			
			board->read_eeprom_page(EEPROM_K_I_ADDR,(uint8_t *)&board->i_k[0],EEPROM_K_I_LEN);
			
#if SUPPORT_MICRO_SWITCH
			board->read_eeprom_page(EEPROM_SELF_LOCK_STATUS,(uint8_t *)&board->val_key[0],EEPROM_SELF_LOCK_STATUS_LEN);
			
			for(int i = 0; i < RelaySlaveChaNum;i++)
			{
				if(board->val_key[i] > 1)
				{
					board->val_key[i] = 0;
				}
			}
#endif
			
			for(int i =0 ;i < 2;i++)
			{
				board->v_k[i] = board->v_k[i] > 10000 ?  3135 : board->v_k[i];
				board->i_k[i] = board->i_k[i] > 10000 ?  10000 : board->i_k[i];
			}
			
			iic_data chache={0};
			for(uint8_t i = 0 ; i < MAX_ROW;i++)
			{
				board->read_eeprom_page(EEPROM_CONSUMER_ADDR + (CONSUM_PAGE*i),(uint8_t*)&chache,sizeof(iic_data));
				if(board->con_da.index > chache.iic_con.recode_index1)
				{
					
				}else
				{
					board->con_da.index = chache.iic_con.recode_index1;
					board->con_da.row = i;
				}
			}	
			board->read_eeprom_page(EEPROM_CONSUMER_ADDR +(CONSUM_PAGE*(board->con_da.row)),(uint8_t*)&chache,sizeof(iic_data));
			for(uint16_t i = 0 ; i < RelaySlaveChaNum;i++)
			{
					board->ele_restore[i] = chache.iic_con.iic_consumer[i];
			}

			board->con_da.row++;      //point next write row
			if(board->con_da.row >= MAX_ROW)
			{
				board->con_da.row = 0;
			}
			board->con_da.index++;		//point next write consumer index
			if(board->con_da.index >= UINT64_MAX)
			{
				iic_data chache1={0};
				board->con_da.index = 0;
				for(uint8_t i = 0 ; i < MAX_ROW;i++){
					board->write_eeprom_page(EEPROM_CONSUMER_ADDR +(CONSUM_PAGE*i),(uint8_t*)&chache1,CONSUM_PAGE);
					DelayNms(7);
				}
			}
			//read chn ctrl
		}
	}
}


void set_relay_sta_async(async_data *data)
{
	if(!data)
		goto failed;
	board_t *board = get_board();
	if(board)
	{
		if(data->fire_or_zero == _FIRE)
		{
			//if(board->md_data.rw_data.rw_d.chn_ctrl[data->channel] != 0)  goto failed;
			if(data->w_eep_flag == FLAG_W_EEP)
			{
				w_eeprom_data_t da = {0};
				da.lenth =2;
				memcpy((void*)&da.data,(void*)&data->status,2);
				da.start_addr = (EEPROM_STATUS_ADDR+(data->channel*2));
				board->q_cache.en_queue(&da);
			}
		}
		else if(data->fire_or_zero == _ZERO)
		{
	#if (ZERO_CONTRL == ZERO_LINE_CTRL_YES)
			if(data->w_eep_flag == FLAG_W_EEP)
			{
				w_eeprom_data_t da = {0};
				da.lenth =2;
				memcpy(&da.data,&data->status,2);
				da.start_addr = (EEPROM_STATUS_ADDR+((data->channel+13)*2));
				board->q_cache.en_queue(&da);	
			}			
	#else
				goto failed;
	#endif			
		}
		else
		{
			goto failed;
		}
		SET_RL_STATUS(*data->reg,data->status);
		if(data->method == DELAY_CTRL)
		{
				if(data->status)
				{
					SET_RL_ON_DELAY_FLAG(*(data->reg));
					CLEAR_RL_OFF_DELAY_FLAG(*(data->reg));
				}else
				{
					CLEAR_RL_ON_DELAY_FLAG(*(data->reg));
					SET_RL_OFF_DELAY_FLAG(*(data->reg));
				}						
		}else
		{
			if(data->status)
			{
				CLEAR_RL_ON_DELAY_FLAG(*(data->reg));
				CLEAR_RL_OFF_DELAY_FLAG(*(data->reg));
			}else
			{
				CLEAR_RL_ON_DELAY_FLAG(*(data->reg));
				CLEAR_RL_OFF_DELAY_FLAG(*(data->reg));
			}						
		}
		SET_RL_ORDER_FLAG(*(data->reg));
	}
failed:
	return;
}



void set_relay_status_async(uint16_t *reg,uint8_t method,uint16_t status)
{
	board_t *board = get_board();
	SET_RL_STATUS(*reg,status);
	if(method == DELAY_CTRL)
	{
		if(status)
		{
			SET_RL_ON_DELAY_FLAG(*reg);
			CLEAR_RL_OFF_DELAY_FLAG(*reg);
		}else
		{
			CLEAR_RL_ON_DELAY_FLAG(*reg);
			SET_RL_OFF_DELAY_FLAG(*reg);
		}
	}else 
	{
		 if(status)
		 {
			 CLEAR_RL_ON_DELAY_FLAG(*reg);
			 CLEAR_RL_OFF_DELAY_FLAG(*reg);
		 }else
		 {
			 CLEAR_RL_ON_DELAY_FLAG(*reg);
			 CLEAR_RL_OFF_DELAY_FLAG(*reg);
		 }
	}
	SET_RL_ORDER_FLAG(*reg);
}