stc_ttss_weight/source/app/common.c

#include "common.h"
//#include "../tpc/tpc_uart.h"
#include "../bsp/bsp_cs1232.h"
#include "../msp/msp_eeprom.h"
#include "../msp/msp_id.h"

struct global_param G;
struct ts_eeprom_param eep_param;
struct ts_eeprom_enc eep_enc;

#define EEP_SECTOR_SIZE 0x200
#define EEP_PARAM_ADDR (EEP_SECTOR_SIZE * 1)
#define EEP_ENC_ADDR (EEP_SECTOR_SIZE * 0)

void L3_eeprom_read_param()
{
#if 0
	U8 dlen = 0;
	L0_Iap_Read_array(EEP_PARAM_ADDR, (U8*)&eep_param, 2 + EEPROM_PARAM_DATA_MAX + 2);
	if(eep_param.filter == EEPROM_PARAM_FILTER)
	{
		dlen = eep_param.len - 2;
		crc16(eep_param.crc,(U8*)&eep_param,2+dlen);
		if(eep_param.crc[0] == eep_param.buf[dlen] && eep_param.crc[1] == eep_param.buf[dlen+1])
		{
			L0_uart0_uc('#');
			//Lc_buf_copy_uc((U8*)&G.p,(U8*)eep_param.buf,dlen);
			Lc_buf_copy_uc((U8*)&G.p,(U8*)eep_param.buf,sizeof(G.p));//防止dlen>sizeof(G.P)引起的内存错误
		}
	}
#endif
	if(L1_eep_read_block(D_EEP_PARAM_IN_SECTOR, D_EEP_PARAM_IN_BLOCK, D_EEP_PARAM_BLOCK_SIZE, (U8*)&G.p, NULL) == 0)
	{
		//L0_uart0_sendstr("e2p read success");
		return;
	}
	//L0_uart0_sendstr("e2p read failed");
}

void L3_eeprom_persist_param()
{
#if 0
	U8 dlen = sizeof(G.p);
	eep_param.filter = EEPROM_PARAM_FILTER;
	eep_param.len = dlen + 2;
	Lc_buf_copy_uc((U8*)eep_param.buf,(U8*)&G.p,dlen);
	crc16(eep_param.crc, &eep_param, 2+dlen);
	eep_param.buf[dlen] = eep_param.crc[0];
	eep_param.buf[dlen+1] = eep_param.crc[1];
	
	L0_Iap_Erase(EEP_PARAM_ADDR);
	L0_Iap_Program_array(EEP_PARAM_ADDR, (U8*)&eep_param, 2 + dlen + 2);
#endif
	if(L1_eep_write_block(D_EEP_PARAM_IN_SECTOR, D_EEP_PARAM_IN_BLOCK, D_EEP_PARAM_BLOCK_SIZE, (U8*)&G.p,sizeof(G.p),TRUE) == 0)
	{
		//L0_uart0_sendstr("e2p write success"); 
		return;
	}
	//L0_uart0_sendstr("e2p write failed"); 
}

#if 0
int L3_mcu_id_ok(void)
{
	U8 i = 0,crc[2];
	U32 enc_key;
	//1.获取MCU_ID
	L0_id_get_rom(G.e.mcu_id);
	for(i=0;i<MCU_ID_LEN;i++)
	{
		L0_uart0_uchex(G.e.mcu_id[i]);
	}
	
	//2.读取eeprom中的加密信息
	L0_Iap_Read_array(EEP_ENC_ADDR, (U8*)&eep_enc, MCU_ID_KEY_LEN + MCU_ID_LEN + 2);
	crc16(crc,(U8*)&eep_enc,MCU_ID_KEY_LEN + MCU_ID_LEN);
	if(eep_enc.crc[0] != crc[0] || eep_enc.crc[1] != crc[1])
	{
		L0_uart0_uc('-');
		return 0;
	}
	
	//3.根据mcu_id和enc_key计算enc_val
	enc_key = ((U32)eep_enc.enc_key[0] << 24) | (eep_enc.enc_key[1] << 16) | (eep_enc.enc_key[2] << 8) |(eep_enc.enc_key[3] << 0);
	Lc_encrypt_id((U8*)G.e.mcu_enc_id, (U8*)G.e.mcu_id, enc_key, MCU_ID_LEN);
	
	//4.判断enc_val是否一致
	for(i=0;i<MCU_ID_KEY_LEN;i++)
	{
		if(G.e.mcu_enc_id[i] != eep_enc.enc_val[i])
		{
			return 0;
		}
	}
	return 1;
}

#else

/**
 *
 * @brief:  eeprom的D_EEP_ENC_IN_SECTOR、D_EEP_ENC_IN_BLOCK中提前存放了加密信息: enc_key, enc_val(enc_key+chipid计算所得)
 * @param:  void
 * @return: 1 is ok , 0 is failed
 *
 */
int L3_mcu_id_ok(void)
{
	U8 i = 0;

	//1. 获取eeprom中存储的enc信息
	if(L1_eep_read_block(D_EEP_ENC_IN_SECTOR, D_EEP_ENC_IN_BLOCK, D_EEP_ENC_BLOCK_SIZE, (U8*)&eep_enc,NULL) == 1)
	{
		//L0_uart0_sendstr("e2p read enc failed"); 
		return 0;
	}
	//L0_uart0_sendstr("e2p read enc success"); 	

	//2.获取MCU_ID
	L0_id_get_rom(G.e.mcu_id);
	//L0_uart0_sendArray(enc_info.mcu_id,MCU_ID_LEN);

	//3.根据mcu_id和enc_key计算enc_val
	//enc_key = ((U32)eep_enc.enc_key[0] << 24) | (eep_enc.enc_key[1] << 16) | (eep_enc.enc_key[2] << 8) |(eep_enc.enc_key[3] << 0);
	Lc_encrypt_id1((U8*)G.e.mcu_enc_id, (U8*)G.e.mcu_id, eep_enc.enc_key, MCU_ID_LEN);
		
	//4.判断enc_val是否一致
	for(i=0;i<MCU_ID_KEY_LEN;i++)
	{
		if(G.e.mcu_enc_id[i] != eep_enc.enc_val[i])
		{
			return 0;
		}
	}
	return 1;
}
#endif


void L3_reg_reset()
{
	U8 i = 0;
	//G.p.reset = 0;
	G.p.adc_ch_status = ADC_status_ch2_Ready | ADC_status_ch3_Ready | ADC_status_ch4_Ready;		//修改采集通道
	G.p.slaver_id = P485_SLAVER_ID;	
	//G.p.zero = 0;
	G.p.weight_max = 500;	//500kg
	G.p.lmd = 2;	//2mv/v
	
	G.p.cc_blur_ch_avg = 6;
	G.p.cc_blur_ch_shift = 2;
	G.p.cc_blur_all_shift0 = 2;
	G.p.cc_blur_all_shift1 = 4;
	G.p.cc_blur_all_out_d_threshold = 200;	//0.2kg
	G.p.cc_blur_all_out_dd_threshold = 200;	//0.2kg

	for(i=0;i<D_weight_show_limit_num;i++)
	{
		G.p.weight_show_limit[i].weight = 0;
		G.p.weight_show_limit[i].times = 0;
	}
	G.p.weight_show_limit[0].weight = 300;	//0.3kg
	G.p.weight_show_limit[0].times = 1;
	G.p.weight_show_limit[1].weight = 200;	//0.2kg
	G.p.weight_show_limit[1].times = 9;
	G.p.weight_show_limit[2].weight = 100;	//0.1kg
	G.p.weight_show_limit[2].times = 18;
	G.p.weight_show_limit[3].weight = 50;	//0.05kg
	G.p.weight_show_limit[3].times = 18;
	G.p.weight_show_limit[4].weight = 20;	//0.02kg
	G.p.weight_show_limit[4].times = 30;
	
	for(i=0;i<D_weight_std_num;i++)
	{
		G.p.weight_std[i].weight_range = 0;
		G.p.weight_std[i].ratio = 0;
	}
}

void L3_reg_init(void)
{
	U8 i = 0;
	G.reserved1 = G.reserved2 = G.reserved3 = 0x55;
	G.total_weight = G.total_zweight = 0;

	L3_reg_reset();

	for(i=0;i<D_ch_max_num;i++)
	{
		G.weight[i] = 0;
	}
	G._total_weight = 0;
	G._total_zweight = 0;
	
	L3_eeprom_read_param();
}

S32 L3_count_std_weight(S32 weight)
{
	U8 i = 0;
	U16 ratio = 100;
	weight = (weight - G._total_zweight)/10;
	for(i=0;i<D_weight_std_num;i++)
	{
		if(G.p.weight_std[i].weight_range == 0 || (G.p.weight_std[i].weight_range * 100) >= weight)
		{
			break;
		}
	}
	if(i<D_weight_std_num && G.p.weight_std[i].ratio != 0)
	{
		ratio = G.p.weight_std[i].ratio;
	}
	return (S32)(weight * 1.0 * ratio / 100) ;
}

U8 L3_pack_PH4(TS_PH4_modbus *pmodbus ,U8 oper, void *buf,U8 bufsize)
{
	pmodbus->salver = G.p.slaver_id;
	pmodbus->oper = oper;
	Lc_buf_copy_uc(pmodbus->buf,buf,bufsize);
	crc16(pmodbus->crc,&pmodbus->salver,2 + bufsize);
	pmodbus->buf[bufsize] = pmodbus->crc[0];
	pmodbus->buf[bufsize + 1] = pmodbus->crc[1];

	return bufsize + 2 + 2;
}

int L3_ph4_send_error_pkg(U8 errcode)
{
	TS_PH4_modbus modbusack;
	U8 modbuslen = 0;
	ModbusErrAck modbusErrAck;
	modbusErrAck.errcode = errcode;

	modbuslen = L3_pack_PH4(&modbusack, MODBUS_OPER_ERR, &modbusErrAck, sizeof(modbusErrAck));
	L0_uart0_sendArray((U8*)&modbusack, modbuslen);
	return 0;
}


TS_PH4_modbus modbusack;
Modbus03 modbus03;
Modbus03Ack modbus03Ack;
Modbus06 modbus06;
Modbus06Ack modbus06Ack;
Modbus10 modbus10;
Modbus10Ack modbus10Ack;


int L3_ph4_common_handler(TS_PH4_modbus *pmodbus)
{
	U8 handlerStatus = TP_HANDLED, modbuslen = 0;
	switch(pmodbus->oper)
	{
	case 0x03:
	{
		U16 i = 0,j = 0,regval = 0;
		modbus03.reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]);
		modbus03.num = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]);
		if((modbus03.num < 5) && (modbus03.reg < sizeof(G)/2))	//每次最多读取4个寄存器 8个字节，以防止越界
		{
			for(i=0; i<modbus03.num; i++)
			{
				regval = *(REG_2_MEM(modbus03.reg + i));
				modbus03Ack.buf[j++] = regval >> 8 & 0xFF;
				modbus03Ack.buf[j++] = regval & 0xFF;
			}
			modbus03Ack.bytes = modbus03.num * 2;
			modbuslen = L3_pack_PH4(&modbusack, 0x03, &modbus03Ack, modbus03Ack.bytes + 1);
			L0_uart0_sendArray((U8*)&modbusack, modbuslen);
		}
		break;
	}
	case 0x06:
	{	
		modbus06.reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]);
		modbus06.val = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]);
		if(modbus06.reg < sizeof(G)/2)
		{
			if(modbus06.reg == MEM_2_REG(&G.p.zero))
			{  
			    G._total_zweight = G._total_weight;
				G.total_zweight = G._total_zweight/10;
				G.total_weight = 0;
			}
			else if(modbus06.reg == MEM_2_REG(&G.p.reset))
			{
				L3_reg_reset();
			}
			else
			{
				*(REG_2_MEM(modbus06.reg)) = modbus06.val;
			}
			modbus06Ack.reg = modbus06.reg;
			modbus06Ack.val = *(REG_2_MEM(modbus06.reg));
			modbuslen = L3_pack_PH4(&modbusack, 0x06, &modbus06Ack, 4);
			L0_uart0_sendArray((U8*)&modbusack, modbuslen);
		}
	
		//重新计算重量
		G.total_weight = L3_count_std_weight(G._total_weight);
		
		//持久化
		if(modbus06.reg > MEM_2_REG(&G.reserved2) && modbus06.reg < MEM_2_REG(&G.reserved3))
		{
			L3_eeprom_persist_param();
		}
		break;
	}
	case 0x10:
	{
		U16 i = 0,j = 0,regval = 0;
		modbus10.reg = ((U16)pmodbus->buf[0]) << 8 | ((U16)pmodbus->buf[1]);
		modbus10.num = ((U16)pmodbus->buf[2]) << 8 | ((U16)pmodbus->buf[3]);
		modbus10.count = pmodbus->buf[4];
		if((modbus10.num < 21) && (modbus10.reg < sizeof(G)/2))	//每次最多写入20个寄存器 40个字节，以防止越界
		{
			for(i=0; i<modbus10.num; i++)
			{
				regval = ((U16)pmodbus->buf[5+i*2]) << 8 | ((U16)pmodbus->buf[5+i*2+1]);
				*(REG_2_MEM(modbus10.reg + i)) = regval;
			}
			modbus10Ack.reg = modbus10.reg;
			modbus10Ack.num = modbus10.num;
			modbuslen = L3_pack_PH4(&modbusack, 0x10, &modbus10Ack, 4);
			L0_uart0_sendArray((U8*)&modbusack, modbuslen);
		}

		//重新计算重量
		G.total_weight = L3_count_std_weight(G._total_weight);
		
		//持久化
		if(modbus10.reg > MEM_2_REG(&G.reserved2) && modbus10.reg < MEM_2_REG(&G.reserved3))
		{
			L3_eeprom_persist_param();
		}
		break;
	}
	default:
		//L3_ph4_send_error_pkg(MODBUS_ERR_OPCODE);
		break;
	}
    return handlerStatus;
}