/*
*********************************************************************************************************
*                                       IAR Development Kits
*                                              on the
*
*                                    M451
*
* Filename      : spi_adc.c
* Version       : V1.00
* Programmer(s) : Qian Xianghong
*********************************************************************************************************
*/

#include  "includes.h"

// 默认为斯达易思的流量计
//
// 是否SMAR  C的流量计
//#define _SMARC_FLOWMETER_
// 是否天信流量计（MODBUS/A4协议）
//#define _TIANCYA4_FLOWMETER_

// 定义中断处理的回到函数
typedef void (*RS485_Read_CallBack)(uint8_t c);
RS485_Read_CallBack RS485_Read = NULL;

#define RS485_EN PC7

const uint8_t  VACUUM_ID[] = {1, 2};	// 真空计通信地址
#define VACUUM_CMD	4					// 真空计读取命令
#define VACUUM_ADDR	608					// 真空计起始寄存器地址
#define VACUUM_LEN	8					// 真空计读取寄存器个数

const uint8_t LEAK_ID = 3;				// 泄露报警控制器通信地址
#define LEAK_CMD	3					// 泄露报警控制器读取命令
#define LEAK_ADDR	0x08				// 泄露报警控制器起始寄存器地址
#define LEAK_LEN	8					// 泄露报警控制器读取寄存器个数

const uint8_t FLOW_ID = 4;				// 流量计通信地址
#if defined(_SMARC_FLOWMETER_)
	#define FLOW_CMD	3					// 流量计读取命令
	#define FLOW_ADDR	4068				// 流量计起始寄存器地址
	#define FLOW_LEN	12					// 流量计读取寄存器个数
#elif defined(_TIANCYA4_FLOWMETER_)
	#define FLOW_CMD	3					// 流量计读取命令
	#define FLOW_ADDR	0					// 流量计起始寄存器地址
	#define FLOW_LEN	12					// 流量计读取寄存器个数
#else
	#define FLOW_CMD	3					// 流量计读取命令
	#define FLOW_ADDR	0					// 流量计起始寄存器地址
	#define FLOW_LEN	15					// 流量计读取寄存器个数
#endif

#pragma pack(push, 1)
typedef struct
{
	uint8_t id;
	uint8_t cmd;
	uint16_t addr;
	uint16_t len;
	uint16_t crc;
} modbus_send_t;

typedef struct
{
	struct
	{
		uint8_t id;
		uint8_t cmd;
		uint8_t len;
	} header;
	union{
		// 真空计数据
		struct
		{
			uint16_t staVacuum;		// 状态
			uint16_t lifeVacuum;	// 使用年限
			uint32_t vacuum;		// 真空度，float型，先用整形交换字节序
			uint32_t rateVacuum;	// 漏放气速率，float型，先用整形交换字节序
			uint32_t tempr;			// 温度，float型，先用整形交换字节序
		} vacuum;
		
		// 泄漏报警器数据
		struct
		{
			unsigned unit :	 4;			// 气体单位
			unsigned ratio : 4;			// 数值单位
			uint8_t type;				// 气体类型
			uint16_t	A1;				// A1报警值
			uint16_t	A2;	
			uint16_t	A3;	
			uint16_t	A4;	
			uint16_t	range;			// 量程
			uint16_t	concentrations;	// 浓度
			uint8_t	staLeak;			// 传感器状态
			unsigned : 8;
		} leak;

		// 流量计数据
		struct
		{
			uint32_t nM3_int;	// 标况累积总量整数部分
			uint16_t nM3_frac;	// 标况累积总量小数部分（放大10000倍）
			uint32_t M3_int;	// 工况累积总量整数部分
			uint16_t M3_frac;	// 工况累积总量小数部分（放大10000倍）
			uint32_t nM3_h;		// 标况流量（nM3/h，放大100倍）
			uint32_t M3_h;		// 工况流量（M3/h，放大100倍）
			int16_t	tempr;		// 温度（℃，放大10倍，第一位正负位(即数值大于0x7FFF为负)）
			uint32_t pressure;	// 压力(绝压）（KPa, 放大10倍)
			uint16_t err1;		// 异常标志位1
								//温度错误标志位: 0x0003
								//压力错误标志位: 0x0030
								//电池电量低标志位: 0x0300
								//工况流量超最大工况流量: 0x3000
								//无异常：0x0000
			uint16_t err2;		// 异常标志位2
								//存储器异常标志位: 0x0003
								//无异常：0x0000
		} flow;
		
		// SMARC流量计数据
		struct
		{
			uint32_t nM3_h;		// 标况流量: float, 方便颠倒顺序，用uint32_t型接收
			uint32_t M3_h;		// 工况流量: float, 方便颠倒顺序，用uint32_t型接收
			uint32_t tempr;		// 温度: float, 方便颠倒顺序，用uint32_t型接收
			uint32_t pressure;	// 压力: float, 方便颠倒顺序，用uint32_t型接收
			uint16_t warnFlag;	// 报警标志
			uint8_t nM3_BCD[6];	// 标况体积
		} flow_SMARC;

		// 天信流量计数据（Modbus/A4通信协议）
		struct
		{
			double nM3;			// 标况体积
			uint32_t nM3_h;		// 标况流量: float, 方便颠倒顺序，用uint32_t型接收
			uint32_t M3_h;		// 工况流量: float, 方便颠倒顺序，用uint32_t型接收
			uint32_t tempr;		// 温度: float, 方便颠倒顺序，用uint32_t型接收
			uint32_t pressure;	// 压力: float, 方便颠倒顺序，用uint32_t型接收
		} flow_TancyA4;
	};
	uint16_t crc;	// 占位置
} modbus_recv_t;

typedef union
{
	modbus_send_t send;
	modbus_recv_t recv;
	uint8_t buff[sizeof(modbus_recv_t)];
} modbus_comm_t;

// DYQ-7通信协议的泄露报警器
#define RS_MIN_FRAME_LEN	(15)
#define RS_MAX_FRAME_LEN	(39)
#define RS_MIN_DATA_LEN		(0)
#define RS_MAX_DATA_LEN		(RS_MAX_FRAME_LEN - RS_MIN_FRAME_LEN)

#define RS_FRAME_SOF		(0x1B)	// 标识一个帧的开始

#define RS_DIR_M2S			(0)		// Master->Slave
#define RS_DIR_S2M			(1)		// Slave->Master

#define RS_PROTOCOL_VER_1	(1)

// 请求命令
#define RS_CMD_READ_DATA	(5)		// 读采集数据
// 处理结果
#define RS_RESULT_SUCC		(0)		// 处理成功
#define RS_RESULT_FAIL		(-1)	// 处理失败

// 通信协议版本
const uint8_t RS_PROTOCOL_VER = RS_PROTOCOL_VER_1;	

// 485泄露报警器请求数据
typedef struct	// size = RS_MAX_FRAME_LEN
{
	uint8_t		sof;				// RS_FRMAE_SOF
	uint8_t		len;				// bytes from sof to crc（RS_MIN_FRAME_LEN~RS_MAX_FRAME_LEN）
	uint8_t		destAddr;
	uint8_t		srcAddr;
	uint8_t		srcPSN[6];
	uint8_t		dir;
	uint8_t		protocol_ver;		// RS_PROTOCOL
	uint8_t		cmd;
	uint8_t		data[RS_MAX_DATA_LEN];
	uint16_t	crc;				// 占位置，实际crc可能更靠前
} rs_frame_t;

// 485泄露报警器应答数据
typedef struct // size = 20
{
	uint16_t	adc;			// 采集ADC值
	float		measureValue;	// 采集值
	uint8_t		measureState;	// 测量值状态
	uint16_t	levelHeight;	// 液位高度
	uint16_t	volume;			// 剩余液量
	uint16_t	volumeMax;		// 有效容积
	uint16_t	quality;		// 剩余重量
	uint8_t		warnState;		// 报警状态
	uint16_t	envAdc;			// 环境温度ADC
	int16_t		envTempr;		// 环境温度
} rs_data_t;

#pragma pack(pop)

rs_frame_t RS_TranFrame;

modbus_comm_t modbus;
uint8_t modbus_idx = 0;
uint8_t vaccum_idx = 0;
data_sample_t *modbus_sample;

// MODBUS的CRC算法
uint16_t MODBUS_RTU_CRC16(const uint8_t *puchMsg, uint16_t usDataLen)
{
    uint16_t crc = 0xFFFF;
	uint8_t i;
	while (usDataLen--)   // 传输消息缓冲区
    {
        crc ^= *puchMsg++;
        for(i = 0; i < 8; i++)
        {
            if(crc & 0x0001)
            {
                crc >>= 1;
                crc ^= 0xA001;
            }
            else
            {
                crc >>= 1;
            }
        }
    }

    // 交换高低字节顺序
    return ((crc & 0xFF) << 8) | ((crc >> 8) & 0xFF);
}

// 将十进制转换成BCD
void dec2bcd(uint32_t dec, uint8_t *bcd, uint8_t len)
{
	char fmt[10], str[20];
	uint8_t i;
	
	// 生成格式串（如：%010u）
	sprintf(fmt, "%%0%du", len * 2);
	// 将dec值转换成前面补0的字符串（如：000000123456)
	sprintf(str, fmt, dec);
	// 转换
	for(i = 0; i < strlen(str); i += 2)
	{
		bcd[i / 2] = ((str[i] - '0') << 4) | (str[i + 1] - '0');
	}
}

// 本函数由规管设计者（Zhang Jm）提供，用于对读出的真空值进行修正
// 本函数只适用于规管量程为-2（0.01Pa）的情况
/**
  * @brief  Function of Fuzzy Processing.
  * @param  value: vacuun value.
  * @retval None.
  */
float Mode1_Fuzzy_Process(float value)
{
  static const float beta1 = -0.2539755;
  static const float beta2 = 13.15659; 
  
  static const float theta = 0.011666666;
  static const float eta = 0.9999999;
  static const float kappa = 0.006666666;  
  float temp1, temp2, result, lower_t = 0.0101;  
  
  if((value < 0.09f) && (value > 0.04f))
  {  
    temp1 = -beta1 * value;
    temp2 = beta2 * pow(value, 2.0); 
    return(1 - exp(temp1 - temp2));
  }
  else if((value <= 0.04f) && (value > 0.005f))
  {/*y = theta*x^eta/(kappa^eta+x^eta)*/
    temp1 = pow(value, eta);
    temp2 = pow(kappa, eta) + temp1;
    result = theta * temp1 / temp2;
    if(result < lower_t)
      return(lower_t);
    else
      return(result); 
  }
  else
    return(value);
}

void Modbus_Read(uint8_t c)
{
	uint8_t i;
	uint32_t reversed;
	int32_t i_reversed;
	float f;
	uint8_t d_reversed[8];
	double d;

    /* Receive data */
	if(modbus_idx < sizeof(modbus_recv_t))
	{
		modbus.buff[modbus_idx++] = c;
		
		if(modbus.recv.header.id == LEAK_ID && modbus.recv.header.cmd == LEAK_CMD 
				&& modbus.recv.header.len == sizeof(modbus.recv.leak) 
				&& modbus_idx == sizeof(modbus.recv.header) + sizeof(modbus.recv.leak) + sizeof(modbus.recv.crc)
				&& MODBUS_RTU_CRC16(modbus.buff, modbus_idx) == 0)
		{
			/* Print the received data */
//			printf("Received data:\n");
//			for(i = 0; i < modbus_idx; i++)
//			{
//				printf("%02X ", modbus.buff[i]);
//			}
//			printf("\n");

			// 探测器状态
			modbus_sample->leak.staLeak = modbus.recv.leak.staLeak;
			// 浓度
			modbus_sample->leak.concentrations = ntohs(modbus.recv.leak.concentrations);
			if(modbus.recv.leak.ratio == 1)
				modbus_sample->leak.concentrations /= 10;
			else if(modbus.recv.leak.ratio == 2)
				modbus_sample->leak.concentrations /= 100;
			else if(modbus.recv.leak.ratio == 3)
				modbus_sample->leak.concentrations /= 1000;
			
			NVIC_SetPendingIRQ(TMR1_IRQn);
		}
		else if(modbus.recv.header.id == VACUUM_ID[vaccum_idx] && modbus.recv.header.cmd == VACUUM_CMD 
				&& modbus.recv.header.len == sizeof(modbus.recv.vacuum)
				&& modbus_idx == sizeof(modbus.recv.header) + sizeof(modbus.recv.vacuum) + sizeof(modbus.recv.crc)
				&& MODBUS_RTU_CRC16(modbus.buff, modbus_idx) == 0)
		{
			/* Print the received data */
			printf("Received data:\n");
			for(i = 0; i < modbus_idx; i++)
			{
				printf("%02X ", modbus.buff[i]);
			}
			printf("\n");

			// 传感器状态
			modbus_sample->vacuum[vaccum_idx].staVacuum = ntohs(modbus.recv.vacuum.staVacuum);
			// 使用年限
			modbus_sample->vacuum[vaccum_idx].lifeVacuum = ntohs(modbus.recv.vacuum.lifeVacuum);
			// 真空度
			reversed = ntohl(modbus.recv.vacuum.vacuum);
			memmove(&modbus_sample->vacuum[vaccum_idx].vacuum, &reversed, sizeof(modbus_sample->vacuum[vaccum_idx].vacuum));
			// 调用真空值修正函数（2021.11.03）
			modbus_sample->vacuum[vaccum_idx].vacuum = Mode1_Fuzzy_Process(modbus_sample->vacuum[vaccum_idx].vacuum);
			// 漏放气速率
			reversed = ntohl(modbus.recv.vacuum.rateVacuum);
			memmove(&modbus_sample->vacuum[vaccum_idx].rateVacuum, &reversed, sizeof(modbus_sample->vacuum[vaccum_idx].rateVacuum));
			// 温度
			reversed = ntohl(modbus.recv.vacuum.tempr);
			memmove(&modbus_sample->vacuum[vaccum_idx].tempr, &reversed, sizeof(modbus_sample->vacuum[vaccum_idx].tempr));

			NVIC_SetPendingIRQ(TMR1_IRQn);
		}		
#if defined(_SMARC_FLOWMETER_)
		else if(modbus.recv.header.id == FLOW_ID && modbus.recv.header.cmd == FLOW_CMD 
				&& modbus.recv.header.len == sizeof(modbus.recv.flow_SMARC)
				&& modbus_idx == sizeof(modbus.recv.header) + sizeof(modbus.recv.flow_SMARC) + sizeof(modbus.recv.crc)
				&& MODBUS_RTU_CRC16(modbus.buff, modbus_idx) == 0)
		{
//			/* Print the received data */
//			printf("Received data:\n");
//			for(i = 0; i < modbus_idx; i++)
//			{
//				printf("%02X ", modbus.buff[i]);
//			}
//			printf("\n");

			// 标况体积总量
			// 整数部分
			reversed = 0;
			for(i = 0; i < 9; i++)
			{
				reversed *= 10;
				if(i % 2 == 0)
					reversed += (modbus.recv.flow_SMARC.nM3_BCD[i / 2] >> 4);
				else
					reversed += (modbus.recv.flow_SMARC.nM3_BCD[i / 2] & 0x0F);
			}
			dec2bcd(reversed, modbus_sample->flow.nM3, 5);
			// 小数部分
			reversed = 0;
			for(i = 9; i < 11; i++)
			{
				reversed *= 10;
				if(i % 2 == 0)
					reversed += (modbus.recv.flow_SMARC.nM3_BCD[i / 2] >> 4);
				else
					reversed += (modbus.recv.flow_SMARC.nM3_BCD[i / 2] & 0x0F);
			}
			dec2bcd(reversed, modbus_sample->flow.nM3 + 5, 1);
			// 标况流量
			reversed = ntohl(modbus.recv.flow_SMARC.nM3_h);
			memmove(&f, &reversed, 4);
			reversed = f * 100;
			dec2bcd(reversed, modbus_sample->flow.nM3_h, 4);
			// 工况流量
			reversed = ntohl(modbus.recv.flow_SMARC.M3_h);
			memmove(&f, &reversed, 4);
			reversed = f * 100;
			dec2bcd(reversed, modbus_sample->flow.M3_h, 4);			
			// 温度
			reversed = ntohl(modbus.recv.flow_SMARC.tempr);
			memmove(&f, &reversed, 4);
			i_reversed = f * 100;
			if(i_reversed >= 0)
				dec2bcd(i_reversed, modbus_sample->flow.tempr, 4);			
			else
			{
				dec2bcd(-i_reversed, modbus_sample->flow.tempr, 4);
				modbus_sample->flow.tempr[0] = 0x80;				
			}			
			// 压力
			reversed = ntohl(modbus.recv.flow_SMARC.pressure);
			memmove(&f, &reversed, 4);
			reversed = f * 100;
			dec2bcd(reversed, modbus_sample->flow.pressure, 4);			
			
			/* Print the converted bcd data */
			printf("Flowmeter BCD data:\n");
			for(i = 0; i < sizeof(modbus_sample->flow); i++)
			{
				printf("%02X ", *(((uint8_t *) &modbus_sample->flow) + i));
			}
			printf("\n");
			
			NVIC_SetPendingIRQ(TMR1_IRQn);
		}
#elif defined(_TIANCYA4_FLOWMETER_)
		else if(modbus.recv.header.id == FLOW_ID && modbus.recv.header.cmd == FLOW_CMD 
				&& modbus.recv.header.len == sizeof(modbus.recv.flow_TancyA4)
				&& modbus_idx == sizeof(modbus.recv.header) + sizeof(modbus.recv.flow_TancyA4) + sizeof(modbus.recv.crc)
				&& MODBUS_RTU_CRC16(modbus.buff, modbus_idx) == 0)
		{
//			/* Print the received data */
//			printf("Received data:\n");
//			for(i = 0; i < modbus_idx; i++)
//			{
//				printf("%02X ", modbus.buff[i]);
//			}
//			printf("\n");

			// 标况体积总量: double型, 先颠倒顺序
			memmove(d_reversed, &modbus.recv.flow_TancyA4.nM3, 8);
			i = d_reversed[0];
			d_reversed[0] = d_reversed[7];
			d_reversed[7] = i;
			i = d_reversed[1];
			d_reversed[1] = d_reversed[6];
			d_reversed[6] = i;
			i = d_reversed[2];
			d_reversed[2] = d_reversed[5];
			d_reversed[5] = i;
			i = d_reversed[3];
			d_reversed[3] = d_reversed[4];
			d_reversed[4] = i;
			memmove(&d, &d_reversed, 8);
			// 整数部分
			reversed = (uint32_t) d;
			dec2bcd(reversed, modbus_sample->flow.nM3, 5);
			// 小数部分
			reversed = (uint32_t) ((d - reversed) * 100);
			dec2bcd(reversed, modbus_sample->flow.nM3 + 5, 1);
			
			// 标况流量
			reversed = ntohl(modbus.recv.flow_TancyA4.nM3_h);
			memmove(&f, &reversed, 4);
			reversed = f * 100;
			dec2bcd(reversed, modbus_sample->flow.nM3_h, 4);
			// 工况流量
			reversed = ntohl(modbus.recv.flow_TancyA4.M3_h);
			memmove(&f, &reversed, 4);
			reversed = f * 100;
			dec2bcd(reversed, modbus_sample->flow.M3_h, 4);			
			// 温度
			reversed = ntohl(modbus.recv.flow_TancyA4.tempr);
			memmove(&f, &reversed, 4);
			i_reversed = f * 100;
			if(i_reversed >= 0)
				dec2bcd(i_reversed, modbus_sample->flow.tempr, 4);			
			else
			{
				dec2bcd(-i_reversed, modbus_sample->flow.tempr, 4);
				modbus_sample->flow.tempr[0] = 0x80;				
			}			
			// 压力
			reversed = ntohl(modbus.recv.flow_TancyA4.pressure);
			memmove(&f, &reversed, 4);
			reversed = f * 100;
			dec2bcd(reversed, modbus_sample->flow.pressure, 4);			
			
			/* Print the converted bcd data */
			printf("Flowmeter BCD data:\n");
			for(i = 0; i < sizeof(modbus_sample->flow); i++)
			{
				printf("%02X ", *(((uint8_t *) &modbus_sample->flow) + i));
			}
			printf("\n");
			
			NVIC_SetPendingIRQ(TMR1_IRQn);
		}
#else
		else if(modbus.recv.header.id == FLOW_ID && modbus.recv.header.cmd == FLOW_CMD 
				&& modbus.recv.header.len == sizeof(modbus.recv.flow)
				&& modbus_idx == sizeof(modbus.recv.header) + sizeof(modbus.recv.flow) + sizeof(modbus.recv.crc)
				&& MODBUS_RTU_CRC16(modbus.buff, modbus_idx) == 0)
		{
//			/* Print the received data */
//			printf("Received data:\n");
//			for(i = 0; i < modbus_idx; i++)
//			{
//				printf("%02X ", modbus.buff[i]);
//			}
//			printf("\n");

			// 标况体积总量（BCD码，放大100倍）
			if((htons(modbus.recv.flow.err2) & 0x000F) == 0x0003)			// 是否存储器错误？
				dec2bcd(0, modbus_sample->flow.nM3, 6);
			else
			{
				reversed = ntohl(modbus.recv.flow.nM3_int);			// 整数部分
				dec2bcd(reversed, modbus_sample->flow.nM3, 5);
				reversed = ntohs(modbus.recv.flow.nM3_frac);		// 小数部分
				reversed /= 100;									// 放大10000倍->放大100倍
				dec2bcd(reversed, modbus_sample->flow.nM3 + 5, 1);
			}
			// 标况流量（BCD码，放大100倍）
			reversed = ntohl(modbus.recv.flow.nM3_h);
			dec2bcd(reversed, modbus_sample->flow.nM3_h, 4);			
			// 工况流量（BCD码，放大100倍）
			reversed = ntohl(modbus.recv.flow.M3_h);
			dec2bcd(reversed, modbus_sample->flow.M3_h, 4);			
			// 温度（BCD码，放大100倍，第一字节为符号： 80H 为负，00H 为正）
			if((htons(modbus.recv.flow.err1) & 0x000F) == 0x0003) 		// 是否温度传感器错误？
				i_reversed = 0;
			else
			{
				i_reversed = ntohs(modbus.recv.flow.tempr);
				i_reversed *= 10;								// 放大10倍->放大100倍
			}
			if(i_reversed >= 0)
				dec2bcd(i_reversed, modbus_sample->flow.tempr, 4);			
			else
			{
				dec2bcd(-i_reversed, modbus_sample->flow.tempr, 4);
				modbus_sample->flow.tempr[0] = 0x80;				
			}			
			// 压力（BCD码，放大100倍）
			if((htons(modbus.recv.flow.err1) & 0x00F0) == 0x0030) 		// 是否压力传感器错误？
				reversed = 0;
			else
			{
				reversed = ntohl(modbus.recv.flow.pressure);
				reversed *= 10;									// 放大10倍->放大100倍
			}
			dec2bcd(reversed, modbus_sample->flow.pressure, 4);			

			/* Print the converted bcd data */
			printf("Flowmeter BCD data:\n");
			for(i = 0; i < sizeof(modbus_sample->flow); i++)
			{
				printf("%02X ", *(((uint8_t *) &modbus_sample->flow) + i));
			}
			printf("\n");
			
			NVIC_SetPendingIRQ(TMR1_IRQn);
		}
#endif
	}
}

// 物理层校验
uint8_t rs_phy_valid(rs_frame_t *frame)
{
	if(frame->protocol_ver != RS_PROTOCOL_VER || frame->dir != RS_DIR_S2M)
	{
		// 物理层校验失败
		return 0;
	}
	return 1;
}

// mac层校验
uint8_t rs_mac_valid(rs_frame_t *frame, uint8_t dir)
{
	if(frame->destAddr != dcBuff.configBottle.addr)
	{
		// mac层校验失败
		return 0;
	}
	return 1;
}

// 初始化帧
void rs_initial_frame(rs_frame_t *frame)
{
	memset((uint8_t *) frame, 0, sizeof(rs_frame_t));
	frame->len = RS_MIN_FRAME_LEN;
}

// 追加负载数据
uint8_t rs_append_data(rs_frame_t *frame, uint8_t *data, uint8_t len)
{
	if(frame->len < RS_MIN_FRAME_LEN || frame->len + len > RS_MAX_FRAME_LEN)
		return 0;
	
	if(len > 0)
		memmove(frame->data + (frame->len - RS_MIN_FRAME_LEN), data, len);
	frame->len += len;
	return 1;
}

// 重新寻找SOF
void RS_SearchSOF(uint8_t *buf, uint16_t fromPos, uint8_t *len)
{
	uint8_t i;
	
	for(i = fromPos; i < *len && buf[i] != RS_FRAME_SOF; i++)
	{
	}
	
	*len -= i;
	memmove(buf, buf + i, *len);
}

// 模块任务主体：处理射频接收数据
void RS_ParseFrame(uint8_t  c)
{
	uint8_t *RS_ModuleData = (uint8_t *) &RS_TranFrame;
	uint16_t i;
	uint8_t frameOk, frameErr;

	uint32_t mask;
	rs_data_t *rsData = (rs_data_t *) (RS_TranFrame.data + sizeof(mask));
	
	if(modbus_idx == 0 && c != RS_FRAME_SOF)
		return;
	
	RS_ModuleData[modbus_idx++] = c;

	do
	{
		frameErr = (modbus_idx >= 2 &&
			(RS_ModuleData[1] < RS_MIN_FRAME_LEN || RS_ModuleData[1] > RS_MAX_FRAME_LEN));
		if(frameErr)
		{
			// 从1开始寻找SOF
			RS_SearchSOF(RS_ModuleData, 1, &modbus_idx);
		}

		frameOk = (modbus_idx >= 2 && RS_ModuleData[1] >= RS_MIN_FRAME_LEN && RS_ModuleData[1] <= RS_MAX_FRAME_LEN
			&& modbus_idx >= RS_ModuleData[1]);
		if(frameOk)
		{
			if(MODBUS_RTU_CRC16(RS_ModuleData, RS_ModuleData[1]) == 0)
			{
				if(rs_phy_valid(&RS_TranFrame) && rs_mac_valid(&RS_TranFrame, RS_DIR_M2S))
				{
					// 收到一帧
					printf("\r\nRS recv %d bytes:\r\n", RS_ModuleData[1]);
					for(i = 0; i < RS_ModuleData[1]; i++)
						printf(" %02X", RS_ModuleData[i]);
					printf("\r\n");
					
					// 处理这一帧
					{
						memmove(&mask, RS_TranFrame.data, 4);
						mask = ntohl(mask);
						if((mask & 0x61000000) == 0x61000000)	// 检查数据掩码
						{
							modbus_sample->leak.typeLeak = LEAK_TYPE_MODBUS;
							if(rsData->measureState > 1) 
								modbus_sample->leak.staLeak = LEAK_STATUS_FAULT;
							else if(rsData->warnState == 4)
								modbus_sample->leak.staLeak = LEAK_STATUS_A2_ALARM;
							else
								modbus_sample->leak.staLeak = LEAK_STATUS_OK;
								
							if(rsData->warnState < 3)
								modbus_sample->leak.concentrations = 0;
							else
							{
								memmove(&mask, &rsData->measureValue, 4);
								mask = ntohl(mask);
								memmove(&rsData->measureValue, &mask, 4);
								modbus_sample->leak.concentrations = rsData->measureValue / 1000;
							}
						}
						
						NVIC_SetPendingIRQ(TMR1_IRQn);
					}
				}
				
				// 继续寻找下一帧
				modbus_idx -= RS_ModuleData[1];
				memmove(RS_ModuleData, RS_ModuleData + RS_ModuleData[1], modbus_idx);
				// 从0开始寻找SOF
				RS_SearchSOF(RS_ModuleData, 0, &modbus_idx);
			}
			else
			{
				// 从1开始寻找SOF
				RS_SearchSOF(RS_ModuleData, 1, &modbus_idx);
			}
		}
	} while(frameOk || frameErr);
}

void SC0_IRQHandler(void)
{
	uint8_t c;
	
	// 接收中断
	if(SCUART_GET_INT_FLAG(SC0, SC_ISR_RDA_IS_Msk) || SCUART_GET_INT_FLAG(SC0, SC_ISR_RTMR_IS_Msk))       /* Rx Ready or Time-out INT*/
    {
		c = SC0->RBR;
		//printf("<%02X>", c);
		if(RS485_Read != NULL)
			RS485_Read(c);
    }
	// 错误中断
    if(SCUART_GET_INT_FLAG(SC0, SC_ISR_TERR_IS_Msk)) 
    {
        SCUART_CLR_INT_FLAG(SC0, SC_ISR_TERR_IS_Msk);
    }
}

void Sensor_Init()
{
    /* Select SC UART module clock source as HXT and UART module clock divider as 1 */
    CLK_SetModuleClock(SC0_MODULE, CLK_CLKSEL2_SC_S_HXT, CLK_SC0_CLK_DIVIDER(1));

    /* Set PA.8 and PA.9 pin for SC UART mode */
    SYS->PA_H_MFP &= ~(SYS_PA_H_MFP_PA8_MFP_Msk | SYS_PA_H_MFP_PA9_MFP_Msk);
    SYS->PA_H_MFP |= (SYS_PA_H_MFP_PA8_MFP_SC0_CLK | SYS_PA_H_MFP_PA9_MFP_SC0_DAT);
	GPIO_ENABLE_PULL_UP(PA, BIT9);

    /* Enable SC UART module clock */
    CLK_EnableModuleClock(SC0_MODULE);
	
    SYS->PC_L_MFP &= ~SYS_PC_L_MFP_PC7_MFP_Msk;
    SYS->PC_L_MFP |= SYS_PC_L_MFP_PC7_MFP_GPC7;
	GPIO_SetMode(PC, 1 << 7, GPIO_PMD_OUTPUT);
	RS485_EN = 0;
}

void Sensor_Open()
{	
    SCUART_Open(SC0, 9600);
    SCUART_ENABLE_INT(SC0, (SC_IER_RDA_IE_Msk)); // | SC_IER_RTMR_IE_Msk));// | SC_IER_TERR_IE_Msk));
	NVIC_SetPriority(SC0_IRQn, 1);
    NVIC_EnableIRQ(SC0_IRQn);
}

static void RS485_SendDataByte(uint8_t *pu8TxBuf, uint32_t u32WriteBytes)
{
	RS485_EN = 1;
	delay_us(1);
    /* Send data */
    SCUART_Write(SC0, pu8TxBuf, u32WriteBytes);
	delay_ms(6);	// 至少5ms，保险起见6ms
	RS485_EN = 0;
}

// 物理层发送
uint8_t  rs_uart_send(rs_frame_t *frame, uint8_t destAddr, uint8_t dir)
{
	uint16_t crc;
	uint8_t i;

	// 填写固定字段
	frame->sof = RS_FRAME_SOF;
	frame->destAddr = destAddr;
	frame->srcAddr = dcBuff.configBottle.addr;
	memmove(frame->srcPSN, dcBuff.configBottle.PSN, 6);
	frame->dir = dir;
	frame->protocol_ver = RS_PROTOCOL_VER;

	crc = MODBUS_RTU_CRC16((uint8_t *) frame, frame->len - 2);
	((uint8_t *) frame)[frame->len - 2] = crc >> 8;
	((uint8_t *) frame)[frame->len - 1] = crc & 0xFF;
	
	printf("\r\nRS send %d bytes:\r\n", frame->len);
	for(i = 0; i < frame->len; i++)
		printf(" %02X", ((uint8_t *) frame)[i]);
	printf("\r\n");
	
	RS485_SendDataByte((uint8_t *) frame, frame->len);
	
	return 1;
}

// 读取真空计数据
void Sensor_ReadVacuum(uint8_t sensorIdx, data_sample_t *sample)
{
	// 设置中断回调函数
	RS485_Read = Modbus_Read;
	// 修改波特率
	SCUART_Open(SC0, 9600);

	// 默认读取失败
	sample->vacuum[sensorIdx].staVacuum = VACUUM_STATUS_COMM_FAULT;
	sample->vacuum[sensorIdx].lifeVacuum = 0;
	sample->vacuum[sensorIdx].vacuum = 0;
	sample->vacuum[sensorIdx].rateVacuum = 0;
	
    /* Flush FIFO */
    while(SCUART_GET_RX_EMPTY(SC0) == 0)
    {
        SCUART_READ(SC0);
    }

	// 初始化
	modbus_sample = sample;
	vaccum_idx = sensorIdx;
	modbus_idx = 0;
	
	// 发送
	modbus.send.id = VACUUM_ID[sensorIdx];
	modbus.send.cmd = VACUUM_CMD;
	modbus.send.addr = htons(VACUUM_ADDR - 1);
	modbus.send.len = htons(VACUUM_LEN);
	modbus.send.crc = htons(MODBUS_RTU_CRC16(modbus.buff, sizeof(modbus_send_t) - 2));
	RS485_SendDataByte(modbus.buff, sizeof(modbus_send_t));
	
	// 等待中断处理
}

// 读取流量计数据
void Sensor_ReadFlow(data_sample_t *sample)
{
	// 设置中断回调函数
	RS485_Read = Modbus_Read;
	// 修改波特率
	SCUART_Open(SC0, 9600);

	// 默认读取失败
	memset(&sample->flow, 0, sizeof(sample->flow));

    /* Flush FIFO */
    while(SCUART_GET_RX_EMPTY(SC0) == 0)
    {
        SCUART_READ(SC0);
    }

	// 初始化
	modbus_sample = sample;
	modbus_idx = 0;

	// 发送
	modbus.send.id = FLOW_ID;
	modbus.send.cmd = FLOW_CMD;
	modbus.send.addr = htons(FLOW_ADDR);
	modbus.send.len = htons(FLOW_LEN);
	modbus.send.crc = htons(MODBUS_RTU_CRC16(modbus.buff, sizeof(modbus_send_t) - 2));
	RS485_SendDataByte(modbus.buff, sizeof(modbus_send_t));
	
	// 等待中断处理
}

// 读取泄漏报警数据
void Sensor_ReadLeak(data_sample_t *sample)
{
	uint8_t reSample = 0;

#if 0	
	// 设置中断回调函数
	RS485_Read = Modbus_Read;
	// 修改波特率
	SCUART_Open(SC0, 9600);
#else
	// 设置中断回调函数
	RS485_Read = RS_ParseFrame;
	// 修改波特率
	SCUART_Open(SC0, 19200);
#endif

	// 默认读取失败
	sample->leak.staLeak = LEAK_STATUS_COMM_FAULT;
	sample->leak.concentrations = 0;
	// 传感器类型
	sample->leak.typeLeak = LEAK_TYPE_SWITCH | LEAK_TYPE_CURRENT | LEAK_TYPE_MODBUS;
	
    /* Flush FIFO */
    while(SCUART_GET_RX_EMPTY(SC0) == 0)
    {
        SCUART_READ(SC0);
    }

	// 初始化
	modbus_sample = sample;
	modbus_idx = 0;
	
	// 发送
#if 0
	modbus.send.id = LEAK_ID;
	modbus.send.cmd = LEAK_CMD;
	modbus.send.addr = htons(LEAK_ADDR);
	modbus.send.len = htons(LEAK_LEN);
	modbus.send.crc = htons(MODBUS_RTU_CRC16(modbus.buff, sizeof(modbus_send_t) - 2));
	RS485_SendDataByte(modbus.buff, sizeof(modbus_send_t));
#else
	rs_initial_frame(&RS_TranFrame);
	RS_TranFrame.cmd = RS_CMD_READ_DATA;
	rs_append_data(&RS_TranFrame, (uint8_t *) &reSample, 1);
	rs_uart_send(&RS_TranFrame, 0x50, RS_DIR_M2S);
#endif
	
	// 等待中断处理
}

uint32_t Sensor_ReadDOL()
{
	uint8_t buf[14];
	uint8_t c, i;
	uint8_t idx = 0;
	int16_t fld;
	uint32_t adc[20] = {-1};
	uint8_t cnt = 0;
	uint32_t tick = GetDelayTick(1000);
	
	// 禁止中断
    NVIC_DisableIRQ(UART0_IRQn);
	// 将串口更改为19200bps
	UART_Open(UART0, 19200);
	
	while(!IsTickOut(tick))
	{
		if(UART_GET_INT_FLAG(UART0, UART_ISR_BUF_ERR_IS_Msk))       /* Buffer Error INT */
		{
			UART_ClearIntFlag(UART0, UART_ISR_BUF_ERR_IS_Msk);
		}
		if(UART_GET_INT_FLAG(UART0, UART_ISR_RLS_IS_Msk))       /* RLS INT */
		{
			UART_ClearIntFlag(UART0, UART_ISR_RLS_IS_Msk);
		}
		
		// 解析DOL传感器的TTL数据：每13个字节为一帧，以0x35开头。
		// 由于不知道帧校验方式，所以将检测连续2个帧头（一头一尾）且第10个字节为0x81，作为合法帧的标准
		if(UART_GET_INT_FLAG(UART0, UART_ISR_RDA_IS_Msk) || UART_GET_INT_FLAG(UART0, UART_ISR_RTO_IS_Msk))
		{
			c = UART0->RBR;
			
			// 定位第1个帧头
			if(idx == 0 && c != 0x35)
				continue;
			
			buf[idx++] = c;
			
			// 检查第2个帧头，确保收到正确的一帧
			if(idx == 14 && (buf[13] != 0x35 || buf[10] != 0x81))
			{
				// 查找有没有中间的帧头
				for(i = 1; i < idx; i++)
				{
					if(buf[i] == 0x35)
						break;
				}
				
				// 如果没有找到，则i等于idx，idx将变为0
				idx -= i;
				memmove(buf, buf + i, idx);
			}
			
			// 收到一帧
			if(idx == 14)
			{
				// 取第2~3字节组成的有符号整数，除以系数27.3，即为英寸水柱的值
				memmove(&fld, buf + 2, 2);
				if(fld < 0)
					adc[cnt] = 0;
				else
					adc[cnt] = fld;
				
				// 收够20帧
				if(++cnt == 20)
				{
					// 排序以后取中间10帧的平均值
					sort(adc, cnt);
					adc[0] = 0;
					for(i = 5; i < 15; i++)
						adc[0] += adc[i];
					adc[0] /= 10;
					break;
				}
				
				// 准备接收下一帧，将当前帧头用起来
				idx = 0;
				buf[idx++] = c;
			}
		}
	}

	// 恢复中断
	UART_Open(UART0, 115200ul);
    NVIC_EnableIRQ(UART0_IRQn);

	return adc[0];	
}