/**
  ******************************************************************************
  * @file    InverterSwitch_Page2.c 
  * @author  -
  * @version -
  * @date    2026.3.26
  * @brief   -
  ******************************************************************************
  * @attention
  *
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include "global.h"


//这里放的是基本款的第2页函数，不根据发货要求变动
//CAN:
//13.SMA			14.Sunways		15.Luxpower	16.Schneider
//17.AlpSolarr
//Modbus:
//18.SRNE			19.Voltronic	20.COSUPER
//21.SMK			22.SAKO				23.SNADI		24.invt


//SMA 艾思玛
void CAN_Protocol_SMA(void)
{
	uint8_t   data[8];
	uint16_t  totalCapacity;
	
	int16_t   tempVol;
	int16_t   tempCur;
	
	uint16_t  chgVolLimit;
	uint16_t  dsgVolLimit;
	int16_t   chgCurLimit;
	int16_t   dsgCurLimit;
	
	uint8_t   protectByte1 = 0;
	uint8_t   protectByte2 = 0;
	uint8_t   protectByte3 = 0;
	uint8_t   protectByte4 = 0;
	
	uint8_t   alarmByte1 = 0;
	uint8_t   alarmByte2 = 0;
	uint8_t   alarmByte3 = 0;
	uint8_t   alarmByte4 = 0;

	
	int16_t   T_Average; // 平均温度
	
	
		//Data0 BIT0.1 General[Cancel]	//0000 0010
		protectByte1 |= 0x02;
		
		//保护
		//放电高温保护
		//over temp at discharging
		if(((canMem[0].status_byte2 & 0x0008) != 0) || ((canMem[0].status_byte4 & 0x0202) != 0))
		{
			protectByte1 &= 0x7f;
			protectByte1 |= 0x40;
		}
		else
		{
			protectByte1 &= 0xbf;
			protectByte1 |= 0x80;
		}

		//欠压保护
		//cell_uv+pack_uv+l0v
		if(((canMem[0].status_byte1 & 0x0202) != 0) || ((canMem[0].status_byte3 & 0x0008) != 0))
		{
			protectByte1 &= 0xdf;
			protectByte1 |= 0x10;
		}
		else
		{
			protectByte1 &= 0xef;
			protectByte1 |= 0x20;
		}
		
//		//过压保护
//		//cell_ov+pack_ov+pf
//		if((canMem[0].status_byte1 & 0x0141) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				protectByte1 &= 0xf7; //去掉leave
//				protectByte1 |= 0x04; //赋值arrive
//			}
//			else
//			{
//				protectByte1 &= 0xfb;
//				protectByte1 |= 0x08;
//			}
//		}
//		else
//		{
//			protectByte1 &= 0xfb;
//			protectByte1 |= 0x08;
//		}

		//放电过流保护
		//discharge over current，SC, OCD1, OCD2
		if( ((canMem[0].status_byte1 & 0x042c) != 0) || ((canMem[0].status_byte2 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0020) != 0))
		{
			protectByte2 &= 0x7f;
			protectByte2 |= 0x40;
		}
		else
		{
			protectByte2 &= 0xbf;
			protectByte2 |= 0x80;
		}

		//充电低温保护
		//Data1 BIT4.5 under temp at charging	//0001 0000
		if( ((canMem[0].status_byte2 & 0x0001) != 0) || ((canMem[0].status_byte4 & 0x0404) != 0) )
		{
			protectByte2 &= 0xdf;
			protectByte2 |= 0x10;
		}
		else
		{
			protectByte2 &= 0xef;
			protectByte2 |= 0x20;
		}

		//充电高温保护
		//Data1 BIT2.3 over temp at charging	//0000 0100
		if( ((canMem[0].status_byte2 & 0x0002) != 0) || ((canMem[0].status_byte4 & 0x0101) != 0) )
		{
			protectByte2 &= 0xf7;
			protectByte2 |= 0x04;
		}
		else
		{
			protectByte2 &= 0xfb;
			protectByte2 |= 0x08;
		}

		//放电低温保护
		//Data1 BIT0.1 under temp at discharging	//0000 0001
		if( ((canMem[0].status_byte2 & 0x0004) != 0) || ((canMem[0].status_byte4 & 0x0808) != 0) )
		{
			protectByte2 &= 0xfd;
			protectByte2 |= 0x01;
		}
		else
		{
			protectByte2 &= 0xfe;
			protectByte2 |= 0x02;
		}
		
		//短路
		//Data2 BIT4.5 short circuit	//0001 0000
		if((canMem[0].status_byte1 & 0x20) != 0)
		{
			protectByte3 &= 0xdf;
			protectByte3 |= 0x10;
		}
		else
		{
			protectByte3 &= 0xef;
			protectByte3 |= 0x20;
		}
		
		//充电过流保护
		//charge over current
		if( ((canMem[0].status_byte1 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0010) != 0))
		{
			protectByte3 &= 0xfd;
			protectByte3 |= 0x01;
		}
		else
		{
			protectByte3 &= 0xfe;
			protectByte3 |= 0x02;
		}
		//Data2 BIT2.3 Contactor[Cancel]	//0000 1000
		protectByte3 |= 0x08;
		//Data2 BIT6.7 BMS internal[Cancel]	//1000 0000
		protectByte3 |= 0x80;
//		//Data3 BIT0.1 cell imbanlance	//0000 0001
//		if((bmsMem.balanceStatus & 0x01) !=0) //0x01表示平衡
//		{
//			protectByte4 &= 0xfe;
//			protectByte4 |= 0x02;
//		}
//		else
//		{
//			protectByte4 &= 0xfd;
//			protectByte4 |= 0x01;
//		}
		
		
		//告警
		//放电高温告警
		//over temp at discharging
		if(((canMem[0].status_byte2 & 0x2200) != 0) || ((canMem[0].status_byte4 & 0x2000) != 0))
		{
			alarmByte1 &= 0x7f;
			alarmByte1 |= 0x40;
		}
		else
		{
			alarmByte1 &= 0xbf;
			alarmByte1 |= 0x80;
		}

		//欠压告警
		if((canMem[0].status_byte3 & 0x0A00) != 0)
		{
			alarmByte1 &= 0xdf;
			alarmByte1 |= 0x10;
		}
		else
		{
			alarmByte1 &= 0xef;
			alarmByte1 |= 0x20;
		}
		
//		//过压告警
//		if((canMem[0].status_byte3 & 0x0500) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				alarmByte1 &= 0xf7; //去掉leave
//				alarmByte1 |= 0x04; //赋值arrive
//			}
//			else
//			{
//				alarmByte1 &= 0xfb;
//				alarmByte1 |= 0x08;
//			}
//		}
//		else
//		{
//			alarmByte1 &= 0xfb;
//			alarmByte1 |= 0x08;
//		}

		//放电过流告警
		if((canMem[0].status_byte3 & 0x2000) != 0)
		{
			alarmByte2 &= 0x7f;
			alarmByte2 |= 0x40;
		}
		else
		{
			alarmByte2 &= 0xbf;
			alarmByte2 |= 0x80;
		}

		//充电低温告警
		//Data1 BIT4.5 under temp at charging	//0001 0000
		if( ((canMem[0].status_byte2 & 0x4400) != 0) || ((canMem[0].status_byte4 & 0x4000) != 0) )
		{
			alarmByte2 &= 0xdf;
			alarmByte2 |= 0x10;
		}
		else
		{
			alarmByte2 &= 0xef;
			alarmByte2 |= 0x20;
		}

		//充电高温告警
		//Data1 BIT2.3 over temp at charging	//0000 0100
		if( ((canMem[0].status_byte2 & 0x1100) != 0) || ((canMem[0].status_byte4 & 0x1000) != 0) )
		{
			alarmByte2 &= 0xf7;
			alarmByte2 |= 0x04;
		}
		else
		{
			alarmByte2 &= 0xfb;
			alarmByte2 |= 0x08;
		}

		//放电低温告警
		//Data1 BIT0.1 under temp at discharging	//0000 0001
		if( ((canMem[0].status_byte2 & 0x8800) != 0) || ((canMem[0].status_byte4 & 0x8000) != 0) )
		{
			alarmByte2 &= 0xfd;
			alarmByte2 |= 0x01;
		}
		else
		{
			alarmByte2 &= 0xfe;
			alarmByte2 |= 0x02;
		}
		
		//短路
		//Data2 BIT4.5 short circuit	//0001 0000
		if((canMem[0].status_byte1 & 0x20) != 0)
		{
			alarmByte3 &= 0xdf;
			alarmByte3 |= 0x10;
		}
		else
		{
			alarmByte3 &= 0xef;
			alarmByte3 |= 0x20;
		}
		
		//充电过流告警
		if((canMem[0].status_byte3 & 0x1000) != 0)
		{
			alarmByte3 &= 0xfd;
			alarmByte3 |= 0x01;
		}
		else
		{
			alarmByte3 &= 0xfe;
			alarmByte3 |= 0x02;
		}

//		if((bmsMem.balanceStatus & 0x01) !=0) //0x01表示平衡
//		{
//			alarmByte4 &= 0xfe;
//			alarmByte4 |= 0x02;
//		}
//		else
//		{
//			alarmByte4 &= 0xfd;
//			alarmByte4 |= 0x01;
//		}
		
	
	if(CAN_SendCount ==0) //ID=0x35a - Alarms/Warnings
	{
		data[0] = protectByte1;
		data[1] = protectByte2;
		data[2] = protectByte3;
		data[3] = protectByte4;
		data[4] = alarmByte1; //报警和保护信号相同
		data[5] = alarmByte2;
		data[6] = alarmByte3;
		data[7] = alarmByte4;
		CAN1_SendData(0x35a, &data[0]);
	}
	if(CAN_SendCount ==1) //ID = 0x351 - 电池充电/放电电压，充电/放电限流
	{
		//充放电电流限制需要有符号区别吗？
		chgVolLimit = bmsMem.inverter_chgVolLimit; //充电电压限制，上位机配置，默认值57.6V
		dsgVolLimit = bmsMem.inverter_dsgVolLimit; //放电电压限制，上位机配置，默认值41.6V
		
		if(chg_forbidFlg == 1)
		{
			chgCurLimit = 0; //SMA禁充
		}
		else if(chg_curlimitFlg == 1)
		{
			chgCurLimit = Inv_curlimit * (OnlineNum-chg_cur0Num); //限流40A*未保护个数
		}
		else
		{
			chgCurLimit = bmsMem.inverter_chgCurLimit * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
		}
		if(dsg_forbidFlg == 1)
		{
			dsgCurLimit = 0; //SMA禁放
		}
		else
		{
			dsgCurLimit = bmsMem.inverter_dsgCurLimit * (OnlineNum-dsg_curLimitNum); //放电电流限制，上位机配置，默认值100A
		}
		
		data[0] =  chgVolLimit & 0xFF;       //充电电压限制低位
		data[1] = (chgVolLimit >> 8) & 0xFF;
		data[2] =  chgCurLimit & 0xFF;       //充电电流限制低位
		data[3] = (chgCurLimit >> 8) & 0xFF;
		data[4] =  dsgCurLimit & 0xFF;       //放电电流限制低位
		data[5] = (dsgCurLimit >> 8) & 0xFF;
		data[6] =  dsgVolLimit & 0xFF;       //放电电压限制低位
		data[7] = (dsgVolLimit >> 8) & 0xFF;
		CAN1_SendData(0x351, &data[0]);
	}
	if(CAN_SendCount ==2) //ID = 0x355 - 电量SOC/SOH
	{
		data[0] = canMem[0].soc & 0xFF;  //SOC
		data[1] = 0;
		data[2] = canMem[0].soh & 0xFF;  //SOH
		data[3] = 0;
		data[4] = 0X00;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0X00;
		CAN1_SendData(0x355, &data[0]);
	}
	if(CAN_SendCount ==3) //ID = 0x356 - 电池电压/电流/温度
	{
		tempVol = (uint16_t)(bmsMem.packVoltage/10); //单位0.01
		tempCur = (int16_t)(canMem[0].cur/10); //单位0.1
		T_Average = canMem[0].temp;// 平均温度
		
		data[0] =  tempVol & 0xFF; 
		data[1] = (tempVol >>8) & 0xFF;  //电池包电压
		data[2] =  tempCur & 0xFF;
		data[3] = (tempCur >>8) & 0xFF;  //电池包电流
		data[4] =  (T_Average -2731) & 0xFF;;
		data[5] = ((T_Average -2731) >>8) & 0xFF;  //温度-暂时取平均温度，具体哪一路需要客户确认
		data[6] = 0x00;
		data[7] = 0X00;
		CAN1_SendData(0x356, &data[0]);
	}
	if(CAN_SendCount ==4) //ID = 0x35e - 制造商名称-ASCII
	{
		data[0] = 'B'; 
		data[1] = 'T';
		data[2] = 'Y';
		data[3] = 'G'; 
		data[4] = '-';
		data[5] = 'B';
		data[6] = 'M';
		data[7] = 'S';
		CAN1_SendData(0x35e, &data[0]);
	}
	if(CAN_SendCount ==5) //ID = 0x35f - 电池类型，BMS版本，电池容量，保留的制造商ID
	{
		totalCapacity = ncc_Ah * OnlineNum; //单位1Ah
		
		data[0] = 0X00; 
		data[1] = 0X00;
		data[2] = 0X00; //版本号暂无
		data[3] = 0X00; 
		data[4] =  totalCapacity & 0xFF; //电池容量
		data[5] = (totalCapacity >> 8) & 0xFF;
		data[6] = 0X00;
		data[7] = 0X00;
		CAN1_SendData(0x35f, &data[0]);	
	}
	
	if(CAN_SendCount>=6)
	{
		CAN_SendCount = 0;
	}		
}

//Sunways 尚唯斯
void CAN_Protocol_Sunways(void)
{
	uint8_t   data[8];
	uint16_t  totalCapacity;
	
	uint16_t  tempVol;
	int16_t   tempCur;
	
	uint16_t  chgVolLimit;
	uint16_t  dsgVolLimit;
	int16_t   chgCurLimit = bmsMem.inverter_chgCurLimit;
	int16_t   dsgCurLimit = bmsMem.inverter_dsgCurLimit;
	
	uint8_t   protectByte1 = 0;
	uint8_t   protectByte2 = 0;
		
	int16_t   T_Average; // 平均温度
	
	uint8_t   alarmByte1 = 0;
	uint8_t   alarmByte2 = 0;
	
	uint8_t   alarmByte3 = 0;		//0x399传输告警位
	uint8_t   status = 0;				//0x399传输状态位
	uint8_t   protectByte3 = 0;	//0x399传输故障位
	

	//保护
	//放电过流保护
	//discharge over current，SC, OCD1, OCD2
	if( ((canMem[0].status_byte1 & 0x042c) != 0) || ((canMem[0].status_byte2 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0020) != 0))
	{
		protectByte1 |= 0x80;
	}
	else
	{
		protectByte1 &= 0x7f;
	}
	
	//低温保护
	//under temp at charging or discharging
	if(((canMem[0].status_byte2 & 0x0005) != 0) || ((canMem[0].status_byte4 & 0x0C0C) != 0))
	{
		protectByte1 |= 0x10;
	}
	else
	{
		protectByte1 &= 0xef;
	}
	
	//过温保护
	//over temp at charging or discharging
	if(((canMem[0].status_byte2 & 0x000A) != 0) || ((canMem[0].status_byte4 & 0x0303) != 0))
	{
		protectByte1 |= 0x08;
	}
	else
	{
		protectByte1 &= 0xf7;
	}
	
	//欠压保护
	//cell_uv+pack_uv+l0v
	if(((canMem[0].status_byte1 & 0x0202) != 0) || ((canMem[0].status_byte3 & 0x0008) != 0))
	{
		protectByte1 |= 0x04;
		alarmByte3 |= 0x02;
		protectByte3 |= 0x04;
	}
	else
	{
		protectByte1 &= 0xfb;
		alarmByte3 &= 0xfd;
		protectByte3 &= 0xfb;
	}
	
//		//过压保护
//		//cell_ov+pack_ov+pf
//		if((canMem[0].status_byte1 & 0x0141) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				protectByte1 |= 0x02;
//			}
//			else
//			{
//				protectByte1 &= 0xfd;
//			}
//		}
//		else
//		{
//			protectByte1 &= 0xfd;
//		}
	
	//充电过流保护
	//charge over current
	if( ((canMem[0].status_byte1 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0010) != 0))
	{
		protectByte2 |= 0x01;
	}
	else
	{
		protectByte2 &= 0xfe;
	}
	
	//告警
	//放电过流告警
	if((canMem[0].status_byte3 & 0x2000) != 0)
	{
		alarmByte1 |= 0x80;
	}
	else
	{
		alarmByte1 &= 0x7f;
	}

	//低温告警
	if(((canMem[0].status_byte2 & 0xCC00) != 0) || ((canMem[0].status_byte4 & 0xC000) != 0))
	{
		alarmByte1 |= 0x10;
	}
	else
	{
		alarmByte1 &= 0xef;
	}
	
	//过温告警
	if(((canMem[0].status_byte2 & 0x3300) != 0) || ((canMem[0].status_byte4 & 0x3000) != 0))
	{
		alarmByte1 |= 0x08;
	}
	else
	{
		alarmByte1 &= 0xf7;
	}

	//欠压告警
	if((canMem[0].status_byte3 & 0x0A00) != 0)
	{
		alarmByte1 |= 0x04;
	}
	else
	{
		alarmByte1 &= 0xfb;
	}

//		//过压告警
//		if((canMem[0].status_byte3 & 0x0500) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				alarmByte1 |= 0x02;
//			}
//			else
//			{
//				alarmByte1 &= 0xfd;
//			}
//		}
//		else
//		{
//			alarmByte1 &= 0xfd;
//		}

	//充电过流告警
	if((canMem[0].status_byte3 & 0x1000) != 0)
	{
		alarmByte2 |= 0x01;
	}
	else
	{
		alarmByte2 &= 0xfe;
	}
	
	
	if(CAN_SendCount ==0) //ID=0x359
	{
		data[0] = protectByte1;
		data[1] = protectByte2;
		data[2] = alarmByte1;
		data[3] = alarmByte2;
		data[4] = OnlineNum;
		data[5] = 0x50;
		data[6] = 0x4E;
		data[7] = 0X00;
		CAN1_SendData(0x359, &data[0]);
	}
	
	if(CAN_SendCount ==1) //ID = 0x351
	{		
		//充放电电流限制需要有符号区别吗？
		chgVolLimit = bmsMem.inverter_chgVolLimit; //充电电压限制，上位机配置，默认值57.6V
		dsgVolLimit = bmsMem.inverter_dsgVolLimit; //放电电压限制，上位机配置，默认值41.6V
		
		if(chg_forbidFlg == 1)
		{
			chgCurLimit = 0; //Sol-Ark禁充
		}
		else if(chg_curlimitFlg == 1)
		{
			chgCurLimit = Inv_curlimit * (OnlineNum-chg_cur0Num); //限流40A*未保护个数
		}
		else
		{
			chgCurLimit = bmsMem.inverter_chgCurLimit * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
		}
		if(dsg_forbidFlg == 1)
		{
			dsgCurLimit = 0; //Sol-Ark禁放
		}
		else
		{
			dsgCurLimit = bmsMem.inverter_dsgCurLimit * (OnlineNum-dsg_curLimitNum); //放电电流限制，上位机配置，默认值100A
		}
		
		data[0] =  chgVolLimit & 0xFF;       //充电电压限制低位
		data[1] = (chgVolLimit >> 8) & 0xFF;
		data[2] =  chgCurLimit & 0xFF;       //充电电流限制低位
		data[3] = (chgCurLimit >> 8) & 0xFF;
		data[4] =  dsgCurLimit & 0xFF;       //放电电流限制低位
		data[5] = (dsgCurLimit >> 8) & 0xFF;
		data[6] =  dsgVolLimit & 0xFF;       //放电电压限制低位
		data[7] = (dsgVolLimit >> 8) & 0xFF;	
		CAN1_SendData(0x351, &data[0]);		
	}
	
	if(CAN_SendCount ==2)
	{
		data[0] = canMem[0].soc & 0xFF;  //SOC
		data[1] = 0;
		data[2] = canMem[0].soh & 0xFF;  //SOH
		data[3] = 0; 
		data[4] = 0X00;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0X00;
		CAN1_SendData(0x355, &data[0]);
	}
	
	if(CAN_SendCount ==3)
	{
		tempVol = (uint16_t)(bmsMem.packVoltage/10); //单位0.01
		tempCur = (int16_t)(canMem[0].cur/10); //单位0.1
		T_Average = canMem[0].temp;// 平均温度
		
		data[0] =  tempVol & 0xFF; 
		data[1] = (tempVol >>8) & 0xFF;  //电池包电压
		data[2] =  tempCur & 0xFF;
		data[3] = (tempCur >>8) & 0xFF;  //电池包电流
		data[4] =  (T_Average -2731) & 0xFF;;
		data[5] = ((T_Average -2731) >>8) & 0xFF;  //温度-暂时取平均温度，具体哪一路需要客户确认
		data[6] = 0x00;
		data[7] = 0X00;	
		CAN1_SendData(0x356, &data[0]);
	}
	
	if(CAN_SendCount ==4)
	{
		status = 0x03;
		if(chg_forbidFlg == 1)//sunways
		{
			status &= ~0x01; //禁充
		}
		if(dsg_forbidFlg == 1)//sunways
		{
			status &= ~0x02; //禁放
		}
		if(chg_forceFlg == 1)//sunways
		{
			status |= ~0x04; //强充
		}
		
		data[0] = 0x00; 
		data[1] = 0x00;
		data[2] = alarmByte3;
		data[3] = status;
		data[4] = protectByte3;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0X00;	
		CAN1_SendData(0x399, &data[0]);
	}
	
	if(CAN_SendCount ==5)
	{
		totalCapacity = ncc_Ah * OnlineNum; //单位1Ah
		
		data[0] = 0x00;//电池类型
		data[1] = 0x00;
		data[2] = VersionMem.Software[0] & 0xFF;//BMS版本号，仅传输大版本号及小修改
		data[3] = VersionMem.Software[3] & 0xFF; 
		data[4] = totalCapacity & 0xFF;       //容量
		data[5] = (totalCapacity >> 8) & 0xFF;	
		data[6] = 0x00;//制造商ID
		data[7] = 0X00;	
		CAN1_SendData(0x35F, &data[0]);
	}
	
	if(CAN_SendCount ==6)
	{
		RequestFlag = 0xC0; //充电允许0x80，放电允许0x40，不强充~0x20
		if(chg_forbidFlg == 1)//sunways
		{
			RequestFlag &= 0x7F; //禁充
		}
		if(dsg_forbidFlg == 1)//sunways
		{
			RequestFlag &= 0xBF; //禁放
		}
		if(chg_forceFlg == 1)//sunways
		{
			RequestFlag |= 0x20; //强充
		}
		
		data[0] = RequestFlag;
		data[1] = 0x00;
		data[2] = 0x00;
		data[3] = 0x00; 
		data[4] = 0X00;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0X00;	
		CAN1_SendData(0x35C, &data[0]);
	}
	
	if(CAN_SendCount ==7) //0x370
	{		
		data[0] = bmsMem.vCell[0] & 0xFF; //电芯N电压
		data[1] = (bmsMem.vCell[0] >> 8) & 0xFF;
		data[2] = bmsMem.vCell[1] & 0xFF; //电芯N+1电压
		data[3] = (bmsMem.vCell[1] >> 8) & 0xFF;
		data[4] = bmsMem.vCell[2] & 0xFF; //电芯N+2电压
		data[5] = (bmsMem.vCell[2] >> 8) & 0xFF;
		data[6] = bmsMem.vCell[3] & 0xFF; //电芯N+3电压
		data[7] = (bmsMem.vCell[3] >> 8) & 0xFF;
		CAN1_SendData(0x370, &data[0]);
	}
	
	if(CAN_SendCount ==8) //0x371
	{		
		data[0] = bmsMem.vCell[4] & 0xFF; //电芯N+4电压
		data[1] = (bmsMem.vCell[4] >> 8) & 0xFF;
		data[2] = bmsMem.vCell[5] & 0xFF; //电芯N+5电压
		data[3] = (bmsMem.vCell[5] >> 8) & 0xFF; 
		data[4] = bmsMem.vCell[6] & 0xFF; //电芯N+6电压
		data[5] = (bmsMem.vCell[6] >> 8) & 0xFF;
		data[6] = bmsMem.vCell[7] & 0xFF; //电芯N+7电压
		data[7] = (bmsMem.vCell[7] >> 8) & 0xFF;	
		CAN1_SendData(0x371, &data[0]);
	}

	if(CAN_SendCount ==9) //0x372
	{		
		data[0] = bmsMem.vCell[8] & 0xFF; //电芯N+8电压
		data[1] = (bmsMem.vCell[8] >> 8) & 0xFF;
		data[2] = bmsMem.vCell[9] & 0xFF; //电芯N+9电压
		data[3] = (bmsMem.vCell[9] >> 8) & 0xFF; 
		data[4] = bmsMem.vCell[10] & 0xFF; //电芯N+10电压
		data[5] = (bmsMem.vCell[10] >> 8) & 0xFF;
		data[6] = bmsMem.vCell[11] & 0xFF; //电芯N+11电压
		data[7] = (bmsMem.vCell[11] >> 8) & 0xFF;	
		CAN1_SendData(0x372, &data[0]);
	}

	if(CAN_SendCount ==10) //0x373
	{		
		data[0] = bmsMem.vCell[12] & 0xFF; //电芯N+12电压
		data[1] = (bmsMem.vCell[12] >> 8) & 0xFF;
		data[2] = bmsMem.vCell[13] & 0xFF; //电芯N+13电压
		data[3] = (bmsMem.vCell[13] >> 8) & 0xFF; 
		data[4] = bmsMem.vCell[14] & 0xFF; //电芯N+14电压
		data[5] = (bmsMem.vCell[14] >> 8) & 0xFF;
		data[6] = bmsMem.vCell[15] & 0xFF; //电芯N+15电压
		data[7] = (bmsMem.vCell[15] >> 8) & 0xFF;	
		CAN1_SendData(0x373, &data[0]);
	}
	
	if(CAN_SendCount ==11) //0x3D0
	{
		data[0] = ((bmsMem.mcu_T1 - 2731)/10 + 50) & 0xFF; 
		data[1] = ((bmsMem.mcu_T2 - 2731)/10 + 50) & 0xFF;
		data[2] = ((bmsMem.mcu_T3 - 2731)/10 + 50) & 0xFF;
		data[3] = ((bmsMem.mcu_T4 - 2731)/10 + 50) & 0xFF; 
		data[4] = ((bmsMem.afe_T1 - 2731)/10 + 50) & 0xFF;
		data[5] = ((bmsMem.afe_T2 - 2731)/10 + 50) & 0xFF;;
		data[6] = ((bmsMem.afe_T3 - 2731)/10 + 50) & 0xFF;;
		data[7] = 0X00;	
		CAN1_SendData(0x3D0, &data[0]);
	}
		
	if(CAN_SendCount ==12) //0x3DA
	{
		data[0] = bmsMem.can_VolMax & 0xFF; 
		data[1] = (bmsMem.can_VolMax >>8) & 0xFF;
		data[2] = bmsMem.can_VolMin & 0xFF; 
		data[3] = (bmsMem.can_VolMin >>8) & 0xFF;
		data[4] = (bmsMem.can_VolMaxIndex + 1) & 0xFF;
		data[5] = (bmsMem.can_VolMinIndex + 1) & 0xFF;
		data[6] = 0X00;
		data[7] = 0X00;	
		CAN1_SendData(0x3DA, &data[0]);
	}
	
	if(CAN_SendCount ==13) //0x3DB
	{
		data[0] = ((bmsMem.can_TempMax - 2731)/10 + 50) & 0xFF; 
		data[1] = (((bmsMem.can_TempMax - 2731)/10 + 50) >>8) & 0xFF;
		data[2] = ((bmsMem.can_TempMin - 2731)/10 + 50) & 0xFF; 
		data[3] = (((bmsMem.can_TempMin - 2731)/10 + 50) >>8) & 0xFF;
		data[4] = (bmsMem.can_TempMaxIndex + 1) & 0xFF;
		data[5] = (bmsMem.can_TempMinIndex + 1) & 0xFF;
		data[6] = 0X00;
		data[7] = 0X00;	
		CAN1_SendData(0x3DB, &data[0]);
	}
	
	if(CAN_SendCount ==14) //0x35E
	{		
		data[0] = 0x50; //制造商名称
		data[1] = 0x4E;
		data[2] = 0x00;
		data[3] = 0x00;
		data[4] = 0X00;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0X00;	
		CAN1_SendData(0x35E, &data[0]);
	}

	if(CAN_SendCount>=15)
	{
		CAN_SendCount = 0;
	}		

}
//Lux power 深圳鹏城
void CAN_Protocol_Luxpower(void)
{
	uint8_t   data[8];
	uint16_t  totalCapacity;//总容量
	
	uint16_t  tempVol;
	int16_t   tempCur; //总电流
	
	uint16_t  chgVolLimit;
	uint16_t  dsgVolLimit;
	int16_t   chgCurLimit;
	int16_t   dsgCurLimit;
	
	uint8_t   protectByte1 = 0;
	uint8_t   protectByte2 = 0;
	
	uint8_t   alarmByte1 = 0;
	uint8_t   alarmByte2 = 0;
	
	int16_t   T_Max;	   // 最高温度
	int16_t   T_Min;	   // 最低温度
	uint16_t  cellVolMax=0;	  			 // 电芯单体最高电压
	uint16_t  cellVolMin=0;	 			   // 电芯单体最低电压
	
	
		//保护
		//放电过流保护
		//discharge over current，SC, OCD1, OCD2
		if( ((canMem[0].status_byte1 & 0x042c) != 0) || ((canMem[0].status_byte2 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0020) != 0))
		{
			protectByte1 |= 0x80;
		}
		else
		{
			protectByte1 &= 0x7f;
		}
		
		//低温保护
		//under temp at charging or discharging
		if(((canMem[0].status_byte2 & 0x0005) != 0) || ((canMem[0].status_byte4 & 0x0C0C) != 0))
		{
			protectByte1 |= 0x10;
		}
		else
		{
			protectByte1 &= 0xef;
		}
		
		//过温保护
		//over temp at charging or discharging
		if(((canMem[0].status_byte2 & 0x000A) != 0) || ((canMem[0].status_byte4 & 0x0303) != 0))
		{
			protectByte1 |= 0x08;
		}
		else
		{
			protectByte1 &= 0xf7;
		}
		
		//欠压保护
		//cell_uv+pack_uv+l0v
		if(((canMem[0].status_byte1 & 0x0202) != 0) || ((canMem[0].status_byte3 & 0x0008) != 0))
		{
			protectByte1 |= 0x04;
		}
		else
		{
			protectByte1 &= 0xfb;
		}
		
//		//过压保护
//		//cell_ov+pack_ov+pf
//		if((canMem[0].status_byte1 & 0x0141) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				protectByte1 |= 0x02;
//			}
//			else
//			{
//				protectByte1 &= 0xfd;
//			}
//		}
//		else
//		{
//			protectByte1 &= 0xfd;
//		}
		
		//充电过流保护
		//charge over current
		if( ((canMem[0].status_byte1 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0010) != 0))
		{
			protectByte2 |= 0x01;
		}
		else
		{
			protectByte2 &= 0xfe;
		}
		
		//告警
		//放电过流告警
		if((canMem[0].status_byte3 & 0x2000) != 0)
		{
			alarmByte1 |= 0x80;
		}
		else
		{
			alarmByte1 &= 0x7f;
		}

		//低温告警
		if(((canMem[0].status_byte2 & 0xCC00) != 0) || ((canMem[0].status_byte4 & 0xC000) != 0))
		{
			alarmByte1 |= 0x10;
		}
		else
		{
			alarmByte1 &= 0xef;
		}
		
		//过温告警
		if(((canMem[0].status_byte2 & 0x3300) != 0) || ((canMem[0].status_byte4 & 0x3000) != 0))
		{
			alarmByte1 |= 0x08;
		}
		else
		{
			alarmByte1 &= 0xf7;
		}

		//欠压告警
		if((canMem[0].status_byte3 & 0x0A00) != 0)
		{
			alarmByte1 |= 0x04;
		}
		else
		{
			alarmByte1 &= 0xfb;
		}

//		//过压告警
//		if((canMem[0].status_byte3 & 0x0500) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				alarmByte1 |= 0x02;
//			}
//			else
//			{
//				alarmByte1 &= 0xfd;
//			}
//		}
//		else
//		{
//			alarmByte1 &= 0xfd;
//		}

		//充电过流告警
		if((canMem[0].status_byte3 & 0x1000) != 0)
		{
			alarmByte2 |= 0x01;
		}
		else
		{
			alarmByte2 &= 0xfe;
		}
		
	
	if(CAN_SendCount ==0) //ID = 0x359 --- 报警/保护、总容量
	{
		totalCapacity = ncc_Ah * OnlineNum; //单位1Ah
		
		data[0] = protectByte1;
		data[1] = protectByte2;
		data[2] = alarmByte1;
		data[3] = alarmByte2;
		data[4] = OnlineNum;
		data[5] = totalCapacity & 0xFF;
		data[6] = (totalCapacity >> 8) & 0xFF;
		data[7] = 0X00;
		CAN1_SendData(0x359, &data[0]);
	}
	if(CAN_SendCount ==1) //ID = 0x351 --- 充/放电限压/限流
	{
		//充放电电流限制需要有符号区别吗？
		chgVolLimit = bmsMem.inverter_chgVolLimit; //充电电压限制，上位机配置，默认值57.6V
		dsgVolLimit = bmsMem.inverter_dsgVolLimit; //放电电压限制，上位机配置，默认值41.6V
		
		if(chg_forbidFlg == 1)
		{
			chgCurLimit = 0; //Luxpower禁充
		}
		else if(chg_curlimitFlg == 1)
		{
			chgCurLimit = Inv_curlimit * (OnlineNum-chg_cur0Num); //限流40A*未保护个数
		}
		else
		{
			chgCurLimit = bmsMem.inverter_chgCurLimit * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
		}
		if(dsg_forbidFlg == 1)
		{
			dsgCurLimit = 0; //Luxpower禁放
		}
		else
		{
			dsgCurLimit = bmsMem.inverter_dsgCurLimit * (OnlineNum-dsg_curLimitNum); //放电电流限制，上位机配置，默认值100A
		}
		
		data[0] =  chgVolLimit & 0xFF;       //充电电压限制低位
		data[1] = (chgVolLimit >> 8) & 0xFF;
		data[2] =  chgCurLimit & 0xFF;       //充电电流限制低位
		data[3] = (chgCurLimit >> 8) & 0xFF;
		data[4] =  dsgCurLimit & 0xFF;       //放电电流限制低位
		data[5] = (dsgCurLimit >> 8) & 0xFF;
		data[6] =  dsgVolLimit & 0xFF;       //放电电压限制低位
		data[7] = (dsgVolLimit >> 8) & 0xFF;
		CAN1_SendData(0x351, &data[0]);
	}
	if(CAN_SendCount ==2) //ID = 0x355 --- SOC/SOH、最大/小电压
	{
		cellVolMax = canMem[0].VolMax;
		cellVolMin = canMem[0].VolMin;
		
		data[0] = canMem[0].soc & 0xFF;  //SOC
		data[1] = 0;
		data[2] = canMem[0].soh & 0xFF;  //SOH
		data[3] = 0; 
		data[4] =  cellVolMax & 0xFF;			 		//最大单体电压
		data[5] = (cellVolMax >> 8) & 0xFF;
		data[6] =  cellVolMin & 0xFF;         //最小单体电压
		data[7] = (cellVolMin >> 8) & 0xFF;
		CAN1_SendData(0x355, &data[0]);
	}
	if(CAN_SendCount ==3) //ID = 0x356 --- 总电压/电流、最大/小温度
	{
		tempVol = (uint16_t)(bmsMem.packVoltage/10); //单位0.01
		tempCur = (int16_t)(canMem[0].cur/10); //单位0.1
		T_Max = canMem[0].TempMax;	   // 最高温度 单位0.1
		T_Min = canMem[0].TempMin;	   // 最低温度 单位0.1
		
		data[0] =  tempVol & 0xFF; 
		data[1] = (tempVol >>8) & 0xFF;  //电池包电压
		data[2] =  tempCur & 0xFF;
		data[3] = (tempCur >>8) & 0xFF;  //电池包电流
		data[4] =  (T_Max -2731) & 0xFF;	//最高单体温度
		data[5] = ((T_Max -2731) >> 8) & 0xFF;
		data[6] =  (T_Min -2731) & 0xFF;	//最低单体温度
		data[7] = ((T_Min -2731) >> 8) & 0xFF;
		CAN1_SendData(0x356, &data[0]);
	}	
	if(CAN_SendCount ==4) //ID = 0x35C --- 总电压/电流、最大/小温度
	{
		RequestFlag = 0xC0; //充电允许0x80，放电允许0x40，不强充~0x20
		if(chg_forbidFlg == 1)//Lux power
		{
			RequestFlag &= 0x7F; //禁充
		}
		if(dsg_forbidFlg == 1)//Lux power
		{
			RequestFlag &= 0xBF; //禁放
		}
		if(chg_forceFlg == 1)//Lux power
		{
			RequestFlag |= 0x20; //强充
		}
		
		data[0] = RequestFlag;  //充电允许，放电允许
		data[1] = 0x00;
		data[2] = 0x00;
		data[3] = 0x00; 
		data[4] = 0X00;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0X00;
		CAN1_SendData(0x35C, &data[0]);
	}
	
	if(CAN_SendCount>=5)
	{
		CAN_SendCount = 0;
	}
}

//Schneider 施耐德
void CAN_Protocol_Schneider(void)
{
	uint8_t   data[8];
	uint16_t  totalCapacity; //总容量
	
	uint32_t  tempVol; //总电压
	int32_t   tempCur; //总电流
	
	uint32_t  chgVolLimit; //充电限压
	uint32_t  dsgVolLimit; //放电限压
	int32_t   chgCurLimit; //充电限流
	int32_t   dsgCurLimit; //放电限流
	
	uint8_t   protectByte1 = 0; //保护位1，与告警位1值相同
	
	uint8_t   alarmByte1 = 0;

	
	int16_t   T_Average; // 平均温度
	int16_t   T_Max;	   // 最高温度
	int16_t   T_Min;	   // 最低温度
	
	uint16_t  cellVolMax=0;	  			 // 电芯单体最高电压
	uint16_t  cellVolMin=0;	 			   // 电芯单体最低电压
	
	
//		//Data2 BIT6 cell imbalance
//		if((bmsMem.balanceStatus & 0x01) !=0) //表示开启了均衡
//		{
//			protectByte1 |= 0xBF;
//			alarmByte1 |= 0xBF;
//		}
//		else
//		{
//			protectByte1 &= 0x40;
//			alarmByte1 &= 0x40;
//		}
		
		//保护
		//欠压保护
		//cell_uv+pack_uv+l0v
		if(((canMem[0].status_byte1 & 0x0202) != 0) || ((canMem[0].status_byte3 & 0x0008) != 0))
		{
			protectByte1 |= 0x20;
		}
		else
		{
			protectByte1 &= 0xDF;
		}
		
//		//过压保护
//		//cell_ov+pack_ov+pf
//		if((canMem[0].status_byte1 & 0x0141) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				protectByte1 |= 0x10;
//			}
//			else
//			{
//				protectByte1 &= 0xEF;
//			}
//		}
//		else
//		{
//			protectByte1 &= 0xEF;
//		}
		
		//低温保护
		//under temp at charging or discharging
		if(((canMem[0].status_byte2 & 0x0005) != 0) || ((canMem[0].status_byte4 & 0x0C0C) != 0))
		{
			protectByte1 |= 0x08;
		}
		else
		{
			protectByte1 &= 0xF7;
		}
		
		//过温保护
		//over temp at charging or discharging
		if(((canMem[0].status_byte2 & 0x000A) != 0) || ((canMem[0].status_byte4 & 0x0303) != 0))
		{
			protectByte1 |= 0x04;
		}
		else
		{
			protectByte1 &= 0xFB;
		}
		
		//放电过流保护
		//discharge over current，SC, OCD1, OCD2
		if( ((canMem[0].status_byte1 & 0x042c) != 0) || ((canMem[0].status_byte2 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0020) != 0))
		{
			protectByte1 |= 0x02;
		}
		else
		{
			protectByte1 &= 0xFD;
		}
		
		//充电过流保护
		//charge over current
		if( ((canMem[0].status_byte1 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0010) != 0))
		{
			protectByte1 |= 0x01;
		}
		else
		{
			protectByte1 &= 0xFE;
		}
		
		//告警
		//欠压告警
		if((canMem[0].status_byte3 & 0x0A00) != 0)
		{
			alarmByte1 |= 0x20;
		}
		else
		{
			alarmByte1 &= 0xDF;
		}
		
//		//过压告警
//		if((canMem[0].status_byte3 & 0x0500) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				alarmByte1 |= 0x10;
//			}
//			else
//			{
//				alarmByte1 &= 0xEF;
//			}
//		}
//		else
//		{
//			alarmByte1 &= 0xEF;
//		}
		
		//低温告警
		if(((canMem[0].status_byte2 & 0xCC00) != 0) || ((canMem[0].status_byte4 & 0xC000) != 0))
		{
			alarmByte1 |= 0x08;
		}
		else
		{
			alarmByte1 &= 0xF7;
		}
		
		//过温告警
		if(((canMem[0].status_byte2 & 0x3300) != 0) || ((canMem[0].status_byte4 & 0x3000) != 0))
		{
			alarmByte1 |= 0x04;
		}
		else
		{
			alarmByte1 &= 0xFB;
		}
		
		//放电过流告警
		if((canMem[0].status_byte3 & 0x2000) != 0)
		{
			alarmByte1 |= 0x02;
		}
		else
		{
			alarmByte1 &= 0xFD;
		}
		
		//充电过流告警
		if((canMem[0].status_byte3 & 0x1000) != 0)
		{
			alarmByte1 |= 0x01;
		}
		else
		{
			alarmByte1 &= 0xFE;
		}

		
	if(CAN_SendCount ==0) //ID = 0x321 - 最大充电电压、最小放电电压
	{
		//充放电电流限制需要有符号区别吗？
		chgVolLimit = bmsMem.inverter_chgVolLimit; //充电电压限制，上位机配置，默认值57.6V
		dsgVolLimit = bmsMem.inverter_dsgVolLimit; //放电电压限制，上位机配置，默认值41.6V
		
		data[0] = 0x00;
		data[1] = 0x00;
		data[2] = (chgVolLimit >> 8) & 0xFF;
		data[3] = chgVolLimit & 0xFF; //最大充电电压
		data[4] = 0x00;
		data[5] = 0x00;
		data[6] = (dsgVolLimit >> 8) & 0xFF;
		data[7] = dsgVolLimit & 0xFF; //最小放电电压
		CAN1_SendData(0x321, &data[0]);
	}
	if(CAN_SendCount ==1) //ID = 0x322 - 最大充电电流、最大放电电流
	{
		//充放电电流限制需要有符号区别吗？
		if(chg_forbidFlg == 1)
		{
			chgCurLimit = 0; //Schneider禁充
		}
		else if(chg_curlimitFlg == 1)
		{
			chgCurLimit = Inv_curlimit * (OnlineNum-chg_cur0Num); //限流40A*未保护个数
		}
		else
		{
			chgCurLimit = bmsMem.inverter_chgCurLimit * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
		}
		if(dsg_forbidFlg == 1)
		{
			dsgCurLimit = 0; //Schneider禁放
		}
		else
		{
			dsgCurLimit = bmsMem.inverter_dsgCurLimit * (OnlineNum-dsg_curLimitNum); //放电电流限制，上位机配置，默认值100A
		}
		
		data[0] = 0x00;
		data[1] = 0x00;
		data[2] = (chgCurLimit >> 8) & 0xFF;
		data[3] = chgCurLimit & 0xFF; //最大充电电流
		data[4] = 0x00;
		data[5] = 0x00;
		data[6] = (dsgCurLimit >> 8) & 0xFF; 
		data[7] = dsgCurLimit & 0xFF; //最大放电电流
		CAN1_SendData(0x322, &data[0]);
	}
	if(CAN_SendCount ==2) //ID = 0x323 - 电池电压、电流
	{
		tempVol = (int16_t)(bmsMem.packVoltage/10); //单位0.01
		tempCur = (int16_t)(canMem[0].cur/10); //单位0.1
		
		data[0] = 0x00;
		data[1] = 0x00;
		data[2] = (tempVol >>8) & 0xFF; //电池组电压 0.01
		data[3] =  tempVol & 0xFF;
		data[4] = 0x00;
		data[5] = 0x00;
		data[6] = (tempCur >>8) & 0xFF; //电池组电流 0.1
		data[7] =  tempCur & 0xFF;
		CAN1_SendData(0x323, &data[0]);
	}
	if(CAN_SendCount ==3) //ID = 0x324 - 温度、SOC
	{
		totalCapacity = 100 * ncc_Ah * OnlineNum; //单位0.01Ah
		T_Average = canMem[0].temp;// 平均温度
		
		data[0] = ((T_Average-2731) >>8) & 0xFF;
		data[1] =  (T_Average-2731) & 0xFF; //平均温度 0.1
		data[2] = 0x00;
		data[3] = canMem[0].soc & 0xFF;   //SOC
		data[4] = 0x00;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0x00;
		CAN1_SendData(0x324, &data[0]);
	}
	if(CAN_SendCount ==4) //ID = 0x325 - 允许位、报警/保护
	{
		RequestFlag = 0xC0; //充电允许0x02，放电允许0x04，不强充~0x01
		if(chg_forbidFlg == 1)//Schneider
		{
			RequestFlag &= 0xFD; //禁充
		}
		if(dsg_forbidFlg == 1)//Schneider
		{
			RequestFlag &= 0xFB; //禁放
		}
		if(chg_forceFlg == 1)//Schneider
		{
			RequestFlag |= 0x01; //强充
		}
		
		data[0] = RequestFlag; //充电允许放电允许
		data[1] = 0x00;
		data[2] = protectByte1;
		data[3] = 0x00;
		data[4] = alarmByte1;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0x00;
		CAN1_SendData(0x325, &data[0]);
	}
	if(CAN_SendCount ==5) //ID = 0x326 - SOH、满充容量
	{
		totalCapacity = 100 * ncc_Ah * OnlineNum; //单位0.01Ah
		
		data[0] = 0x00;
		data[1] = 0x00;
		data[2] = 0x00;
		data[3] = 0x00;
		data[4] = 0;
		data[5] = canMem[0].soh & 0xFF;  //SOH
		data[6] = (totalCapacity >> 8) & 0xFF;
		data[7] = totalCapacity & 0xFF; //电池满充容量 10mAh
		CAN1_SendData(0x326, &data[0]);
	}
	if(CAN_SendCount ==6) //ID = 0x327 - 电池最高/低温度、电池最高/低电压
	{
		T_Max = canMem[0].TempMax;	   // 最高温度
		T_Min = canMem[0].TempMin;	   // 最低温度
		cellVolMax = canMem[0].VolMax;
		cellVolMin = canMem[0].VolMin;
		
		data[0] = ((T_Max -2731) >> 8) & 0xFF;
		data[1] =  (T_Max -2731) & 0xFF;	//最大电池温度
		data[2] = ((T_Min -2731) >> 8) & 0xFF;
		data[3] =  (T_Min -2731) & 0xFF;	//最小电池温度
		data[4] =  (cellVolMax >> 8) & 0xFF;
		data[5] =   cellVolMax & 0xFF;	//最大电池电压
		data[6] =  (cellVolMin >> 8) & 0xFF;
		data[7] =   cellVolMin & 0xFF;	//最小电池电压
		CAN1_SendData(0x327, &data[0]);
	}
	
	if(CAN_SendCount>=7)
	{
		CAN_SendCount = 0;
	}
}

//AlpSolarr 力高
void CAN_Protocol_AlpSolarr(void)
{
	uint8_t   data[8];
	uint16_t  totalCapacity;
	
	uint16_t  tempVol;
	int16_t   tempCur;
	
	uint16_t  chgVolLimit;
	uint16_t  dsgVolLimit;
	int16_t   chgCurLimit;
	int16_t   dsgCurLimit;
	
	uint8_t   protectByte1 = 0;
	uint8_t   protectByte2 = 0;
	
	int16_t   T_Average; // 平均温度
	int16_t   T_Max;	   // 最高温度
	int16_t   T_Min;	   // 最低温度
	uint16_t  cellVolMax=0;	   // 电芯单体最高电压
	int16_t  	cellVolMin=0;	   // 电芯单体最低电压

		//BIT7 discharge over current，SC, OCD1, OCD2
		if( ((canMem[0].status_byte1 & 0x2c) !=0) || ((canMem[0].status_byte4 & 0x20) !=0) )
		{
			protectByte1 |= 0x80;
		}
		else
		{
			protectByte1 &= 0x7f;
		}
		
		//BIT4 cell under temp at charging or discharging
		//add mcu temp protect status
		if( ((canMem[0].status_byte2 & 0x05) !=0) || ((canMem[0].status_byte4 & 0x0C) !=0) )
		{
			protectByte1 |= 0x10;
		}
		else
		{
			protectByte1 &= 0xEF;
		}
		
		//BIT3 cell over temp at charging or discharging
		//add mcu temp protect status
		if( ((canMem[0].status_byte2 & 0x0A) !=0) || ((canMem[0].status_byte4 & 0x03) !=0) )
		{
			protectByte1 |= 0x08;
		}
		else
		{
			protectByte1 &= 0xF7;
		}
		
		//BIT2 cell uv
		if((canMem[0].status_byte1 & 0x02) !=0)
		{
			protectByte1 |= 0x04;
		}
		else
		{
			protectByte1 &= 0xfb;
		}
		
		//BIT1 cell ov
		if((canMem[0].status_byte1 & 0x01) !=0)
		{
			if(canMem[0].soc < 99)
			{
				protectByte1 |= 0x02;
			}
			else
			{
				protectByte1 &= 0xfd;
			}
		}
		else
		{
			protectByte1 &= 0xfd;
		}
		
		//BIT0 charge over current
		if( ((canMem[0].status_byte1 & 0x10) !=0) || ((canMem[0].status_byte4 & 0x10) !=0) )
		{
			protectByte2 |= 0x01;
		}
		else
		{
			protectByte2 &= 0xfe;
		}
		
//		//Data1 BIT4 cell balance
//		if((bmsMem.balanceStatus & 0x01) !=0)
//		{
//			protectByte2 |= 0x10;
//		}
//		else
//		{
//			protectByte2 &= 0xef;
//		}


	if(CAN_SendCount ==0) //ID=0x359
	{
		data[0] = protectByte1;
		data[1] = protectByte2;
		data[2] = protectByte1;
		data[3] = protectByte2;
		data[4] = 0X00;
		data[5] = 0X00;
		data[6] = 0X00;
		data[7] = 0X00;
		CAN1_SendData(0x359, &data[0]);
	}
	if(CAN_SendCount ==1) //ID = 0x351
	{
		//充放电电流限制需要有符号区别吗？
		chgVolLimit = bmsMem.inverter_chgVolLimit; //充电电压限制，上位机配置，默认值57.6V
		dsgVolLimit = bmsMem.inverter_dsgVolLimit; //放电电压限制，上位机配置，默认值41.6V
		
		if(chg_forbidFlg == 0)
		{
			chgCurLimit = bmsMem.inverter_chgCurLimit * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
		}
		else
		{
			chgCurLimit = 0; //禁充
		}
		if(dsg_forbidFlg == 0)
		{
			dsgCurLimit = bmsMem.inverter_dsgCurLimit * (OnlineNum-dsg_curLimitNum); //放电电流限制，上位机配置，默认值100A
		}
		else
		{
			dsgCurLimit = 0; //禁放
		}
		
		data[0] =  chgVolLimit & 0xFF;       //充电电压限制低位
		data[1] = (chgVolLimit >> 8) & 0xFF;
		data[2] =  chgCurLimit & 0xFF;       //充电电流限制低位
		data[3] = (chgCurLimit >> 8) & 0xFF;
		data[4] =  dsgCurLimit & 0xFF;       //放电电流限制低位
		data[5] = (dsgCurLimit >> 8) & 0xFF;
		data[6] =  dsgVolLimit & 0xFF;       //放电电压限制低位
		data[7] = (dsgVolLimit >> 8) & 0xFF;	
		CAN1_SendData(0x351, &data[0]);		
	}
	if(CAN_SendCount ==2)
	{
		data[0] = canMem[0].soc & 0xFF;  //SOC
		data[1] = 0;
		data[2] = canMem[0].soh & 0xFF;  //SOH
		data[3] = 0; 
		data[4] = 0X00;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0X00;
		CAN1_SendData(0x355, &data[0]);
	}
	if(CAN_SendCount ==3)
	{
		tempVol = (uint16_t)(bmsMem.packVoltage/10); //单位0.01
		tempCur = (int16_t)(canMem[0].cur/10); //单位0.1
		T_Average = canMem[0].temp;// 平均温度
		
		data[0] =  tempVol & 0xFF; 
		data[1] = (tempVol >>8) & 0xFF;  //电池包电压
		data[2] =  tempCur & 0xFF;
		data[3] = (tempCur >>8) & 0xFF;  //电池包电流
		data[4] =  (T_Average -2731) & 0xFF;;
		data[5] = ((T_Average -2731) >>8) & 0xFF;  //温度-暂时取平均温度，具体哪一路需要客户确认
		data[6] = 0x00;
		data[7] = 0X00;	
		CAN1_SendData(0x356, &data[0]);
	}
		if(CAN_SendCount ==4) //ID = 0x370 - 最大/最小单体温度，最大/最小单体电压（新加入）
	{
		T_Max = canMem[0].TempMax;	   // 最高温度
		T_Min = canMem[0].TempMin;	   // 最低温度
		cellVolMax = canMem[0].VolMax;
		cellVolMin = canMem[0].VolMin;
		
		data[0] =  (T_Max -2731) & 0xFF;       //最大单体温度
		data[1] = ((T_Max -2731) >> 8) & 0xFF;
		data[2] =  (T_Min -2731) & 0xFF;       //最小单体温度
		data[3] = ((T_Min -2731) >> 8) & 0xFF;
		data[4] =  cellVolMax & 0xFF;       //最大单体电压
		data[5] = (cellVolMax >> 8) & 0xFF;
		data[6] =  cellVolMin & 0xFF;       //最小单体电压
		data[7] = (cellVolMin >> 8) & 0xFF;
		CAN1_SendData(0x370, &data[0]);
	}
	if(CAN_SendCount ==5)
	{
		RequestFlag = 0xC0; //充电允许0x80，放电允许0x40，不强充~0x20
		if(chg_forbidFlg == 1)
		{
			RequestFlag &= 0x7F; //禁充
		}
		if(dsg_forbidFlg == 1)
		{
			RequestFlag &= 0xBF; //禁放
		}
		if(chg_forceFlg == 1)
		{
			RequestFlag |= 0x20; //强充
		}
		
		data[0] = RequestFlag;
		data[1] = 0x00;
		data[2] = 0x00;
		data[3] = 0x00; 
		data[4] = 0X00;
		data[5] = 0x00;
		data[6] = 0x00;
		data[7] = 0X00;	
		CAN1_SendData(0x35C, &data[0]);
	}
	if(CAN_SendCount ==6) //0x35E 
	{
		totalCapacity = fcc_Ah * OnlineNum; //单位1Ah
		
		data[0] = 0x00;       
		data[1] = 0x00;
		data[2] = 0x00;
		data[3] = 0x00; 
		data[4] = 0x00;
		data[5] = 0x00;
		data[6] =  totalCapacity & 0xFF;       
		data[7] = (totalCapacity >> 8) & 0xFF;
		CAN1_SendData(0x35E, &data[0]);
	}
//	if(CAN_SendCount ==7)
//	{
//		data[0] = 0xAA; 
//		data[1] = 0xAA;
//		data[2] = 0xAA;
//		data[3] = 0xAA; 
//		data[4] = 0xAA;
//		data[5] = 0xAA;
//		data[6] = 0xAA;
//		data[7] = 0xAA;	
//		CAN1_SendData(0x305, &data[0]);
//	}
	
	if(CAN_SendCount>=7)
	{
		CAN_SendCount = 0;
	}		
}

//MODBUS:
//SRNE 硕日 
void MOD_Protocol_SRNE(void)
{
	uint8_t i;
	uint16_t protectByte = 0; //0x0000-0xFFFF
	uint16_t alarmByte = 0;
	uint16_t statusByte = 0;
	
	
		//保护
//		//单体过压保护
//		//cell_ov+pack_ov+pf
//		if(((canMem[0].status_byte1 & 0x0001) != 0) || ((canMem[0].status_byte1 & 0x0040) != 0))
//	{
//		if(canMem[0].soc < 99)
//		{
//			alarmByte |= 0x0001;
//		}
//		else
//		{
//			alarmByte &= 0xFFFE;
//		}
//	}
//	else
//	{
//		alarmByte &= 0xFFFE;
//	}

		//单体欠压保护
		//cell_uv+pack_uv+l0v
		if(((canMem[0].status_byte1 & 0x0002) != 0) || ((canMem[0].status_byte3 & 0x0008) != 0))
		{
			alarmByte |= 0x0002;
		}
		else
		{
			alarmByte &= 0xFFFD;
		}

//	//总体过压保护
//	if((canMem[0].status_byte1 & 0x0100) != 0) 
//	{
//		alarmByte |= 0x0004;
//	}
//	else
//	{
//		alarmByte &= 0xFFFB;
//	}
	
		//总体欠压保护
		if((canMem[0].status_byte1 & 0x0200) != 0)
		{
			alarmByte |= 0x0008;
		}
		else
		{
			alarmByte &= 0xFFF7;
		}
		
		//充电过流保护
		//charge over current
		if( ((canMem[0].status_byte1 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0010) != 0))
		{
			protectByte |= 0x0010;
		}
		else
		{
			protectByte &= 0xFFEF;
		}
		
		//放电过流保护
		//discharge over current，SC, OCD1, OCD2
		if( ((canMem[0].status_byte1 & 0x042c) != 0) || ((canMem[0].status_byte2 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0020) != 0))
		{
			protectByte |= 0x0020;
		}
		else
		{
			protectByte &= 0xFFDF;
		}
		
		//充电高温保护
		//charge over temp 高温
		if( ((canMem[0].status_byte2 & 0x0002) !=0) || ((canMem[0].status_byte4 & 0x0101) !=0) )
		{
			protectByte |= 0x0100;
		}
		else
		{
			protectByte &= 0xFEFF;
		}
		
		//放电高温保护
		//discharge over temp 
		if( ((canMem[0].status_byte2 & 0x0008) !=0) || ((canMem[0].status_byte4 & 0x0202) !=0) ) 
		{
			protectByte |= 0x0200;
		}
		else
		{
			protectByte &= 0xFDFF;
		}
		
		//充电低温保护
		//charge under temp 低温
		if( ((canMem[0].status_byte2 & 0x0001) !=0) || ((canMem[0].status_byte4 & 0x0404) !=0) )
		{
			protectByte |= 0x0400;
		}
		else
		{
			protectByte &= 0xFBFF;
		}
		
		//放电低温保护
		//discharge under temp 
		if( ((canMem[0].status_byte2 & 0x0004) !=0) || ((canMem[0].status_byte4 & 0x0808) !=0) )
		{
			protectByte |= 0x0800;
		}
		else
		{
			protectByte &= 0xF7FF;
		}
		
	//环境低温保护 0x4000
		if((canMem[0].status_byte4 & 0x0C00) !=0)  //环境充放电低温
		{
			protectByte |= 0x4000;
		}
		else
		{
			protectByte &= 0xBFFF;
		}
	
	//环境高温保护 0x2000
		if((canMem[0].status_byte4 & 0x0300) !=0)  //环境充放电高温
		{
			protectByte |= 0x2000;
		}
		else
		{
			protectByte &= 0xDFFF;
		}

	//MOS高温保护  0x1000
		if((canMem[0].status_byte2 & 0x0300) !=0)  //MOS充放电高温
		{
			protectByte |= 0x1000;
		}
		else
		{
			protectByte &= 0xEFFF;
		}
		
		
		//告警
//		//单体过压告警
//		//cell_ov+pack_ov+pf
//		if((canMem[0].status_byte3 & 0x0100) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				alarmByte |= 0x0001;
//			}
//			else
//			{
//				alarmByte &= 0xFFFE;
//			}
//		}
//		else
//		{
//			alarmByte &= 0xFFFE;
//		}

		//单体欠压告警
		//cell_uv+pack_uv+l0v
		if((canMem[0].status_byte3 & 0x0200) != 0) 
		{
			alarmByte |= 0x0002;
		}
		else
		{
			alarmByte &= 0xFFFD;
		}
		
//	//总体过压告警
//	if((canMem[0].status_byte3 & 0x0400) != 0) 
//	{
//		alarmByte |= 0x0004;
//	}
//	else
//	{
//		alarmByte &= 0xFFFB;
//	}
	
		//总体欠压告警
		if((canMem[0].status_byte3 & 0x0800) != 0)
		{
			alarmByte |= 0x0008;
		}
		else
		{
			alarmByte &= 0xFFF7;
		}

		//充电过流告警
		//charge over current
		if((canMem[0].status_byte3 & 0x1000) != 0) 
		{
			alarmByte |= 0x0010;
		}
		else
		{
			alarmByte &= 0xFFEF;
		}
		
		//放电过流告警
		//discharge over current，SC, OCD1, OCD2
		if((canMem[0].status_byte3 & 0x0200) != 0) 
		{
			alarmByte |= 0x0020;
		}
		else
		{
			alarmByte &= 0xFFDF;
		}
		
		//充电高温告警
		//charge over temp 高温
		if( ((canMem[0].status_byte2 & 0x1100) !=0) || ((canMem[0].status_byte4 & 0x1000) !=0) )
		{
			alarmByte |= 0x0100;
		}
		else
		{
			alarmByte &= 0xFEFF;
		}
		
		//放电高温告警
		//discharge over temp 
		if( ((canMem[0].status_byte2 & 0x2200) !=0) || ((canMem[0].status_byte4 & 0x2000) !=0) ) 
		{
			alarmByte |= 0x0200;
		}
		else
		{
			alarmByte &= 0xFDFF;
		}
		
		//充电低温告警
		//charge under temp 低温
		if( ((canMem[0].status_byte2 & 0x4400) !=0) || ((canMem[0].status_byte4 & 0x4000) !=0) )
		{
			alarmByte |= 0x0400;
		}
		else
		{
			alarmByte &= 0xFBFF;
		}
		
		//放电低温告警
		//discharge under temp 
		if( ((canMem[0].status_byte2 & 0x8800) !=0) || ((canMem[0].status_byte4 & 0x8000) !=0) )
		{
			alarmByte |= 0x0800;
		}
		else
		{
			alarmByte &= 0xF7FF;
		}
		
		//环境低温告警 0x4000
		if((canMem[0].status_byte4 & 0xC000) !=0)  //环境充放电低温
		{
			alarmByte |= 0x4000;
		}
		else
		{
			alarmByte &= 0xBFFF;
		}
	
		//环境高温告警 0x2000
		if((canMem[0].status_byte4 & 0x3000) !=0)  //环境充放电高温
		{
			alarmByte |= 0x2000;
		}
		else
		{
			alarmByte &= 0xDFFF;
		}

		//MOS高温告警  0x1000
		if((canMem[0].status_byte2 & 0x3000) !=0)  //MOS充放电高温
		{
			alarmByte |= 0x1000;
		}
		else
		{
			alarmByte &= 0xEFFF;
		}

		
		SRNEMem.protect_byte = protectByte;	//保护标志	Hex	2byte
		SRNEMem.alarm_byte = alarmByte;		  //告警标志	Hex	2byte
		
		//状态位赋值
		if(bCHGING == 1) //充电
		{
			statusByte |= 0x0100;
		}
		else
		{
			statusByte &= 0xFEFF;
		}
		if(bDSGING == 1) //放电
		{
			statusByte |= 0x0200;
		}
		else
		{
			statusByte &= 0xFDFF;
		}
		if((canMem[0].status_byte3 & 0x02) !=0) //充电MOS状态
		{
			statusByte |= 0x0400;
		}
		else
		{
			statusByte &= 0xFBFF;
		}
		if((canMem[0].status_byte3 & 0x01) !=0) //放电MOS状态
		{
			statusByte |= 0x0800;
		}
		else
		{
			statusByte &= 0xF7FF;
		}
		SRNEMem.status_byte = statusByte;	//状态/故障标志	Hex	2byte
		
		
		SRNEMem.balanceStatus = bmsMem.balanceStatus;//平衡状态	Hex	2byte
		
		
	SRNEMem.packCurrent = (int16_t)(canMem[0].cur);	//电流	10mA	2byte
	SRNEMem.packVoltage = (uint16_t)(bmsMem.packVoltage/10);	//电池组电压	10mA	2byte
	
	SRNEMem.soc = (uint8_t)canMem[0].soc;					//SOC % 2byte
	SRNEMem.soh = (uint8_t)canMem[0].soh;         //SOH % 2byte
	
	SRNEMem.fcc = 100 * ncc_Ah * OnlineNum;					//满容量	10mAH	2byte
	SRNEMem.rcc = 100 * ncc_Ah * OnlineNum * SRNEMem.soc/100;					//剩余容量	10mAH	2byte
	
	
	//电芯电压
	for(i=0;i<16;i++)
	{
		SRNEMem.vCell[i] = bmsMem.vCell[i];		//电池电压	mV	32byte
	}
	//电芯温度
	SRNEMem.Tcell[0] = (int16_t)(bmsMem.mcu_T1-2731);			//电池温度	0.1℃	8byte
	SRNEMem.Tcell[1] = (int16_t)(bmsMem.mcu_T2-2731);
	SRNEMem.Tcell[2] = (int16_t)(bmsMem.mcu_T3-2731);
	SRNEMem.Tcell[3] = (int16_t)(bmsMem.mcu_T4-2731);
	
	SRNEMem.afe_MOS = (int16_t)((bmsMem.afe_T1 + bmsMem.afe_T2)/2 - 2731); //MOS温度 	0.1℃	2byte 对应上下MOS的温度平均值
	SRNEMem.afe_MCU = (int16_t)(bmsMem.afe_T3-2731);                       //环境温度	0.1℃	2byte 对应MCU芯片温度
	
	//充放电电流限制需要有符号区别吗？
	SRNEMem.chgVolLimit = bmsMem.inverter_chgVolLimit; //充电电压限制，上位机配置，默认值57.6V
	//SRNEMem.dsgVolLimit = bmsMem.inverter_dsgVolLimit; //放电电压限制，上位机配置，默认值41.6V
	
	if(chg_forbidFlg == 1)
	{
		SRNEMem.chgCurLimit = 0; //SRNE禁充
	}
	else if(chg_curlimitFlg == 1)
	{
		SRNEMem.chgCurLimit = Inv_curlimit * (OnlineNum-chg_cur0Num); //限流40A*未保护个数
	}
	else
	{
		SRNEMem.chgCurLimit = bmsMem.inverter_chgCurLimit * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
	}
	if(dsg_forbidFlg == 1)
	{
		SRNEMem.dsgCurLimit = 0; //SRNE禁放
	}
	else
	{
		SRNEMem.dsgCurLimit = bmsMem.inverter_dsgCurLimit * (OnlineNum-dsg_curLimitNum); //放电电流限制，上位机配置，默认值100A
	}
	
}

//Voltronic 日月元
void MOD_Protocol_Voltronic(void)
{
	uint8_t  i;
	
	uint16_t chg_alarm_byte = 0;
	uint16_t dsg_alarm_byte = 0;
	uint16_t chg_protect1_byte = 0;
	uint16_t dsg_protect1_byte = 0;
	
		//充电告警
		//充电过流告警
		//charge over current
		if((canMem[0].status_byte3 & 0x1000) !=0) 
		{
			chg_alarm_byte |= 0x0008;
		}
		else
		{
			chg_alarm_byte &= 0xFFF7;
		}
		
		//充电低温告警
		//charge under temp
		if( ((canMem[0].status_byte2 & 0x4400) !=0) || ((canMem[0].status_byte4 & 0x4000) !=0) )
		{
			chg_alarm_byte |= 0x0004;
		}
		else
		{
			chg_alarm_byte &= 0xFFFB;
		}

//		//过压告警
//		if((canMem[0].status_byte3 & 0x0500) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				chg_alarm_byte |= 0x0002;
//			}
//			else
//			{
//				chg_alarm_byte &= 0xFFFD;
//			}
//		}
//		else
//		{
//			chg_alarm_byte &= 0xFFFD;
//		}

		//充电高温告警
		//charge over temp
		if( ((canMem[0].status_byte2 & 0x1100) !=0) || ((canMem[0].status_byte4 & 0x1000) !=0) )
		{
			chg_alarm_byte |= 0x0001;
		}
		else
		{
			chg_alarm_byte &= 0xFFFE;
		}
		
		//放电告警
		//欠压告警
		if((canMem[0].status_byte3 & 0x0A00) != 0)
		{
			dsg_alarm_byte |= 0x0008;
		}
		else
		{
			dsg_alarm_byte &= 0xFFF7;
		}
		
		//MOS高温告警
		if((canMem[0].status_byte2 & 0x0200) != 0)
		{
			dsg_alarm_byte |= 0x0004;
		}
		else
		{
			dsg_alarm_byte &= 0xFFFB;
		}
		
		//放电低温告警
		//discharge under temp
		if( ((canMem[0].status_byte2 & 0x8800) !=0) || ((canMem[0].status_byte4 & 0x8000) !=0) )
		{
			dsg_alarm_byte |= 0x0002;
		}
		else
		{
			dsg_alarm_byte &= 0xFFFD;
		}
		
		//放电高温告警
		//discharge over temp
		if( ((canMem[0].status_byte2 & 0x2200) !=0) || ((canMem[0].status_byte4 & 0x2000) !=0) )
		{
			dsg_alarm_byte |= 0x0001;
		}
		else
		{
			dsg_alarm_byte &= 0xFFFE;
		}
		
		//保护
		//充电保护1
		//充电过流保护
		//charge over current
		if( ((canMem[0].status_byte1 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0010) != 0))
		{
			chg_protect1_byte |= 0x0800;
		}
		else
		{
			chg_protect1_byte &= 0xF7FF;
		}
		
			//过压保护
//		//cell_ov+pack_ov+pf
//		if((canMem[0].status_byte1 & 0x0141) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				chg_protect1_byte |= 0x0400;
//			}
//			else
//			{
//				chg_protect1_byte &= 0xFBFF;
//			}
//		}
//		else
//		{
//			chg_protect1_byte &= 0xFBFF;
//		}

		//充电低温保护
		//charge under temp
		if( ((canMem[0].status_byte2 & 0x0001) !=0) || ((canMem[0].status_byte4 & 0x0404) !=0) )
		{
			chg_protect1_byte |= 0x0200;
		}
		else
		{
			chg_protect1_byte &= 0xFBFF;
		}

		//充电高温保护
		//charge over temp
		if( ((canMem[0].status_byte2 & 0x0002) !=0) || ((canMem[0].status_byte4 & 0x0101) !=0) )
		{
			chg_protect1_byte |= 0x0100;
		}
		else
		{
			chg_protect1_byte &= 0xFEFF;
		}
		
		//MOS高温保护
		if((canMem[0].status_byte2 & 0x0100) != 0)
		{
			dsg_alarm_byte |= 0x0040;
		}
		else
		{
			dsg_alarm_byte &= 0xFFBF;
		}

		//放电保护1
		//放电高温保护
		//discharge over temp
		if( ((canMem[0].status_byte2 & 0x0008) !=0) || ((canMem[0].status_byte4 & 0x0202) !=0) )
		{
			dsg_protect1_byte |= 0x4000;
		}
		else
		{
			dsg_protect1_byte &= 0xBFFF;
		}
		
		//放电低温保护
		//discharge under temp
		if( ((canMem[0].status_byte2 & 0x0004) !=0) || ((canMem[0].status_byte4 & 0x0808) !=0) )
		{
			dsg_protect1_byte |= 0x2000;
		}
		else
		{
			dsg_protect1_byte &= 0xBFFF;
		}
		
		//放电过流保护
		//discharge over current，SC, OCD1, OCD2
		if( ((canMem[0].status_byte1 & 0x042c) !=0) || ((canMem[0].status_byte2 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0020) !=0) )
		{
			dsg_protect1_byte |= 0x1000;
		}
		else
		{
			dsg_protect1_byte &= 0xEFFF;
		}
		
		//欠压保护
		//cell_uv+pack_uv+l0v
		if(((canMem[0].status_byte1 & 0x0202) != 0) || ((canMem[0].status_byte3 & 0x0008) != 0))
		{
			dsg_protect1_byte |= 0x0800;
		}
		else
		{
			dsg_protect1_byte &= 0xF7FF;
		}
		
		RequestFlag = 0x00C0; //充电允许0x0080，放电允许0x0040，不强充~0x0020
		if(chg_forbidFlg == 1)//Voltronic
		{
			RequestFlag &= 0xFF7F; //禁充
		}
		if(dsg_forbidFlg == 1)//Voltronic
		{
			RequestFlag &= 0xFFBF; //禁放
		}
		if(chg_forceFlg == 1)//Voltronic
		{
			RequestFlag |= 0x0020; //强充
		}
		
		
		VoltronicMem.chg_alarm_byte = chg_alarm_byte;     // 充电报警
		VoltronicMem.dsg_alarm_byte = dsg_alarm_byte;     // 放电报警
		VoltronicMem.chg_protect1_byte = chg_protect1_byte; // 充电保护
		VoltronicMem.dsg_protect1_byte = dsg_protect1_byte; // 放电保护
		VoltronicMem.status_byte = RequestFlag; // 充放电允许
		
		
	//常规数据填充
	VoltronicMem.protocolType = 0x0000;
	VoltronicMem.protocolVer  = 0x0100;
	VoltronicMem.SoftwareH = VersionMem.Software[0]<<8 | VersionMem.Software[1];
	VoltronicMem.SoftwareL = VersionMem.Software[2]<<8 | VersionMem.Software[3];
	VoltronicMem.HardwareH = VersionMem.Hardware[0];
	VoltronicMem.HardwareL = VersionMem.Hardware[1]<<8 | VersionMem.Hardware[2];
	
	//实时数据
	VoltronicMem.packNum = OnlineNum;
	
	VoltronicMem.cellNum = bmsMem.ucCellNum;
	VoltronicMem.tempNum = 6;
	
	//电芯电压
	for(i=0;i<16;i++)
	{
		VoltronicMem.cellVol[i] = bmsMem.vCell[i]/100; //电池电压	0.1V
	}
	//电芯温度
	VoltronicMem.T[0] = bmsMem.mcu_T1; //电池温度	0.1K
	VoltronicMem.T[1] = bmsMem.mcu_T2;
	VoltronicMem.T[2] = bmsMem.mcu_T3;
	VoltronicMem.T[3] = bmsMem.mcu_T4;
	VoltronicMem.T[4] = bmsMem.afe_T3;
	VoltronicMem.T[5] = (bmsMem.afe_T1 + bmsMem.afe_T2)/2;
	
	if(bCHGING==1)
	{
		VoltronicMem.chg_packCurrent = (uint16_t)(canMem[0].cur/10); //充电电流	0.1A 2byte
		VoltronicMem.dsg_packCurrent = 0;
	}
	else
  {
		VoltronicMem.dsg_packCurrent = (uint16_t)(-canMem[0].cur/10); //放电电流	0.1A 2byte
		VoltronicMem.chg_packCurrent = 0;
	}
	VoltronicMem.packVoltage = (uint16_t)(bmsMem.packVoltage/100); //模块电压 0.1V 2byte
	
	//mAH /3600
	VoltronicMem.soc = canMem[0].soc;					               //SOC	%	2byte
	VoltronicMem.fccH = ((1000 * ncc_Ah * OnlineNum)>>16) & 0xFFFF;                        //满容量 mAH	4byte
	VoltronicMem.fccL =  (1000 * ncc_Ah * OnlineNum) & 0xFFFF;
	VoltronicMem.rccH = ((1000 * ncc_Ah * OnlineNum * VoltronicMem.soc/100)>>16) & 0xFFFF; //剩余容量 mAH	4byte
	VoltronicMem.rccL =  (1000 * ncc_Ah * OnlineNum * VoltronicMem.soc/100) & 0xFFFF;
	
	VoltronicMem.chgVolLimit = bmsMem.inverter_chgVolLimit; //充电电压限制，上位机配置，默认值57.6V
	VoltronicMem.dsgVolLimit = bmsMem.inverter_dsgVolLimit; //放电电压限制，上位机配置，默认值41.6V
	
	if(chg_forbidFlg == 1)
	{
		VoltronicMem.chgCurLimit = 0; //Voltronic禁充
	}
	else if(chg_curlimitFlg == 1)
	{
		VoltronicMem.chgCurLimit = Inv_curlimit * (OnlineNum-chg_cur0Num); //限流40A*未保护个数
	}
	else
	{
		VoltronicMem.chgCurLimit = bmsMem.inverter_chgCurLimit * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
	}
	if(dsg_forbidFlg == 1)
	{
		VoltronicMem.dsgCurLimit = 0; //Voltronic禁放
	}
	else
	{
		VoltronicMem.dsgCurLimit = bmsMem.inverter_dsgCurLimit * (OnlineNum-dsg_curLimitNum); //放电电流限制，上位机配置，默认值100A
	}
	
	
	VoltronicMem.cellNum2 = bmsMem.ucCellNum;
	VoltronicMem.tempNum2 = 6;
	
	//各种状态位，0xF0表示未实现
	for(i=0;i<10;i++)
	{
		VoltronicMem.Vol_status[i]=0xF0;
	}
	for(i=0;i<5;i++)
	{
		VoltronicMem.T_status[i]=0xF0;
	}
	for(i=0;i<10;i++)
	{
		VoltronicMem.other_status[i]=0xF0;
	}
	
}

//COSUPER 古顶
void MOD_Protocol_COSUPER(void)
{
	uint8_t i;
	uint16_t protectByte = 0; //0x0000-0xFFFF
	uint16_t alarmByte = 0;
	uint16_t statusByte = 0;
	
	
		//保护
//		//单体过压保护
//		//cell_ov+pack_ov+pf
//		if(((canMem[0].status_byte1 & 0x0001) != 0) || ((canMem[0].status_byte1 & 0x0040) != 0))
//	{
//		if(canMem[0].soc < 99)
//		{
//			alarmByte |= 0x0001;
//		}
//		else
//		{
//			alarmByte &= 0xFFFE;
//		}
//	}
//	else
//	{
//		alarmByte &= 0xFFFE;
//	}

		//单体欠压保护
		//cell_uv+pack_uv+l0v
		if(((canMem[0].status_byte1 & 0x0002) != 0) || ((canMem[0].status_byte3 & 0x0008) != 0))
		{
			alarmByte |= 0x0002;
		}
		else
		{
			alarmByte &= 0xFFFD;
		}

//	//总体过压保护
//	if((canMem[0].status_byte1 & 0x0100) != 0) 
//	{
//		alarmByte |= 0x0004;
//	}
//	else
//	{
//		alarmByte &= 0xFFFB;
//	}
	
		//总体欠压保护
		if((canMem[0].status_byte1 & 0x0200) != 0)
		{
			alarmByte |= 0x0008;
		}
		else
		{
			alarmByte &= 0xFFF7;
		}
		
		//充电过流保护
		//charge over current
		if( ((canMem[0].status_byte1 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0010) != 0))
		{
			protectByte |= 0x0010;
		}
		else
		{
			protectByte &= 0xFFEF;
		}
		
		//放电过流保护
		//discharge over current，SC, OCD1, OCD2
		if( ((canMem[0].status_byte1 & 0x042c) != 0) || ((canMem[0].status_byte2 & 0x0010) != 0) || ((canMem[0].status_byte4 & 0x0020) != 0))
		{
			protectByte |= 0x0020;
		}
		else
		{
			protectByte &= 0xFFDF;
		}
		
		//充电高温保护
		//charge over temp 高温
		if( ((canMem[0].status_byte2 & 0x0002) !=0) || ((canMem[0].status_byte4 & 0x0101) !=0) )
		{
			protectByte |= 0x0100;
		}
		else
		{
			protectByte &= 0xFEFF;
		}
		
		//放电高温保护
		//discharge over temp 
		if( ((canMem[0].status_byte2 & 0x0008) !=0) || ((canMem[0].status_byte4 & 0x0202) !=0) ) 
		{
			protectByte |= 0x0200;
		}
		else
		{
			protectByte &= 0xFDFF;
		}
		
		//充电低温保护
		//charge under temp 低温
		if( ((canMem[0].status_byte2 & 0x0001) !=0) || ((canMem[0].status_byte4 & 0x0404) !=0) )
		{
			protectByte |= 0x0400;
		}
		else
		{
			protectByte &= 0xFBFF;
		}
		
		//放电低温保护
		//discharge under temp 
		if( ((canMem[0].status_byte2 & 0x0004) !=0) || ((canMem[0].status_byte4 & 0x0808) !=0) )
		{
			protectByte |= 0x0800;
		}
		else
		{
			protectByte &= 0xF7FF;
		}
		
	//环境低温保护 0x4000
		if((canMem[0].status_byte4 & 0x0C00) !=0)  //环境充放电低温
		{
			protectByte |= 0x4000;
		}
		else
		{
			protectByte &= 0xBFFF;
		}
	
	//环境高温保护 0x2000
		if((canMem[0].status_byte4 & 0x0300) !=0)  //环境充放电高温
		{
			protectByte |= 0x2000;
		}
		else
		{
			protectByte &= 0xDFFF;
		}

	//MOS高温保护  0x1000
		if((canMem[0].status_byte2 & 0x0300) !=0)  //MOS充放电高温
		{
			protectByte |= 0x1000;
		}
		else
		{
			protectByte &= 0xEFFF;
		}
		
		
		//告警
//		//单体过压告警
//		//cell_ov+pack_ov+pf
//		if((canMem[0].status_byte3 & 0x0100) != 0)
//		{
//			if(canMem[0].soc < 99)
//			{
//				alarmByte |= 0x0001;
//			}
//			else
//			{
//				alarmByte &= 0xFFFE;
//			}
//		}
//		else
//		{
//			alarmByte &= 0xFFFE;
//		}

		//单体欠压告警
		//cell_uv+pack_uv+l0v
		if((canMem[0].status_byte3 & 0x0200) != 0) 
		{
			alarmByte |= 0x0002;
		}
		else
		{
			alarmByte &= 0xFFFD;
		}
		
//	//总体过压告警
//	if((canMem[0].status_byte3 & 0x0400) != 0) 
//	{
//		alarmByte |= 0x0004;
//	}
//	else
//	{
//		alarmByte &= 0xFFFB;
//	}
	
		//总体欠压告警
		if((canMem[0].status_byte3 & 0x0800) != 0)
		{
			alarmByte |= 0x0008;
		}
		else
		{
			alarmByte &= 0xFFF7;
		}

		//充电过流告警
		//charge over current
		if((canMem[0].status_byte3 & 0x1000) != 0) 
		{
			alarmByte |= 0x0010;
		}
		else
		{
			alarmByte &= 0xFFEF;
		}
		
		//放电过流告警
		//discharge over current，SC, OCD1, OCD2
		if((canMem[0].status_byte3 & 0x0200) != 0) 
		{
			alarmByte |= 0x0020;
		}
		else
		{
			alarmByte &= 0xFFDF;
		}
		
		//充电高温告警
		//charge over temp 高温
		if( ((canMem[0].status_byte2 & 0x1100) !=0) || ((canMem[0].status_byte4 & 0x1000) !=0) )
		{
			alarmByte |= 0x0100;
		}
		else
		{
			alarmByte &= 0xFEFF;
		}
		
		//放电高温告警
		//discharge over temp 
		if( ((canMem[0].status_byte2 & 0x2200) !=0) || ((canMem[0].status_byte4 & 0x2000) !=0) ) 
		{
			alarmByte |= 0x0200;
		}
		else
		{
			alarmByte &= 0xFDFF;
		}
		
		//充电低温告警
		//charge under temp 低温
		if( ((canMem[0].status_byte2 & 0x4400) !=0) || ((canMem[0].status_byte4 & 0x4000) !=0) )
		{
			alarmByte |= 0x0400;
		}
		else
		{
			alarmByte &= 0xFBFF;
		}
		
		//放电低温告警
		//discharge under temp 
		if( ((canMem[0].status_byte2 & 0x8800) !=0) || ((canMem[0].status_byte4 & 0x8000) !=0) )
		{
			alarmByte |= 0x0800;
		}
		else
		{
			alarmByte &= 0xF7FF;
		}
		
		//环境低温告警 0x4000
		if((canMem[0].status_byte4 & 0xC000) !=0)  //环境充放电低温
		{
			alarmByte |= 0x4000;
		}
		else
		{
			alarmByte &= 0xBFFF;
		}
	
		//环境高温告警 0x2000
		if((canMem[0].status_byte4 & 0x3000) !=0)  //环境充放电高温
		{
			alarmByte |= 0x2000;
		}
		else
		{
			alarmByte &= 0xDFFF;
		}

		//MOS高温告警  0x1000
		if((canMem[0].status_byte2 & 0x3000) !=0)  //MOS充放电高温
		{
			alarmByte |= 0x1000;
		}
		else
		{
			alarmByte &= 0xEFFF;
		}

		
		SRNEMem.protect_byte = protectByte;	//保护标志	Hex	2byte
		SRNEMem.alarm_byte = alarmByte;		  //告警标志	Hex	2byte
		
		//状态位赋值
		if(bCHGING == 1) //充电
		{
			statusByte |= 0x0100;
		}
		else
		{
			statusByte &= 0xFEFF;
		}
		if(bDSGING == 1) //放电
		{
			statusByte |= 0x0200;
		}
		else
		{
			statusByte &= 0xFDFF;
		}
		if((canMem[0].status_byte3 & 0x02) !=0) //充电MOS状态
		{
			statusByte |= 0x0400;
		}
		else
		{
			statusByte &= 0xFBFF;
		}
		if((canMem[0].status_byte3 & 0x01) !=0) //放电MOS状态
		{
			statusByte |= 0x0800;
		}
		else
		{
			statusByte &= 0xF7FF;
		}
		SRNEMem.status_byte = statusByte;	//状态/故障标志	Hex	2byte
		
		
		SRNEMem.balanceStatus = bmsMem.balanceStatus;//平衡状态	Hex	2byte
		
		
	SRNEMem.packCurrent = (int16_t)(canMem[0].cur);	//电流	10mA	2byte
	SRNEMem.packVoltage = (uint16_t)(bmsMem.packVoltage/10);	//电池组电压	10mA	2byte
	
	SRNEMem.soc = (uint8_t)canMem[0].soc;					//SOC %	2byte
	SRNEMem.soh = (uint8_t)canMem[0].soh;         //SOH %	2byte
	
	SRNEMem.fcc = 100 * ncc_Ah * OnlineNum;					//满容量	10mAH	2byte
	SRNEMem.rcc = 100 * ncc_Ah * OnlineNum * SRNEMem.soc/100;					//剩余容量	10mAH	2byte
	
	
	//电芯电压
	if( bmsMem.ucCellNum == 8) //板子设定为8串
	{
		for(i=0;i<8;i++)
		{
			SRNEMem.vCell[i] = bmsMem.vCell[i];		//电池电压	mV	32byte
		}
		for(i=0;i<8;i++)
		{
			SRNEMem.vCell[8+i] = bmsMem.vCell[i];		//电池电压	mV	32byte
		}
	}
	else //其他默认为16串
	{
		for(i=0;i<16;i++)
		{
			SRNEMem.vCell[i] = bmsMem.vCell[i];		//电池电压	mV	32byte
		}
	}
	
	//电芯温度
	SRNEMem.Tcell[0] = (int16_t)(bmsMem.mcu_T1-2731);			//电池温度	0.1℃	8byte
	SRNEMem.Tcell[1] = (int16_t)(bmsMem.mcu_T2-2731);
	SRNEMem.Tcell[2] = (int16_t)(bmsMem.mcu_T3-2731);
	SRNEMem.Tcell[3] = (int16_t)(bmsMem.mcu_T4-2731);
	
	SRNEMem.afe_MOS = (int16_t)((bmsMem.afe_T1 + bmsMem.afe_T2)/2 - 2731); //MOS温度 	0.1℃	2byte 对应上下MOS的温度平均值
	SRNEMem.afe_MCU = (int16_t)(bmsMem.afe_T3-2731);                       //环境温度	0.1℃	2byte 对应MCU芯片温度
	
	//充放电电流限制需要有符号区别吗？
	SRNEMem.chgVolLimit = bmsMem.inverter_chgVolLimit; //充电电压限制，上位机配置，默认值57.6V
	//SRNEMem.dsgVolLimit = bmsMem.inverter_dsgVolLimit; //放电电压限制，上位机配置，默认值41.6V
	
	if(chg_forbidFlg == 1)
	{
		SRNEMem.chgCurLimit = 0; //COSUPER禁充
	}
	else if(chg_curlimitFlg == 1)
	{
		SRNEMem.chgCurLimit = Inv_curlimit * (OnlineNum-chg_cur0Num); //限流40A*未保护个数
	}
	else
	{
		SRNEMem.chgCurLimit = bmsMem.inverter_chgCurLimit * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
	}
	if(dsg_forbidFlg == 1)
	{
		SRNEMem.dsgCurLimit = 0; //COSUPER禁放
	}
	else
	{
		SRNEMem.dsgCurLimit = bmsMem.inverter_dsgCurLimit * (OnlineNum-dsg_curLimitNum); //放电电流限制，上位机配置，默认值100A
	}
	
}

//SMK 
void MOD_Protocol_SMK(void)
{
	RequestFlag = 0x0060; //充电允许0x0040，放电允许0x0020，不强充~0x1000
	if(chg_forbidFlg == 1)//SMK
	{
		RequestFlag &= 0xFFBF; //禁充
	}
	if(dsg_forbidFlg == 1)//SMK
	{
		RequestFlag &= 0xFFDF; //禁放
	}
	if(chg_forceFlg == 1)//SMK
	{
		RequestFlag |= 0x1000; //强充
	}
	
	SMKMem.status_byte = RequestFlag;       //状态：bit6充电禁止bit5放电禁止
	SMKMem.soc = (uint8_t)canMem[0].soc;	 //SOC	%	2byte	
	SMKMem.rcc = 100 * ncc_Ah * OnlineNum * SMKMem.soc/100;//剩余容量	10mAH	2byte
	SMKMem.fcc = 100 * ncc_Ah * OnlineNum;					       //额定容量	10mAH	2byte
  SMKMem.packVoltage = (int16_t)(bmsMem.packVoltage/10); //模块电压 10mV 2byte
	SMKMem.packCurrent = (int16_t)(canMem[0].cur);	       //模块电流	10mA 2byte
	
	SMKMem.chgVolLimit = bmsMem.inverter_chgVolLimit * 10;                       //充电电压限制，上位机配置，默认值57.6V
	if(chg_forbidFlg == 1)
	{
		SMKMem.chgCurLimit = 0; //SMK禁充
	}
	else if(chg_curlimitFlg == 1)
	{
		SMKMem.chgCurLimit = Inv_curlimit * (OnlineNum-chg_cur0Num); //限流40A*未保护个数
	}
	else
	{
		SMKMem.chgCurLimit = (bmsMem.inverter_chgCurLimit * 10) * (OnlineNum-chg_curLimitNum); //充电电流限制，上位机配置，默认值100A
	}
	if(dsg_forbidFlg == 1)
	{
		SMKMem.dcsCurLimit = 0; //SMK禁放
	}
	else
	{
		SMKMem.dcsCurLimit = (bmsMem.inverter_dsgCurLimit * 10) * (OnlineNum-chg_curLimitNum); //放电电流限制，上位机配置，默认值100A
	}
	
}

//SAKO 三科
void MOD_Protocol_SAKO(void)
{
	MOD_Protocol_Voltronic();
}

//SNADI 佛山斯奈特
void MOD_Protocol_SNADI(void)
{
	
}

//invt 英威腾
void MOD_Protocol_invt(void)
{
	
}