import socket from "./socket.js";
const RandomLeft = 6
const RandomRight = 3
let sendRandomData = new Uint32Array(1) //随机数
let bushu = 0
 // sendRandomData[0] = 0xABCDEF12
//加密
//uword RandomData  随机数，
//ubyte *DataBuf    传入数据
//ubyte *Ciphertext 密文
//uword Length      传入数据长度
function fnEncryption(RandomData, DataBuf, Ciphertext,Length) {
	let fnencryptioni = 0;
	let fnencryptionDate = new Uint8Array(4);
	for (fnencryptioni = 0; fnencryptioni < 4; fnencryptioni++) //32位随机数存放于4个字节的数组里面
	{
		fnencryptionDate[fnencryptioni] = (RandomData >> (8 * fnencryptioni));
	} 
	for (fnencryptioni = 0; fnencryptioni < Length; fnencryptioni++) //每个数据进行加密
	{
		Ciphertext[fnencryptioni] = DataBuf[fnencryptioni] ^ fnencryptionDate[fnencryptioni % 4];
		Ciphertext[fnencryptioni] = Ciphertext[fnencryptioni] ^ ((fnencryptionDate[fnencryptioni % 4] >> RandomRight) |
			(fnencryptionDate[fnencryptioni % 4] << (8 - RandomRight))); //与上循环右移3位
		Ciphertext[fnencryptioni] = Ciphertext[fnencryptioni] ^ ((fnencryptionDate[fnencryptioni % 4] << RandomLeft) | (
			fnencryptionDate[fnencryptioni % 4] >> (8 - RandomLeft))); //异或循环左移6    
	}
}
//解密
//uword RandomData 随机数
//ubyte *DataBuf   传入数据
//ubyte *Plaintext 明文
//uword Length     传入数据长度	
function fnDecrypt( RandomData, DataBuf, Plaintext, Length)
	{
	    let fnencryptioni = 0;
	    let fnencryptionDate = new Uint8Array(4);
		
	    //---------------------------------------------------------------------------------------------
	    for (fnencryptioni = 0; fnencryptioni < 4; fnencryptioni++)
	    {
	        fnencryptionDate[fnencryptioni] = (RandomData >> (8 * fnencryptioni));
	    }
		
	    for (fnencryptioni = 0; fnencryptioni < Length; fnencryptioni++)
	    {
	        Plaintext[fnencryptioni] = DataBuf[fnencryptioni] ^ ((fnencryptionDate[fnencryptioni % 4] << RandomLeft) | (fnencryptionDate[fnencryptioni % 4] >> 2));    //异或循环左移6
	        Plaintext[fnencryptioni] = Plaintext[fnencryptioni] ^ ((fnencryptionDate[fnencryptioni % 4] >> RandomRight) | (fnencryptionDate[fnencryptioni % 4] << 5)); //与上循环右移3位
	        Plaintext[fnencryptioni] = Plaintext[fnencryptioni] ^ fnencryptionDate[fnencryptioni % 4];
		}
		
}


//页面跳转处理状态机
let pageState = new Uint8Array(1);
pageState[0] = 0;
let pageOldState = new Uint8Array(1);
pageOldState[0] = 0;
let Rgstate = new Uint8Array(1);
Rgstate[0] = 0;

function statePageJump() {
	switch (Rgstate[0]) {
		case 0:
			pageOldState[0] = pageState[0];
			Rgstate[0] = 1;
			// console.log("state:" + Rgstate[0])
			break;
		case 1: //默认在视频播放页面
			if (pageOldState[0] != pageState[0]) //说明页面已经切换
			{
				pageOldState[0] = pageState[0];
				Rgstate[0] = 2;
				// console.log("state:" + Rgstate[0])
			} else {
				Rgstate[0] = 1;
				// console.log("state:" + Rgstate[0])
			}
			break;
		case 2:
			if (pageOldState[0] != pageState[0]) //说明页面已经切换
			{
				pageOldState[0] = pageState[0];
				Rgstate[0] = 2;
			} else {
				//发送信号给APP.vue
				uni.$emit('PageJump', { 
					Rgstate:Rgstate[0],
					pageState:pageState[0], 
					pageOldState:pageOldState[0]
					});
				Rgstate[0] = 1;
				 console.log("state:" + Rgstate[0])
			}
			break;
		default:
			break;
	}
}

// 60s会被操作系统调用一次，处理逻辑写到这里，闹钟响，你需要做的事情写下面
let cntTimer60s = 0;
function CallbackTimer60s() {
	statePageJump(); //调用页面跳转处理状态机
	//这个不能动
	cntTimer60s = cntTimer60s + 1;
	// console.log("cntTimer60s:" + cntTimer60s)
}

// 1000ms会被操作系统调用一次，处理逻辑写到这里，闹钟响，你需要做的事情写下面
let cntTimer1000 = 0;
function CallbackTimer1000ms() {
	// console.log(cntTimer1000);
	// CallbackSendDataFFBB(); //发送个字节数据到UDP
	// CallbackSendDataFFDD(); //发送12个字节
	// CallbackSendDataFFCC(); //发送441个字节数据到UDP
	//这个不能动
	cntTimer1000 = cntTimer1000 + 1;
}

//定时器100mm，100ms会被操作系统调用一次，处理逻辑写到这里
let cntTimer100 = 0;
function CallbackTimer100ms() {
	// console.log("cntTimer100:" + cntTimer100);
	CallbackSendDataFFBB(); //发送个字节数据到UDP
	CallbackSendDataFFDD(); //发送12个字节
	CallbackSendDataFFCC(); //发送441个字节数据到UDP
	//这个不能动 
	cntTimer100 = cntTimer100 + 1;
}


let accFFBB = 0; //累加
//定义位运算结构体对象
let FFBB_Byte06 = {
	AutomaticAndManual: 0x0, //模式选择
	StartAndStop: 0, //启动和停止
	Reset: 0, //复位
	StepBack0: 0, //步进回零
	SignOut: 0, //出签
	WaterPump: 0 //水泵
}
let glbFFBB_Byte06 = new Object(FFBB_Byte06) // new个对象传给vue
let FFBB_Byte07 = {
	PowerDoors: 0, //电动门
	Fan: 0, //风机
	SugarControlMotor_1: 0, //控糖电机1
	SugarControlMotor_2: 0, //控糖电机2
	SugarControlMotor_3: 0, //控糖电机3
	SugarControlMotor_4: 0, //控糖电机4
	Humidification: 0 //加湿
}
let glbFFBB_Byte07 = new Object(FFBB_Byte07)
let FFBB_Byte08 = {
	SugarHead: 0, //糖头启动和停止 
	Heating: 0, //加热启动和停止
	StartUp: 0, //开机和关机
	X_axis: 0 //X轴
}
let glbFFBB_Byte08 = new Object(FFBB_Byte08)
let FFBB_Byte09 = {
	Y_axis: 0, //Y轴
	Z_axis: 0, //Z轴
	R_axis: 0, //R轴
	ROG_axis: 0 //ROG轴
}
let glbFFBB_Byte09 = new Object(FFBB_Byte09)
let SetSteps = new Uint8Array(1); //设置步数
let FFBB_Byte11 = {
	SingleStep: 0, //单步
	StepPositionWrite: 0 //步数位置写入 
}
let glbFFBB_Byte11 = new Object(FFBB_Byte11)
 
let SugarType = new Uint8Array(1); //棉花糖类型
SugarType[0] = 0x01
 
//定义IP和port 
let ip = '192.168.17.20' //目标ip	
let port = '8011' //目标端口
let localPort = '8012' //本机端口

//发送18个字节
function CallbackSendDataFFBB() {
	let bitCalculate = new Uint8Array(1); //第6字节
	let data = ['FF', 'BB', '00', '11', '16']; //帧头
	accFFBB = accFFBB + 1; //累加
	data.push(accFFBB.toString(16))
	//组装成第6字节
	bitCalculate =
		glbFFBB_Byte06.AutomaticAndManual +
		((glbFFBB_Byte06.StartAndStop & 0b00000011) << 1) +
		((glbFFBB_Byte06.Reset & 0b00000001) << 3) +
		((glbFFBB_Byte06.StepBack0 & 0b00000001) << 4) +
		((glbFFBB_Byte06.SignOut & 0b00000011) << 5) +
		((glbFFBB_Byte06.WaterPump & 0b00000001) << 7)
	data.push(bitCalculate.toString(16))
	//组装成第7字节
	bitCalculate =
		((glbFFBB_Byte07.PowerDoors & 0b00000011) << 0) +
		((glbFFBB_Byte07.Fan & 0b00000001) << 2) +
		((glbFFBB_Byte07.SugarControlMotor_1 & 0b00000001) << 3) +
		((glbFFBB_Byte07.SugarControlMotor_2 & 0b00000001) << 4) +
		((glbFFBB_Byte07.SugarControlMotor_3 & 0b00000001) << 5) +
		((glbFFBB_Byte07.SugarControlMotor_4 & 0b00000001) << 6) +
		((glbFFBB_Byte07.Humidification & 0b00000001) << 7)
	data.push(bitCalculate.toString(16))
	//组装成第8字节
	bitCalculate =
		((glbFFBB_Byte08.SugarHead & 0b00000011) << 0) +
		((glbFFBB_Byte08.Heating & 0b00000011) << 2) +
		((glbFFBB_Byte08.StartUp & 0b00000011) << 4) +
		((glbFFBB_Byte08.X_axis & 0b00000011) << 6)
	data.push(bitCalculate.toString(16))
	//组装成第9字节
	bitCalculate =
		((glbFFBB_Byte09.Y_axis & 0b00000011) << 0) +
		((glbFFBB_Byte09.Z_axis & 0b00000011) << 2) +
		((glbFFBB_Byte09.R_axis & 0b00000011) << 4) +
		((glbFFBB_Byte09.ROG_axis & 0b00000011) << 6)
	data.push(bitCalculate.toString(16))
	data.push((SetSteps[0]).toString(16)) //设置步数第10字节
	//组装成第11字节
	bitCalculate =
		glbFFBB_Byte11.SingleStep +
		((glbFFBB_Byte11.StepPositionWrite & 0b00000001) << 1)
	data.push(bitCalculate.toString(16))
	data.push((SugarType[0]).toString(16))      //添加棉花糖类型
	//计算CRC
	let sumCRC = 0
	for (let cntj = 0; cntj < data.length; cntj++) { //16进制数组转成10进制添加到CRC数组里
		sumCRC += (parseInt(data[cntj], 16))
	}
	//发送的数据数据转换
	let SaveData = []
	for (let cntl = 0; cntl < data.length; cntl++) {
		SaveData[cntl] = parseInt(data[cntl], 16); //强制类型转换，string类型转换成unit8array类型的, 向0f这样的数据无法转成数字 需要先转成10进制
	}
	//存放输出密文的数据
	let SendCiphertext = new Uint8Array(SaveData.length)
	//加密函数  传入随机数   发送的数据    密文   数据长度
	fnEncryption(sendRandomData, SaveData, SendCiphertext, SaveData.length)
	//存放加密数组
	let EncryptData = [];
	//SendCiphertext得出来得数是数字,转成16进制数发
	for (let cntm = 0; cntm < SendCiphertext.length; cntm++) {
		EncryptData[cntm] = SendCiphertext[cntm].toString(16)
	}
	//添加CRC
	EncryptData.push((sumCRC & 0xff).toString(16));
	//数组添加随机数
	let RandomNumber = new Uint8Array(4); //定义个随机数数组
	//把32位随机数赋值个数组
	RandomNumber[0] = (sendRandomData >> 24)
	RandomNumber[1] = (sendRandomData >> 16)
	RandomNumber[2] = (sendRandomData >> 8)
	RandomNumber[3] = sendRandomData
	for (let cntk = 0; cntk < 4; cntk++) //32位随机数存放于4个字节的数组里面
	{
		EncryptData.push(RandomNumber[cntk].toString(16)) //添加到data数组中
	}
	// socket.sendBytes(JSON.stringify(data));       //发送得数据必须是["1","b","c"]这样类型得
	socket.sendBytesBroadcast(JSON.stringify(EncryptData),ip, port,localPort);
}

let Coordinate = new Uint8Array(408);  //50步坐标
let Parameter =  new Uint8Array(25)    //参数设置
 
// //从配置文件读入初始值
// import  testJsonData  from  "./initial_value.json"
// 发送数据结构体 
let StrSendData_FFCC = {
	sendAxis_x: [], //x轴坐标
	sendAxis_y: [], //y轴坐标
	sendAxis_z: [], //z轴坐标
	sendAxis_r: [], //r轴坐标
	sendSetHumidity: 0, //设定湿度
	sendSetManualTemperature: 0, //糖头手动设定温度
	sendSugarHeadWorkingTemperature: 0, //糖头工作温度
	sendSugarHeadWaitingTemperature: 0, //糖头等待温度
	sendWaterSprayingDuration: 0, //喷水时长
	sendBlowingDuration: 0, //吹风时长
	sendStrSugarYield: [], //出糖量
	sendInterval: [], //间隔
	sendBlow: [], //吹风
	sendWriteParameter: 0, //写参数使能
	sendCRC: 0,  //CRC
	
}
let glbStrSendData_FFCC = new Object(StrSendData_FFCC) // new个对象传给vue

let accFFCC = 0
//发送Udp 449数据函数
function CallbackSendDataFFCC() {
	let data = ['FF', 'CC', '00', '11', '01', 'BD']; //帧头
	let CRC = ['FF', 'CC', '00', '11', '01', 'BD']; //计算CRC数组
	accFFCC = accFFCC + 1; //累加
	data.push(accFFCC.toString(16))
	CRC.push(accFFCC.toString(16))
	let XYZRCoordinate = new Uint8Array(408); //50步坐标
	let ParameterSet = new Uint8Array(25) //参数设置
	for (let cnti = 0; cnti < 51; cnti++) {
		XYZRCoordinate[cnti * 8 + 0] = glbStrSendData_FFCC.sendAxis_x[cnti] >> 8 //x轴高位
		XYZRCoordinate[cnti * 8 + 1] = glbStrSendData_FFCC.sendAxis_x[cnti]     //x轴低位
		XYZRCoordinate[cnti * 8 + 2] = glbStrSendData_FFCC.sendAxis_y[cnti] >> 8
		XYZRCoordinate[cnti * 8 + 3] = glbStrSendData_FFCC.sendAxis_y[cnti]
		XYZRCoordinate[cnti * 8 + 4] = glbStrSendData_FFCC.sendAxis_z[cnti] >> 8
		XYZRCoordinate[cnti * 8 + 5] = glbStrSendData_FFCC.sendAxis_z[cnti]
		XYZRCoordinate[cnti * 8 + 6] = glbStrSendData_FFCC.sendAxis_r[cnti] >> 8
		XYZRCoordinate[cnti * 8 + 7] = glbStrSendData_FFCC.sendAxis_r[cnti]
	}
	//添加408个步数坐标到data数组中
	for (let cntj = 0; cntj < XYZRCoordinate.length; cntj++) {
		data.push(XYZRCoordinate[cntj].toString(16))
	}
	//强制类型转换
	let SaveData = [] // 把data的数据存放在
	for (let cntl = 0; cntl < data.length; cntl++) {
		SaveData[cntl] = parseInt(data[cntl], 16); //强制类型转换，string类型转换成unit8array类型的, 向0f这样的数据无法转成数字 需要先转成10进制
	}
	//添加随机数
	let RandomNumber = new Uint8Array(4); //定义个随机数数组
	RandomNumber[0] = (sendRandomData >> 24)
	RandomNumber[1] = (sendRandomData >> 16)
	RandomNumber[2] = (sendRandomData >> 8)
	RandomNumber[3] = sendRandomData
	for (let cntk = 0; cntk < 4; cntk++) //32位随机数存放于4个字节的数组里面
	{
		data.push(RandomNumber[cntk].toString(16)) //添加到data数组中
	}
	//存放输出密文的数据
	let Ciphertext = new Uint8Array(SaveData.length)
	//加密函数  传入随机数   发送的数据    密文   数据长度
	fnEncryption(sendRandomData, SaveData, Ciphertext, SaveData.length)
	//SendCiphertext得出来得数,转成16进制数添加到数组中
	for (let cntm = 0; cntm < Ciphertext.length; cntm++) {
		data[cntm] = Ciphertext[cntm].toString(16)
	}
	//参数配置
	let SaveParameterData = []
	ParameterSet[0] = glbStrSendData_FFCC.sendSetHumidity //湿度
	ParameterSet[1] = glbStrSendData_FFCC.sendSetManualTemperature //糖头手动设定温度
	ParameterSet[2] = glbStrSendData_FFCC.sendSugarHeadWorkingTemperature //糖头工作温度
	ParameterSet[3] = glbStrSendData_FFCC.sendSugarHeadWaitingTemperature //糖头等待温度
	ParameterSet[4] = glbStrSendData_FFCC.sendWaterSprayingDuration //喷水时长
	ParameterSet[5] = glbStrSendData_FFCC.sendBlowingDuration //吹风时长 
	for (let cntn = 0; cntn < 6; cntn++) {
		ParameterSet[6 + cntn] = glbStrSendData_FFCC.sendStrSugarYield[cntn] //出糖
	}
	for (let cnto = 0; cnto < 6; cnto++) {
		ParameterSet[12 + cnto] = glbStrSendData_FFCC.sendInterval[cnto] //间隔
	}
	for (let cntp = 0; cntp < 6; cntp++) {
		ParameterSet[18 + cntp] = glbStrSendData_FFCC.sendBlow[cntp] //吹风
	}
	ParameterSet[24] = glbStrSendData_FFCC.sendWriteParameter //写参数使能
	
	for (let cntq = 0; cntq < ParameterSet.length; cntq++) {
		SaveParameterData.push(ParameterSet[cntq].toString(16))
	}
	//数据强制类型转换
	let SaveData1 = [] // 把data的数据存放在
	for (let cntu = 0; cntu < SaveParameterData.length; cntu++) {
		SaveData1[cntu] = parseInt(SaveParameterData[cntu],
		16); //强制类型转换，string类型转换成unit8array类型的, 向0f这样的数据无法转成数字 需要先转成10进制
	}
	// 存放输出密文的数据
	let Ciphertext1 = new Uint8Array(SaveData1.length)
	//加密函数  传入随机数   发送的数据    密文   数据长度
	fnEncryption(sendRandomData, SaveData1, Ciphertext1, SaveData1.length)
	//SendCiphertext得出来得数,转成16进制数添加到数组中 
	let EncryptData = []; //存放加密数组，发出
	//添加418个数组
	for (let cntv = 0; cntv < data.length; cntv++) {
		EncryptData.push(data[cntv].toString(16))
	}
	//添加把参数配置
	for (let cntw = 0; cntw < Ciphertext1.length; cntw++) {
		EncryptData.push(Ciphertext1[cntw].toString(16))
	}
	//408步数组添加到计算CRC数组中
	for (let cntx = 0; cntx < XYZRCoordinate.length; cntx++) {
		CRC.push(XYZRCoordinate[cntx].toString(16))
	}
	//参数配置数组添加到CRC数组中
	for (let cnty = 0; cnty < ParameterSet.length; cnty++) { //在参数设置得25个数据添加到data中
		CRC.push(ParameterSet[cnty].toString(16))
	}
	//计算原始数组的CRC
	let sumCRC = 0
	for (let cntz = 0; cntz < CRC.length; cntz++) {
		sumCRC += (parseInt(CRC[cntz], 16))
	}
	//添加CRC值
	EncryptData.push((sumCRC & 0xff).toString(16));
	//添加随机数
	let RandomNumber1 = new Uint8Array(4); //定义个随机数数组
	//添加随机数
	RandomNumber1[0] = (sendRandomData >> 24)
	RandomNumber1[1] = (sendRandomData >> 16)
	RandomNumber1[2] = (sendRandomData >> 8)
	RandomNumber1[3] = sendRandomData
	for (let cntA = 0; cntA < 4; cntA++) //32位随机数存放于4个字节的数组里面
	{
		EncryptData.push(RandomNumber1[cntA].toString(16)) //添加到data数组中
	}
	// socket.sendBytes(JSON.stringify(data)); //发送   
	socket.sendBytesBroadcast(JSON.stringify(EncryptData),ip, port,localPort);
}

let accFFDD = 0;
//接收数据后需要发送一帧数据
let ReadConfiguration = new Uint8Array(1); //读取参数配置使能
function CallbackSendDataFFDD() {
	let data = ['FF', 'DD', '00', '11', '0C']; //帧头
	accFFDD = accFFDD + 1; //累加
	data.push(accFFDD.toString(16))
	data.push(ReadConfiguration[0].toString(16)) //参数使能
	//计算CRC
	let sumCRC = 0
	for (let cnti = 0; cnti < data.length; cnti++) {
		sumCRC += (parseInt(data[cnti], 16)) //data转成10进制累加计算
	}
	//强制类型转换 string类型转换成unit8array类型的, 向0f这样的数据无法转成数字 需要先转成10进制
	let SaveData = []
	for (let cntl = 0; cntl < data.length; cntl++) {
		SaveData[cntl] = parseInt(data[cntl], 16); //强制类型转换，
	}
	//存放输出密文的数据
	let SendCiphertext = new Uint8Array(SaveData.length)
	//加密函数  传入随机数   发送的数据    密文   数据长度
	fnEncryption(sendRandomData, SaveData, SendCiphertext, SaveData.length)
	//存放加密数组
	let EncryptData = [];
	//SendCiphertext得出来得数是数字,转成16进制数发
	for (let cntm = 0; cntm < SendCiphertext.length; cntm++) {
		EncryptData[cntm] = SendCiphertext[cntm].toString(16)
	}
	//添加CRC
	EncryptData.push((sumCRC & 0xff).toString(16));
	//数组添加随机数
	let RandomNumber = new Uint8Array(4); //定义个随机数数组	
	RandomNumber[0] = (sendRandomData >> 24)
	RandomNumber[1] = (sendRandomData >> 16)
	RandomNumber[2] = (sendRandomData >> 8)
	RandomNumber[3] = sendRandomData
	for (let cntk = 0; cntk < 4; cntk++) //32位随机数存放于4个字节的数组里面
	{
		EncryptData.push(RandomNumber[cntk].toString(16)) //添加到data数组中
	}
	//socket.sendBytes(JSON.stringify(data));
	socket.sendBytesBroadcast(JSON.stringify(EncryptData),ip, port,localPort); 
}

let FF00_Data = new Uint8Array(500) // 处理449位数据
//接收数据定义结构体对象
let StrRecData = {
	recFrameHeader: 0, //帧头
	recFrameType: 0, //帧类型
	recFrameLenth: 0, //帧长
	recFrameCnt: 0, //累加
	recAxis_x: [], //x轴坐标
	recAxis_y: [], //y轴坐标
	recAxis_z: [], //z轴坐标
	recAxis_r: [], //r轴坐标
	recSetHumidity: 0, //设定湿度
	recSetManualTemperature: 0, //糖头手动设定温度
	recSugarHeadWorkingTemperature: 0, //糖头工作温度
	recSugarHeadWaitingTemperature: 0, //糖头等待温度
	recWaterSprayingDuration: 0, //喷水时长
	recBlowingDuration: 0, //吹风时长
	recStrSugarYield: [], //出糖量
	recInterval: [], //间隔
	recBlow: [], //吹风
	recWriteParameter: 0, //写参数使能
	recCRC: 0, //CRC
}
let recData = new Object(StrRecData) // new个对象传给vue
//接收数据库里的内容 传个页面
let writeData = new Uint8Array(500)

let FFEE_Data = new Uint8Array(40) // 处理34位数据
//接收18个数据定义结构体对象
let StrRecData1 = {
	recFrameHeader: 0, //帧头
	recFrameType: 0, //帧类型
	recFrameLenth: 0, //帧长
	recTemperature: 0, //当前环境温度
	recHumidity: 0, //当前环境湿度
	recSugarHead: 0, //当前糖头温度
	recCurrentSteps: 0, //当前位置步数
	recCurrentAxis_X: 0, //当前x轴位置
	recCurrentAxis_Y: 0, //当前Y轴位置
	recCurrentAxis_Z: 0, //当前Z轴位置
	recCurrentAxis_R: 0, //当前R轴位置
	recMachine_id: [], //唯一id
	recCRC: 0, //CRC
}
let recData1 = new Object(StrRecData1) // new个对象传给vue

let ReceiveData = new Uint8Array(500) // 接收的数据传给这个全局变量 再传到页面  

//只需要调用一次，相当于初始化，跟定时器一样，操作系统接收到UDP数据后会调用receivedHexMsgCallBack
function CallbackconnectUDP() {
	// let SaveData = []
	let SaveData = new Uint8Array(500);
	// socket.init(ip, port, 'GBK');
	  // console.log("init UDP"); 
	//函数重载，重新定义打包了的函数
	socket.bindBroadcast('8011');   //绑定本机接收数据的广播端口
	socket.recBroadcastHexMsgCallBack = function(receivedHexMsg) {
		//硬件服务器返回16进制数据
		let msg = receivedHexMsg;
		let sum = msg.length / 2;	
		//把数组清空
		for (let k = 0; k < sum; k++) {
			let str = msg.substring(k * 2, k * 2 + 2); //0xFF，从字符串中取出2个字符
			SaveData[k] = parseInt(str, 16); //强制类型转换，string类型转换成unit8array类型的, 向0f这样的数据无法转成数字 需要先转成10进制
		}
	      
	    let DataValue = ((SaveData[35] << 8) + (SaveData[36]))
		//先判断接收的数据第35和36位为 0 就说明接收的数据只有34位
		if (DataValue === 0) {
			//先把接收到的数数据 取出数据赋值给变量	
			sendRandomData = ((SaveData[30] << 24) & 0xFF000000) | ((SaveData[31] << 16) & 0x00ff0000) | ((SaveData[
				32] << 8) & 0x0000FF00) | ((SaveData[33]) & 0x000000FF)
			//传入      随机数,      接收到的数据(密文),   明文,      数据长度
			fnDecrypt(sendRandomData, SaveData, FFEE_Data, SaveData.length);
			//得到明文数据 FFEE_Data
			let localFrameHeader = (FFEE_Data[0] << 8) + (FFEE_Data[1]) //解析帧头	 					
			//如果接收34个字节数据  就判断帧头是不是 FFEE  
			if (localFrameHeader === 65518) 
			{
				recData1.recFrameHeader = (FFEE_Data[0] << 8) + FFEE_Data[1]
				recData1.recFrameType = (FFEE_Data[2] << 8) + FFEE_Data[3]
				recData1.recFrameLenth = FFEE_Data[4]
				recData1.recTemperature = FFEE_Data[5] //环境温度
				recData1.recHumidity = FFEE_Data[6] //当前环境湿度 
				recData1.recSugarHead = FFEE_Data[7] //糖头温度
				recData1.recCurrentSteps = FFEE_Data[8] //当前位置步数        
				recData1.recCurrentAxis_X = (FFEE_Data[9] << 8) + FFEE_Data[10] //当前x轴位置					
				recData1.recCurrentAxis_Y = (FFEE_Data[11] << 8) + FFEE_Data[12] //当前y轴位置	
				recData1.recCurrentAxis_Z = (FFEE_Data[13] << 8) + FFEE_Data[14] //当前z轴位置
				recData1.recCurrentAxis_R = (FFEE_Data[15] << 8) + FFEE_Data[16] //当前r轴位置	
				let ID = [];
				for (let cnti = 0; cnti < 13; cnti++) { //接收唯一ID 
					ID.push(FFEE_Data[17 + cnti])
				}
				//id存入数据中
				for (let cntj = 0; cntj < 13; cntj++) {
					recData1.recMachine_id[cntj] = (ID[cntj])
				}
				recData1.CRC = FFEE_Data[29] //CRC
				//解析随机数存入到全局变量
				sendRandomData = ((SaveData[30] << 24) & 0xFF000000) | ((SaveData[31] << 16) & 0x00ff0000) | ((
					SaveData[32] << 8) & 0x0000FF00) | ((SaveData[33]) & 0x000000FF)
				// const db = uniCloud.database();
				// db.collection("DataSave").where('machine_id == "001"').remove().then((res) => {})
			    //云数据库库添加 ID
			    //  db.collection("DataSave").add({				 
			    // 	machine_id: recData1.recMachine_id,
			    //  }).then((res) => { // res 为数据库查询结果
			    // 	console.log(res) 
			    // })	
		    } else { }
		} else if (DataValue != 0) //数据长度是不是449
		{
			sendRandomData = ((SaveData[415] << 24) & 0xFF000000) | ((SaveData[416] << 16) & 0x00ff0000) | ((
				SaveData[417] << 8) & 0x0000FF00) | ((SaveData[418]) & 0x000000FF)
			//传入      随机数,      接收到的数据(密文),   明文,      数据长度
			fnDecrypt(sendRandomData, SaveData, FF00_Data, SaveData.length);
			//得到明文数据 FF00_Data
			let localFrameHeader = (FF00_Data[0] << 8) + (FF00_Data[1]) //解析帧头	
			//如果接收449个字节数据  就判断帧头是不是 FF00  
			if (localFrameHeader === 65280) {
				 
				for (let cntl = 0; cntl < FF00_Data.Length; cntl++) { //数组直接不能 = 进行赋值 ，用for循环来把一个个值传到另一个数组中
					ReceiveData[cntl] = FF00_Data[cntl]
				}
				recData.recFrameHeader = (FF00_Data[0] << 8) + FF00_Data[1]
				recData.recFrameType = (FF00_Data[2] << 8) + FF00_Data[3]
				recData.recFrameLenth = (FF00_Data[4] << 8) + FF00_Data[5]
				recData.recFrameCnt = FF00_Data[6]
				 
				for (let cnti = 0; cnti < 51; cnti++) { //xyzr轴坐标
					recData.recAxis_x[cnti] = (FF00_Data[7 + cnti * 8] << 8) + FF00_Data[8 + cnti * 8]
					recData.recAxis_y[cnti] = (FF00_Data[9 + cnti * 8] << 8) + FF00_Data[10 + cnti * 8]
					recData.recAxis_z[cnti] = (FF00_Data[11 + cnti * 8] << 8) + FF00_Data[12 + cnti * 8]
					recData.recAxis_r[cnti] = (FF00_Data[13 + cnti * 8] << 8) + FF00_Data[14 + cnti * 8]
				}
				//解析随机数存入到全局变量		
				sendRandomData = ((SaveData[445] << 24) & 0xFF000000) | ((SaveData[446] << 16) & 0x00ff0000) | ((
					SaveData[447] << 8) & 0x0000FF00) | ((SaveData[448]) & 0x000000FF);
				//传入      随机数1,      接收到的数据(密文),   明文,      数据长度
				fnDecrypt(sendRandomData, SaveData, FF00_Data, SaveData.length);
				recData.recSetHumidity = FF00_Data[419]
				recData.recSetManualTemperature = FF00_Data[420]
				recData.recSugarHeadWorkingTemperature = FF00_Data[421]
				recData.recSugarHeadWaitingTemperature = FF00_Data[422]
				recData.recWaterSprayingDuration = FF00_Data[423]
				recData.recBlowingDuration = FF00_Data[424]
				for (let cntj = 0; cntj < 6; cntj++) { //出糖量
					recData.recStrSugarYield[cntj] = FF00_Data[425 + cntj]
				}
				for (let cntl = 0; cntl < 6; cntl++) { //间隔
					recData.recInterval[cntl] = FF00_Data[431 + cntl]
				}
				for (let cntm = 0; cntm < 6; cntm++) { //吹风
					recData.recBlow[cntm] = FF00_Data[437 + cntm]
				}
				recData.recWriteParameter = FF00_Data[443]
				recData.recCRC = FF00_Data[444]
				//解析随机数存入到全局变量
				sendRandomData = ((SaveData[445] << 24) & 0xFF000000) | ((SaveData[446] << 16) & 0x00ff0000) | ((
					SaveData[447] << 8) & 0x0000FF00) | ((SaveData[418]) & 0x000000FF); 
			} else {
				// console.log(FF00_Data)
			}
		} 
		else {  }	
	}
}

function CallbackProcessLogic() {
	//对接收的数据进行处理，状态机写到这里。
	// console.log(param_test.Data_FFCC)
	// param_test.Data_FFCC.
}

// let testdata = new Uint8Array(10)
// testdata[0] = 1; 
//定时发送,下面的程序不要动，属于框架
const funProcess = {
	TimerStart1000ms() {
		this.timer = setInterval(() => {
			CallbackTimer1000ms();
			// console.log(testdata)
			// testdata[1] = testdata[1] +1;
		}, 1000);
	},
	TimerStart100ms() {
		this.timer = setInterval(() => {
			CallbackTimer100ms();
		}, 100);
	},
	TimerStart60s() {
		this.timer = setInterval(() => {
			CallbackTimer60s();
		}, 60*1000);
	},
	disconnect() {
		setTimeout(() => {
			clearInterval(timer);
		}, 100);
	}
}

export default {
	funProcess,
	CallbackProcessLogic,
	CallbackconnectUDP,
	recData, //解析441个字节数据
	Coordinate,    //发送数据的50步坐标
	Parameter,   //参数
	ReadConfiguration, //读取参数配置使能
	recData1, //解析18个字节数据       
	glbFFBB_Byte06,
	glbFFBB_Byte07,
	glbFFBB_Byte08,
	glbFFBB_Byte09,
	SetSteps, //设置步数
	glbFFBB_Byte11,
	SugarType, //棉花糖类型
	glbStrSendData_FFCC, //发送441个字节
	ip,
	port,
	writeData,
	// writeData1,      //解析数据库里的数据传给页面
	// testdata,
	ReceiveData,
	pageState, //页面状态，页面切换用
	bushu,
}