lyn-stc_ttss_868/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()
{
	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*)&R.p,(U8*)eep_param.buf,sizeof(R.p));//防止dlen>sizeof(G.P)引起的内存错误
		}
	}
}

void L3_eeprom_persist_param()
{
	U8 dlen = sizeof(R.p);
	eep_param.filter = EEPROM_PARAM_FILTER;
	eep_param.len = dlen + 2;
	Lc_buf_copy_uc((U8*)eep_param.buf,(U8*)&R.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);
}

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;
}

void L3_param_init(void)
{
	int i;
	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(R.p.weight_std[i].weight_range == 0 || (R.p.weight_std[i].weight_range * 100) >= weight)
		{
			break;
		}
	}
	if(i<D_weight_std_num && R.p.weight_std[i].ratio != 0)
	{
		ratio = R.p.weight_std[i].ratio;
	}
	return (S32)(weight * 1.0 * ratio / 100) ;
}

#if 0
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;
}

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;
}
#endif