zhywpt-sp/static/etc/TDRAPI/TDRObuSDK.js

const mServiceId_i = 'FEE7';
const mWriteUUID_i = 'FEC7';
const mReadUUID_i = 'FEC7';
const mNotifyUUID_i = 'FEC8';
const mActiviceReadUUID_i = 'FEC9';
const mServiceId = ('0000FEE7-0000-1000-8000-00805F9B34FB').toLowerCase();
const mWriteUUID = ('0000FEC7-0000-1000-8000-00805F9B34FB').toLowerCase();
const mReadUUID = ('0000FEC7-0000-1000-8000-00805F9B34FB').toLowerCase();
const mNotifyUUID = ('0000FEC8-0000-1000-8000-00805F9B34FB').toLowerCase();
const mActiviceReadUUID = ('0000FEC9-0000-1000-8000-00805F9B34FB').toLowerCase();
const WECHAT_PRO_HEAD_MAGIC_NUMBER = 0xFE;
const WECHAT_PRO_HEAD_PACK_VERSION = 0x01;
const WECHAT_CMD_ECI_REQ_AUTH = 0x2711; //握手数据（设备--->手机）
const WECHAT_CMD_ECI_REQ_SEND_DATA = 0x2712;
const WECHAT_CMD_ECI_REQ_INIT = 0x2713; //初始化 (设备--->手机)
const WECHAT_CMD_ECI_RESP_AUTH = 0x4E21; //握手数据 （手机--->设备）
const WECHAT_CMD_ECI_RESP_INIT = 0x4E23; //初始化 (手机--->设备)
const WECHAT_CMD_ECI_PUSH_RECV_DATA = 0x7531; //发送指令数据(手机--->设备)
const ETC_PRO_SINGLE_PACK_SIZE = 105; /* ETC–≠“È∑÷∞¸≥§∂» */
const BLE_CTL_START_BIT = 0x80; //分包后，此包是否为起始包
const BLE_ETC_PRO_HEAD_ST = 0x33; /* ETC（33协议头标识） */
const MAX_WECHAT_SEND_LEN = 255;
const MAX_BLE_SIZE = 20;
const KYunNanObuMultiplePackages = 1;

let mDeviceId = 0;
let service = {}; //服务
let writeCharVal = {}; //写入特征值
let readCharVal = {}; //读取特征值
let notifyCharVal = {}; //通知特征值
let activiceReadCharVal = {}; //读取特征值
let mPacketLen = 0;
let mRecvDataCache = [];
let mUnpacketDataCache = [];
let mIsInitCmdSend = false;
let mEtcRawData = [];
let mEtcRawDataLen = 0;
let maxLenPerPacket = 100;
let mReturnedRawCmdData = 0;
let mAbCmdBuf = [];
let mnCmdBufLen = 0;
let mTransData = [];
let mSingleEtcProtoData = [];
let mLenBuf = [];
let mBytesNumOfDataLen = 0;
let receiveDataCallBack = null;
let m_IsIOS = true;
let m_isConn = false;
let mCurrentPacketNum = 0;
let mConnCount = 2;
let beginTime = 0;

function getVersion() {
	var version = "v1.0.0.4.2020092701"
	return version;
}
/**
 通过蓝牙，连接OBU设备

 @param deviceId 需要连接的蓝牙外围设备ID
 @param callback_1 回调函数 连接结果
        code=0表示连接成功，code = 非0  连接失败
 @param callback_2 回调函数 时时监听连接状态
        code=0表示监听连接成功，code = 1表示监听到断开连接
 */
function connectDevice(device, callback_1, callback_2) {
	beginTime = +new Date();
	m_IsIOS = my.getSystemInfoSync().platform.toLowerCase() == 'ios' ? true : false;
	let deviceId = device.deviceId
	// if (m_isConn && mDeviceId == deviceId) {
	//   callback_1(makeRes(0, [], '已连接'))
	//   return;
	// }
	// if (mDeviceId == 0) {
	conn(device, callback_1, callback_2)
	// } else {
	//   my.disconnectBLEDevice({
	//     deviceId: mDeviceId,
	//     complete: function(e) {
	//       conn(device, callback_1, callback_2)
	//     }
	//   })
	// }
}

function conn(device, callback_1, callback_2) {
	let deviceId = device.deviceId
	my.connectBLEDevice({
		deviceId: deviceId,
		success: function(res) {
			console.log('connectBLEDevice')
			mDeviceId = deviceId;
			my.getBLEDeviceServices({
				deviceId: deviceId,
				success: function(res) {
					console.log('getBLEDeviceServices:' + JSON.stringify(res))
					var isExistsService = false
					for (var i = 0; i < res.services.length; i++) {
						console.log('res.services[i].serviceId:' + res.services[i].serviceId +
							',mServiceId:' + mServiceId)
						if (res.services[i].serviceId == (m_IsIOS ? mServiceId_i :
								mServiceId)) {
							console.log('res.services[i].serviceId == mServiceId')
							service: res.services[i]
							isExistsService = true;
							break;
						}
					}
					if (isExistsService) {
						my.getBLEDeviceCharacteristics({
							deviceId: deviceId,
							serviceId: (m_IsIOS ? mServiceId_i : mServiceId),
							success: function(res) {
								console.log('getBLEDeviceCharacteristics' + JSON
									.stringify(res))
								for (var i = 0; i < res.characteristics
									.length; i++) {
									if (res.characteristics[i].characteristicId == (
											m_IsIOS ? mWriteUUID_i : mWriteUUID)) {
										writeCharVal: res.characteristics[i]
									}
									if (res.characteristics[i].characteristicId == (
											m_IsIOS ? mReadUUID_i : mReadUUID)) {
										readCharVal: res.characteristics[i]
									}
									if (res.characteristics[i].characteristicId == (
											m_IsIOS ? mNotifyUUID_i : mNotifyUUID
										)) {
										notifyCharVal: res.characteristics[i]
									}
									if (res.characteristics[i].characteristicId == (
											m_IsIOS ? mActiviceReadUUID_i :
											mActiviceReadUUID)) {
										activiceReadCharVal: res.characteristics[i]
									}
								}

								my.offBLEConnectionStateChanged();

								my.onBLEConnectionStateChanged(function(res) {
									// 该方法回调中可以用于处理连接意外断开等异常情况
									console.log(
										'改变onBLEConnectionStateChange');
									if (res.connected) {
										console.log('connected true')
										m_isConn = true;
										callback_2(makeRes(0, [], '蓝牙已连接'))
									} else {
										console.log('connected false')
										var endTime = +new Date();
										if ((endTime - beginTime) >= 3000) {
											mIsInitCmdSend = false;
											m_isConn = false;
											callback_2(makeRes(-1, [],
												'蓝牙已断开'))
										}
									}
								})

								my.offBLECharacteristicValueChange();

								my.notifyBLECharacteristicValueChange({
									deviceId: deviceId,
									serviceId: (m_IsIOS ? mServiceId_i :
										mServiceId),
									characteristicId: (m_IsIOS ?
										mNotifyUUID_i : mNotifyUUID),
									state: true,
									success: function(res) {
										my.onBLECharacteristicValueChange(
											function(res) {
												console.log(
													'收到数据:' +
													res.value)
												let pRead =
													str2Bytes(res
														.value)
												if (pRead.length >
													0 && pRead !=
													null) {
													if (pRead[0] ==
														WECHAT_PRO_HEAD_MAGIC_NUMBER &&
														pRead[1] ==
														WECHAT_PRO_HEAD_PACK_VERSION
													) {
														mPacketLen =
															(pRead[
																	2
																] <<
																8) |
															pRead[
																3];
													}

													mRecvDataCache
														.push.apply(
															mRecvDataCache,
															pRead)
													if (mRecvDataCache
														.length ==
														mPacketLen
													) {
														let pData =
															mRecvDataCache
														let nCmdID =
															(pData[
																	4
																] <<
																8) |
															pData[5]

														switch (
															nCmdID
														) {
															case WECHAT_CMD_ECI_REQ_AUTH: {
																console
																	.log(
																		'WECHAT_CMD_ECI_REQ_AUTH'
																	)
																let data =
																	makeHandShakeStep1WithETC()
																mRecvDataCache
																	= []

																write
																	(
																		data
																	)
															}
															break;
															case WECHAT_CMD_ECI_REQ_INIT: {
																console
																	.log(
																		'WECHAT_CMD_ECI_REQ_INIT'
																	)
																let data =
																	makeHandShakeStep2WithETC()
																write
																	(
																		data
																	)

																setTimeout
																	(function() {
																			let dataInit =
																				makeInitWithETC()
																			mRecvDataCache
																				= []
																			write
																				(
																					dataInit
																				)
																			mIsInitCmdSend
																				=
																				true
																		},
																		20
																	)
															}
															break;
															case WECHAT_CMD_ECI_REQ_SEND_DATA: {
																console
																	.log(
																		'WECHAT_CMD_ECI_REQ_SEND_DATA'
																	)
																if (
																	mIsInitCmdSend
																) {
																	m_isConn
																		=
																		true
																	callback_1
																		(makeRes(
																			0,
																			[],
																			'连接成功'
																		))
																	mIsInitCmdSend
																		=
																		false
																}

																mEtcRawData
																	= []
																mEtcRawDataLen
																	=
																	0
																let op =
																	unpaketProto(
																		mRecvDataCache
																	)
																if (!
																	op
																) {
																	if (mEtcRawData[
																			0
																		] ==
																		0xB2
																	) {
																		maxLenPerPacket
																			=
																			mEtcRawData[
																				3
																			];
																	} else {
																		mUnpacketDataCache
																			.push
																			.apply(
																				mUnpacketDataCache,
																				mEtcRawData
																			)
																		console
																			.log(
																				'******返回未解析的指令数据包为:' +
																				ab2hexArr(
																					mUnpacketDataCache
																				)
																			)

																		if (mCurrentPacketNum ==
																			0
																		) {
																			mReturnedRawCmdData
																				= []
																			let errorcode =
																				unpackXXCmdPacket(
																					mUnpacketDataCache
																				)
																			console
																				.log(
																					'******解析后的指令数据为' +
																					mReturnedRawCmdData
																				)
																			if (
																				receiveDataCallBack
																			) {
																				receiveDataCallBack
																					(makeRes(
																						errorcode,
																						mReturnedRawCmdData,
																						errorcode ==
																						0 ?
																						'收到数据成功' :
																						'数据透传失败'
																					))
																				receiveDataCallBack
																					=
																					null
																			}
																			mUnpacketDataCache
																				= []
																		}
																	}
																} else {
																	mUnpacketDataCache
																		.push
																		.apply(
																			mUnpacketDataCache,
																			mEtcRawData
																		)
																}
																mRecvDataCache
																	= []
															}
															break;
															default:
																break;
														}
													}
												}
											})
									},
									fail: function(e) {
										callback_1(makeRes(-1, [],
											'连接失败'))
									}
								})
							},
							fail: function(res) {
								callback_1(makeRes(-1, [], '连接失败'))
							}
						})
					}
				},
				fail: function(res) {
					callback_1(makeRes(-1, [], '连接失败'))
				}
			})
		},
		fail: function(res) {
			// if (mConnCount > 0) {
			//   console.log(mConnCount)
			//   mConnCount--
			//   connectDevice(device, callback_1, callback_2)
			// } else {
			//   console.log(mConnCount)
			//   mConnCount = 2
			//   m_isConn = false;
			//   callback_1(-1, [], '连接失败')
			// }
			callback_1(makeRes(-1, [], '连接失败'))
		}
	})
}

//断开与OBU设备的蓝牙连接
function disconnectDevice(callBack) {
	if (!m_isConn) {
		callBack(makeRes(-1, [], '未连接'))
		return;
	}
	let data = makeDisconnectWithETC();
	mIsInitCmdSend = false;
	mRecvDataCache = []
	write(data)

	my.disconnectBLEDevice({
		deviceId: mDeviceId,
		success: function(res) {
			m_isConn = false;
			callBack(makeRes(0, [], '断开成功'))
		},
		fail: function(e) {
			console.log('error:' + e.errMsg)
			callBack(makeRes(-1, [], '断开失败'))
		}
	})
}

/**
 数据透传

 @param cmd 指令[]
 @param cmdtype 明文：IC：10、ESAM：20
 @param callBack 回调函数
        status  成功为 true，失败为 false
        data    NSData  回应数据（明文）+ 签名
        errorMsg    报错信息
 */
function transCmd(cmd, cmdtype, callBack) {
	if (callBack) {
		receiveDataCallBack = callBack;
	}

	if (!m_isConn) {
		receiveDataCallBack(makeRes(-2, [], '连接失败'))
		return;
	}

	let cmdType = 0;
	if (cmdtype == '10') {
		cmdType = 0xA3;
	} else if (cmdtype == '20') {
		cmdType = 0xA8;
	}

	let totalMutableData = []
	for (var i = 0; i < cmd.length; i++) {
		let obj = str2Bytes(cmd[i]);
		console.log('##### cmd_:' + ab2hexArr(obj))
		let oneData = makeMutiPackageData(obj, i + 1)
		console.log('##### oneData:' + ab2hexArr(oneData))
		totalMutableData.push.apply(totalMutableData, oneData);
	}
	console.log('totalMutableData:' + ab2hexArr(totalMutableData))
	let totalChar = totalMutableData;
	let pbChar = [];
	pbChar[0] = 0xA1;
	pbChar[1] = totalMutableData.length;
	pbChar.push.apply(pbChar, totalChar);
	let reallyData = pbChar;
	console.log('reallyData:' + ab2hexArr(reallyData))

	mTransData = []
	if (!makeXXCmdPacket(cmdType, reallyData)) {
		subReqDataAndMakeEtcProtoPacket(mTransData)
	}
}

function makeMutiPackageData(xxCmdData, dataIndex) {
	let index = 0;
	let cmdDataLen = xxCmdData.length;
	let cmdPacketDataLen = cmdDataLen + 12;
	let pbData = []
	pbData[index++] = 0xA4; //1
	pbData[index++] = 0x00; //Len2  1字节长度，真实数值后续代码算            2

	//stable data
	pbData[index++] = 0x38; //3
	pbData[index++] = 0x01; //4
	pbData[index++] = dataIndex; //5
	pbData[index++] = 0x39; //6

	pbData[index++] = cmdDataLen; //Len3

	pbData.push.apply(pbData, xxCmdData)
	index += cmdDataLen;
	//stable data
	pbData[index++] = 0x3C;
	pbData[index++] = 0x01;
	pbData[index++] = 0x00;
	// pbData[index++] = 0x00;
	// pbData[index] = 0x00;

	pbData[1] = cmdDataLen + 3 + 2 + 3;
	return pbData;
}

function subReqDataAndMakeEtcProtoPacket(etcProtoData) {
	let hr = 0;
	let totalDataLen = etcProtoData.length;
	let blockSize = maxLenPerPacket;
	let offset = 0
	if (blockSize == undefined) {
		blockSize = 100
	}

	let YuShu = totalDataLen % blockSize;

	let PackNumOffset = 0;
	let PackNum = (YuShu == 0) ? (totalDataLen / blockSize) : (parseInt(totalDataLen / blockSize) + 1);
	let LastPackSize = (YuShu == 0) ? ETC_PRO_SINGLE_PACK_SIZE : YuShu;

	let pSendBuf = etcProtoData;
	let sendBuff = [];
	mSingleEtcProtoData = [];

	let _pack = {}
	_pack.perPackSize = blockSize
	_pack.finalPackSize = LastPackSize
	_pack.packNum = PackNum

	if (totalDataLen > blockSize) {
		for (; offset < (totalDataLen - blockSize); offset += blockSize) {
			_pack.packNumOffset = PackNumOffset;
			sendBuff.push.apply(sendBuff, pSendBuf.slice(offset, offset + blockSize))
			hr = makeSingleEtcProtocolPaket(sendBuff, _pack)
			if (hr != 0) {
				return hr;
			}
			PackNumOffset++;
			hr = tranmitBleBlock()
			if (hr != 0) {
				return hr;
			}
			sendBuff = []
		}
	}
	_pack.packNumOffset = PackNumOffset;

	sendBuff.push.apply(sendBuff, pSendBuf.slice(offset, totalDataLen))
	let data = sendBuff.slice(0, totalDataLen - offset)
	hr = makeSingleEtcProtocolPaket(data, _pack)
	if (hr != 0) {
		return hr;
	}

	console.log('tranmitBleBlock（' + mSingleEtcProtoData.length + '）:' + ab2hexArr(mSingleEtcProtoData))
	return tranmitBleBlock()
}

function makeSingleEtcProtocolPaket(ectCmdRawData, sPack) {
	let SendCTL = sPack.packNum - sPack.packNumOffset - 1;
	let IsLastPack = ((sPack.packNumOffset + 1) == sPack.packNum) ? 1 : 0;
	let DataLen = 0;
	let SendLen = 0;

	let etcCmdRawDataLen = ectCmdRawData.length;
	let etcCmdRawBufLen = etcCmdRawDataLen + 5;
	let etcCmdRawBuf = [];
	SendCTL = (sPack.packNumOffset == 0) ? (BLE_CTL_START_BIT | SendCTL) : SendCTL;

	DataLen = IsLastPack ? sPack.finalPackSize : sPack.perPackSize; //ETC_PRO_SINGLE_PACK_SIZE;

	/* 33协议组包*/
	etcCmdRawBuf[SendLen++] = BLE_ETC_PRO_HEAD_ST; //ST
	etcCmdRawBuf[SendLen++] = 0x00; //sPack.packNumOffset+1;//0x00;
	etcCmdRawBuf[SendLen++] = SendCTL; //CTL
	etcCmdRawBuf[SendLen++] = etcCmdRawDataLen; //LEN
	etcCmdRawBuf.push.apply(etcCmdRawBuf, ectCmdRawData);
	SendLen += ectCmdRawData.length;
	etcCmdRawBuf[SendLen++] = XorVerify(etcCmdRawBuf.slice(1), (ectCmdRawData.length + 3)); //BCC校验，从SN到DATA

	console.log('*****makeSingleEtcPacket : ' + ab2hexArr(etcCmdRawBuf))
	return makeSingleProtoPacket(etcCmdRawBuf)
}

function XorVerify(buf, len) {
	let TempVerify = 0x00;
	let i = 0;
	for (i = 0; i < len; i++) {
		TempVerify ^= buf[i];
	}
	return TempVerify
}

function AppSetVarints(inValue) {
	if (inValue < 128) {
		mLenBuf[0] = inValue;
		mBytesNumOfDataLen = 1;
	} else {
		mLenBuf[0] = (inValue & 0x7F) | 0x80;
		mLenBuf[1] = (inValue >> 7) & 0x7F;
		mBytesNumOfDataLen = 2;
	}
}

function makeSingleProtoPacket(etcEnclosurBuf) {
	let index = 0;
	let ManufactoryDefineKeyValue = 0; //厂商自定义数据长度，根据不同值设置不同数据

	let sDataLen = etcEnclosurBuf.length;
	if (sDataLen == 0 || sDataLen > (MAX_WECHAT_SEND_LEN - 12)) {
		console.log('[ERROR] Wechat send len error, return!')
		return 1;
	}
	mLenBuf = []
	mBytesNumOfDataLen = 0;
	AppSetVarints(sDataLen)
	let protoBufLen = sDataLen + 11 + mBytesNumOfDataLen + ManufactoryDefineKeyValue;
	let protoBuf = [];

	protoBuf[index++] = WECHAT_PRO_HEAD_MAGIC_NUMBER;
	protoBuf[index++] = WECHAT_PRO_HEAD_PACK_VERSION;
	protoBuf[index++] = (protoBufLen >> 8) & 0xff;
	protoBuf[index++] = (protoBufLen) & 0xff;
	protoBuf[index++] = (WECHAT_CMD_ECI_PUSH_RECV_DATA >> 8) & 0xff;
	protoBuf[index++] = (WECHAT_CMD_ECI_PUSH_RECV_DATA) & 0xff;
	protoBuf[index++] = 0x00;
	protoBuf[index++] = 0x00;

	/* 变长包体，key1-value1 - key2-value2 - key3-value3... ,value=len+data 具体可参考protobuf协议*/
	protoBuf[index++] = 0x0A; //可认为固定值
	protoBuf[index++] = 0x00;

	protoBuf[index++] = 0x12; //data域key值;
	protoBuf[index++] = mLenBuf[0]; //data域lenth
	if (mBytesNumOfDataLen == 2) {
		protoBuf[index++] = mLenBuf[1];
	}
	protoBuf.push.apply(protoBuf, etcEnclosurBuf)
	index += sDataLen;

	if (ManufactoryDefineKeyValue == 2) //暂时未用到
	{
		protoBuf[index++] = 0x18;
		protoBuf[index++] = 0x00;
	}

	if (ManufactoryDefineKeyValue == 3) //暂时未用到
	{
		protoBuf[index++] = 0x18;
		protoBuf[index++] = 0x91;
		protoBuf[index++] = 0x4e;
	}
	mSingleEtcProtoData = []
	mSingleEtcProtoData.push.apply(mSingleEtcProtoData, protoBuf.slice(0, index))
	console.log('*****makeSingleProtoPacket : ' + ab2hexArr(mSingleEtcProtoData))
	return 0;
}

function tranmitBleBlock() {
	let totalDataLen = mSingleEtcProtoData.length;
	let blockSize = MAX_BLE_SIZE;
	let offset = 0;
	if (blockSize <= 0) {
		return 1;
	}

	let pSendBuf = mSingleEtcProtoData;
	let sendBuff = [];
	if (totalDataLen > blockSize) {
		for (; offset < totalDataLen - blockSize; offset += blockSize) {
			sendBuff.push.apply(sendBuff, pSendBuf.slice(offset, blockSize + offset))
			let data = sendBuff.slice(0, blockSize)

			console.log('tranmitBleBlock part:(' + blockSize + '),data:' + ab2hexArr(data))
			writeData(data)
			sendBuff = []
			sleep(100)
		}
	}

	sendBuff.push.apply(sendBuff, pSendBuf.slice(offset, totalDataLen))
	let data = sendBuff.slice(0, totalDataLen - offset)
	console.log('tranmitBleBlock part:(' + (totalDataLen - offset) + '),data:' + ab2hexArr(data))
	writeData(data)
	return 0;
}

function sleep(delay) {
	var start = (new Date()).getTime();
	while ((new Date()).getTime() - start < delay) {
		continue;
	}
}


function write(arrayBuffer) {
	console.log('发送:' + ab2hex(arrayBuffer))
	my.writeBLECharacteristicValue({
		deviceId: mDeviceId,
		serviceId: (m_IsIOS ? mServiceId_i : mServiceId),
		characteristicId: (m_IsIOS ? mWriteUUID_i : mWriteUUID),
		value: ab2hex(arrayBuffer),
		success: function(res) {
			console.log('发送成功')
		},
		fail: function(e) {
			console.log('发送失败')
		}
	})
}

function writeData(data) {
	// let arrayBuffer = new Uint8Array(data).buffer;
	console.log('发送Data:' + data)
	my.writeBLECharacteristicValue({
		deviceId: mDeviceId,
		serviceId: (m_IsIOS ? mServiceId_i : mServiceId),
		characteristicId: (m_IsIOS ? mWriteUUID_i : mWriteUUID),
		value: ab2hex(data),
		success: function(res) {
			console.log('发送成功')
		},
		fail: function(e) {
			console.log('发送失败')
		}
	})
}

function ab2hex(buffer) {
	let hexArr = Array.prototype.map.call(
		new Uint8Array(buffer),
		function(bit) {
			return ('00' + bit.toString(16)).slice(-2)
		}
	)
	return hexArr.join('');
}

function ab2DecArr(buffer) {
	return new Uint8Array(buffer);
}

function ab2hexArr(arr) {
	let hexArr = Array.prototype.map.call(
		arr,
		function(bit) {
			return ('00' + bit.toString(16)).slice(-2)
		}
	)
	return hexArr;
}


function makeHandShakeStep1WithETC() {
	let cBuff = []
	let index = 0
	cBuff[index++] = 0xFE;
	cBuff[index++] = 0x01;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x0E;
	cBuff[index++] = 0x4E;
	cBuff[index++] = 0x21;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x01;
	cBuff[index++] = 0x0A;
	cBuff[index++] = 0x02;
	cBuff[index++] = 0x08;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x12;
	cBuff[index] = 0x00;
	return new Uint8Array(cBuff).buffer;
}

function makeHandShakeStep2WithETC() {
	let cBuff = []
	let index = 0
	cBuff[index++] = 0xFE;
	cBuff[index++] = 0x01;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x13;
	cBuff[index++] = 0x4E;
	cBuff[index++] = 0x23;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x02;
	cBuff[index++] = 0x0A;
	cBuff[index++] = 0x02;
	cBuff[index++] = 0x08;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x10;
	cBuff[index++] = 0xB4;
	cBuff[index++] = 0x24;
	cBuff[index++] = 0x18;
	cBuff[index++] = 0xF8;
	cBuff[index++] = 0xAC;
	cBuff[index] = 0x01;
	return new Uint8Array(cBuff).buffer;
}

function makeInitWithETC() {
	let cBuff = []
	let index = 0
	cBuff[index++] = 0xFE;
	cBuff[index++] = 0x01;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x14;
	cBuff[index++] = 0x75;
	cBuff[index++] = 0x31;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x02;
	cBuff[index++] = 0x0A;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x12;
	cBuff[index++] = 0x06;
	cBuff[index++] = 0x33;
	cBuff[index++] = 0x0A;
	cBuff[index++] = 0x80;
	cBuff[index++] = 0x01;
	cBuff[index++] = 0xA2;
	cBuff[index++] = 0x29;
	cBuff[index++] = 0x18;
	cBuff[index] = 0x00;
	return new Uint8Array(cBuff).buffer;
}

function makeDisconnectWithETC() {
	let cBuff = []
	let index = 0
	cBuff[index++] = 0xFE;
	cBuff[index++] = 0x01;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x14;
	cBuff[index++] = 0x75;
	cBuff[index++] = 0x31;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x02;
	cBuff[index++] = 0x0A;
	cBuff[index++] = 0x00;
	cBuff[index++] = 0x12;
	cBuff[index++] = 0x06;
	cBuff[index++] = 0x33;
	cBuff[index++] = 0x0A;
	cBuff[index++] = 0x80;
	cBuff[index++] = 0x01;
	cBuff[index++] = 0xAE;
	cBuff[index] = 0x25;
	return new Uint8Array(cBuff).buffer;
}

function unpaketProto(recvDataCache) {
	let data = recvDataCache.slice(12)
	let dataLen = recvDataCache[13]

	let st = data[0];
	let ctl = data[2];
	let dataLet = data[3];
	let ndata = data.slice(4);
	let StartPackFlag = ((ctl & 0x80) > 0) ? true : false
	let CurrentPackNum = ctl & 0x7F;
	mCurrentPacketNum = CurrentPackNum;

	let operatorStatus = 0;
	if (st != 0x33) {
		return -1;
		console.log('[ERROR] The received data head ST is not right!')
	}

	if (StartPackFlag) {
		operatorStatus = 1;
	}

	mEtcRawData = ndata.slice(0, dataLen - 1)
	mEtcRawDataLen = dataLen
	return operatorStatus & CurrentPackNum;
}

function unpaketProto_1(recvDataCache) {
	let data = recvDataCache.slice(12)
	let dataLen = recvDataCache[13]

	let st = data[0];
	let ctl = data[2];
	let dataLet = data[3];
	let ndata = data.slice(4);
	let StartPackFlag = ((ctl & 0x80) > 0) ? true : false
	let CurrentPackNum = ctl & 0x7F;

	let operatorStatus = 0;
	if (st != 0x33) {
		return -1;
		console.log('[ERROR] The received data head ST is not right!')
	}

	if (StartPackFlag) {
		operatorStatus = 1;
	}

	mAbCmdBuf = ndata.slice(0, dataLen - 1)
	mnCmdBufLen = dataLen
	return operatorStatus & CurrentPackNum;
}

function unpackXXCmdPacket(recvDataCache) {
	mAbCmdBuf = recvDataCache;
	// mnCmdBufLen = 0
	// unpaketProto_1(recvDataCache)
	// let cmdStatus = mAbCmdBuf[1];
	// if (cmdStatus != 0) {
	//   return 4;
	// }

	let abCmdTLVLen = (mAbCmdBuf[4] << 8) + mAbCmdBuf[3];
	if (abCmdTLVLen <= 0) {
		receiveDataCallBack(makeRes(-1, [], '未插卡'))
		return
	}

	let abCmdTLVBuf = mAbCmdBuf.slice(5, abCmdTLVLen + 5)

	if (abCmdTLVBuf[0] == 0xA3 && abCmdTLVBuf[2] == 0xA2) {
		let abCmdTLVBuf1 = abCmdTLVBuf.slice(2, abCmdTLVLen)

		let len = abCmdTLVLen - 2;
		while (len > 0) {
			let rData = abCmdTLVBuf1.slice(3, abCmdTLVBuf1[1] - 1 + 3)
			mReturnedRawCmdData.push(bytes2Str(rData))
			abCmdTLVBuf1 = abCmdTLVBuf1.slice(3 + abCmdTLVBuf1[1] - 1, abCmdTLVBuf1.length)
			len = abCmdTLVBuf1.length;
		}
	} else {
		return 5;
	}
	return 0;
}

function makeXXCmdPacket(cmdType, reqData) {
	let index = 0;
	let cmdDataLen = reqData.length
	let cmdPacketDataLen = cmdDataLen + 10;
	let pbData = [];

	if (KYunNanObuMultiplePackages == 0) {
		pbData[index++] = ((cmdType == 0xA3) ? cmdType : 0xA8); // PICC 通道            0
		pbData[index++] = 0x00; // 明文数据    01 加密数据                     1
		pbData[index++] = 0x00; //总长度                                       2
		pbData[index++] = 0x00; //总长度，后续代码会算                            3

		pbData[index++] = 0xA1; //4
		pbData[index++] = 0x00; //Len1  1字节长度，真实数值后续代码算                5
		pbData[index++] = 0xA4; //6
		pbData[index++] = 0x00; //Len2  1字节长度，真实数值后续代码算            7

		//stable data
		pbData[index++] = 0x38; //8
		pbData[index++] = 0x01; //9
		pbData[index++] = 0x01; //10
		pbData[index++] = 0x39; //11

		pbData[index++] = cmdDataLen; //Len3
		pbData.push.apply(pbData, reqData)
		index += cmdDataLen;
		//stable data
		pbData[index++] = 0x3C;
		pbData[index++] = 0x03;
		pbData[index++] = 0x90;
		pbData[index++] = 0x00;
		pbData[index] = 0x00;

		pbData[7] = cmdDataLen + 1 + 9; //Len2长度 = 指令数据长度+两组固定数据长度+cmdDatalen自身长度标识1字节
		pbData[5] = pbData[7] + 2; //2包含固定数据0xA4与 pbData[7]本身长度标识1字节

		pbData[2] = ((pbData[5] + 2) & 0xff);
		pbData[3] = ((pbData[5]) >> 8) & 0xff; //总长度 小端模式
	} else {
		pbData[index++] = ((cmdType == 0xA3) ? cmdType : 0xA8);
		pbData[index++] = 0x00; //0 明文 1密文
		pbData[index++] = (cmdDataLen & 0xff); //总长度
		pbData[index++] = (cmdDataLen >> 8) & 0xff; //总长度，后续代码会算
		pbData.push.apply(pbData, reqData)
	}

	mTransData.push.apply(mTransData, pbData.slice(0, pbData[5] + 6))
	return 0;
}

function str2Bytes(str) {
	var pos = 0;
	var len = str.length;
	if (len % 2 != 0) {
		return null;
	}
	len /= 2;
	var hexA = new Array();
	for (var i = 0; i < len; i++) {
		var s = str.substr(pos, 2);
		var v = parseInt(s, 16);
		hexA.push(v);
		pos += 2;
	}
	return hexA;
}

function bytes2Str(arr) {
	var str = "";
	for (var i = 0; i < arr.length; i++) {
		var tmp = arr[i].toString(16);
		if (tmp.length == 1) {
			tmp = "0" + tmp;
		}
		str += tmp;
	}
	return str;
}

function makeRes(code, data, msg) {
	return {
		code: code,
		data: data,
		msg: msg
	}
}

module.exports = {
	getVersion: getVersion,
	connectDevice: connectDevice,
	transCmd: transCmd,
	disconnectDevice: disconnectDevice
}