SmartPDCode/truing_control/PDU-3-ADA/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)
{
#if 0
	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));
	}
#endif
}


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

		if(device != board->md_data.r_data.dev_info)
		{
			//default write eeprom
			
			board->write_eeprom_page(EEPROM_STATUS_ADDR,(uint8_t *)&board->relay_staging_staus[0],2*RelaySlaveChaNum);
#if SUPPORT_ZERO_CRTL
			board->write_eeprom_page(EEPROM_N_STATUS_ADDR,(uint8_t *)&board->relay_zero_staging_status,2);
#endif
			
			

#if (AC_3_3 || AC_3_4)
			uint8_t count = 1;
			for(uint8_t i = 0; i < RelaySlaveChaNum;i += 3)
			{
				for(int j = 0;j < 3;j++)
				{
					board->md_data.rw_data.delay_on	[i*3+j]  = 	count;
					board->md_data.rw_data.delay_off[i*3+j]  =  count;
				}
#if SUPPORT_ZERO_CRTL
				board->md_data.rw_data.delay_N_on          = 	count;
				board->md_data.rw_data.delay_N_off         = 	count;
#endif				
				count++;
			}
			board->v_k[0] = 3135;
			board->v_k[1] = 3135;
			board->v_k[2] = 3135;
			board->i_k[0] = 10000;
			board->i_k[1] = 10000;
			board->i_k[2] = 10000;			
			
			board->write_eeprom_page(EEPROM_SET_V_K_ADDR,(uint8_t *)&board->v_k[0], 4*3);
			board->write_eeprom_page(EEPROM_SET_K_I_ADDR,(uint8_t *)&board->i_k[0], 4*3);
			
#else

		for(uint8_t i = 0; i < PT_SUB_COUNT;i++)
		{
			board->md_data.rw_data.delay_on	[i  ]  = 	i+1;
			board->md_data.rw_data.delay_off[i  ]  =  i+1;
			board->md_data.rw_data.delay_on	[i+4]  = 	i+1;
			board->md_data.rw_data.delay_off[i+4]  =  i+1;
		}
			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_SET_V_K_ADDR,(uint8_t *)&board->v_k[0], 4*2);
			board->write_eeprom_page(EEPROM_SET_K_I_ADDR,(uint8_t *)&board->i_k[0], 4*2);
			
#endif			
			board->write_eeprom_page(EEPROM_OTHER_ADDR,(uint8_t *)&board->md_data.rw_data.delay_on[0], sizeof(rw_3_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->write_eeprom_page(EEPROM_DEVICES_ADDR,(uint8_t *)&board->md_data.r_data.dev_info,EEPROM_DEVICES_LENTH);
		}
		{
			//channel open or close
			board->read_eeprom_page(EEPROM_STATUS_ADDR,(uint8_t *)&board->relay_staging_staus[0],2*RelaySlaveChaNum);
#if SUPPORT_ZERO_CRTL
			board->read_eeprom_page(EEPROM_N_STATUS_ADDR,(uint8_t *)&board->relay_zero_staging_status,2);
			{
				if(board->relay_zero_staging_status)
				{
						SET_RL_ON_DELAY_FLAG(board->relay_zero_staging_status);
						CLEAR_RL_OFF_DELAY_FLAG(board->relay_zero_staging_status);
						SET_RL_ORDER_FLAG(board->relay_zero_staging_status);					
				}
			}
#endif
			{
				for(int i =0 ;i < RelaySlaveChaNum;i++)
				{
					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]);
					}
				}
			}

			board->read_eeprom_page(EEPROM_OTHER_ADDR,(uint8_t *)&board->md_data.rw_data.delay_on[0],sizeof(rw_3_data_t));

			#if (AC_3_3 || AC_3_4)
					board->check_threshold(THRESHOLD_IN,0);
			#else
					board->check_threshold(THRESHOLD_IN,0);
			#endif	


#if (AC_3_3 || AC_3_4)
			board->read_eeprom_page(EEPROM_SET_V_K_ADDR,(uint8_t *)&board->v_k[0], 4*3);
			board->read_eeprom_page(EEPROM_SET_K_I_ADDR,(uint8_t *)&board->i_k[0], 4*3);
			for(int i = 0;i < 3;i++)
			{
				//3135 voltage Calibrate value
				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];
			}
#else
			board->read_eeprom_page(EEPROM_SET_V_K_ADDR,(uint8_t *)&board->v_k[0], 4*2);
			board->read_eeprom_page(EEPROM_SET_K_I_ADDR,(uint8_t *)&board->i_k[0], 4*2);
			for(int i = 0;i < 2;i++)
			{
				board->v_k[i] =  board->v_k[i] > 10000 ? 3135 : board->v_k[i];
				board->v_k[i] =  board->i_k[i] > 10000 ? 10000 : board->i_k[i];
			}
#endif			
			
			

			for(uint8_t i = 0 ; i < RelaySlaveChaNum;i++)
			{
				board->check_threshold(THRESHOLD_OUT,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 (SUPPORT_ZERO_CRTL)
			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_N_STATUS_ADDR;
				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);
}