package com.hdl.sdk.ttl.HDLDeviceManger.Core;
|
|
|
import android.serialport.api.SerialPort;
|
import android.widget.TextView;
|
|
import com.hdl.sdk.ttl.Config.Configuration;
|
import com.hdl.sdk.ttl.Config.MCUConstants;
|
import com.hdl.sdk.ttl.HDLDeviceManger.Bean.MCUDataBean;
|
import com.hdl.sdk.ttl.HDLDeviceManger.Bean.UdpDataBean;
|
import com.hdl.sdk.ttl.HDLDeviceManger.EventBusEvent.EventCode;
|
import com.hdl.sdk.ttl.HDLDeviceManger.HDLListener.IMcuOtaListener;
|
import com.hdl.sdk.ttl.Utils.HDLUtlis.HDLStringUtils;
|
import com.hdl.sdk.ttl.Utils.HDLUtlis.HDLUtlis;
|
import com.hdl.sdk.ttl.Utils.LogUtils.HDLLog;
|
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.OutputStream;
|
import java.security.InvalidParameterException;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
/**
|
* Created by JLChen on 2019/6/26
|
* 串口管理类
|
*/
|
public class HDLSerialPortCore {
|
//串口设备路径名
|
private static String mPathname = "/dev/ttyS2";
|
//波特率
|
private static int mBaudrate = 115200;
|
|
// public static SerialPortFinder mSerialPortFinder = new SerialPortFinder();
|
private static SerialPort mSerialPort = null;
|
private static InputStream mInputStream = null;
|
private static OutputStream mOutputStream = null;
|
// private static HDLReadDatasThread mHDLReadDatasThread = new HDLReadDatasThread();
|
|
// private static HDLRead485DatasThread mHDLRead485DatasThread = new HDLRead485DatasThread();
|
private static HDLReadMCUDatasThread mHDLReadMCUDatasThread = new HDLReadMCUDatasThread();
|
private static HDLSendDatasThread mHDLSendDatasThread = new HDLSendDatasThread();
|
|
public static List<byte[]> mSendDatasList = new ArrayList<byte[]>();//发送数据队列
|
private static List<Byte> mReceiveDatasList = new ArrayList<Byte>();//接收数据队列
|
// private static List<Byte> mReceive485DatasList = new ArrayList<Byte>();//485接收数据队列
|
|
public static Boolean bPassThrough = false; //判断是否透传
|
public static IMcuOtaListener mIMcuOtaListener;
|
public static byte[] upgradeFileDatas; //升级文件数据
|
|
/*** 串口是否打开成功*/
|
private static boolean bOpenSuccess = false;
|
|
// private static boolean b485DatascChangeStop = false;
|
|
public static SerialPort getSerialPort() throws SecurityException, IOException, InvalidParameterException {
|
if (mSerialPort == null) {
|
mSerialPort = new SerialPort(new File(mPathname), mBaudrate, 0);
|
mInputStream = mSerialPort.getInputStream();//调用对象SerialPort方法，获取串口中"读和写"的数据流
|
mOutputStream = mSerialPort.getOutputStream();
|
bOpenSuccess = true;
|
}
|
return mSerialPort;
|
}
|
|
/**
|
* 初始化串口
|
*/
|
public static void initHDLSerialPort(String mmPathname, int mmBaudrate) {
|
openSerialPort(mmPathname, mmBaudrate);
|
}
|
|
/**
|
* 判断串口是否打开
|
*/
|
public static Boolean getIsSerialPortOpen() {
|
return bOpenSuccess;
|
}
|
|
/**
|
* 打开串口，接收数据
|
* 通过串口，接收单片机发送来的数据
|
*/
|
public static Boolean openSerialPort(String mmPathname, int mmBaudrate) {
|
if (mSerialPort != null) {
|
HDLLog.I("HDLSDK 串口 已启动");
|
} else {
|
HDLLog.I("HDLSDK 串口 init");
|
try {
|
mPathname = mmPathname;
|
mBaudrate = mmBaudrate;
|
mSerialPort = new SerialPort(new File(mPathname), mBaudrate, 0);
|
HDLLog.I("HDLSDK 串口启动成功");
|
//调用对象SerialPort方法，获取串口中"读和写"的数据流
|
mInputStream = mSerialPort.getInputStream();
|
mOutputStream = mSerialPort.getOutputStream();
|
bOpenSuccess = true;
|
startHDLThread();
|
} catch (IOException e) {
|
e.printStackTrace();
|
bOpenSuccess = false;
|
HDLLog.I("HDLSDK 串口启动失败 IOException");
|
} catch (InvalidParameterException e) {
|
e.printStackTrace();
|
bOpenSuccess = false;
|
HDLLog.I("HDLSDK 串口启动失败 InvalidParameterException");
|
} catch (SecurityException e) {
|
e.printStackTrace();
|
bOpenSuccess = false;
|
HDLLog.I("HDLSDK 串口启动失败 SecurityException");
|
}
|
}
|
return bOpenSuccess;
|
}
|
|
/**
|
* 关闭串口
|
* 关闭串口中的输入输出流
|
*/
|
public static void closeSerialPort() {
|
HDLLog.I("关闭串口");
|
try {
|
mSendDatasList.clear();//清空发送队列
|
mReceiveDatasList.clear();//清空接收队列
|
bOpenSuccess = false;
|
// HDLCommand.cancelSearching();
|
|
// if (mHDLRead485DatasThread != null) mHDLRead485DatasThread.interrupt();
|
if (mHDLReadMCUDatasThread != null) mHDLReadMCUDatasThread.interrupt();
|
if (mHDLSendDatasThread != null) mHDLSendDatasThread.interrupt();
|
|
if (mInputStream != null) {
|
mInputStream.close();
|
}
|
if (mOutputStream != null) {
|
mOutputStream.close();
|
}
|
if (mSerialPort != null) {
|
mSerialPort.close();
|
mSerialPort = null;
|
}
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
|
}
|
|
/**
|
* 启动串口 发送和接收线程
|
*/
|
private static void startHDLThread() {
|
// mHDLRead485DatasThread = new HDLRead485DatasThread();
|
mHDLReadMCUDatasThread = new HDLReadMCUDatasThread();
|
mHDLSendDatasThread = new HDLSendDatasThread();
|
// mHDLRead485DatasThread.start();
|
mHDLReadMCUDatasThread.start();
|
mHDLSendDatasThread.start();
|
}
|
|
//
|
// /**
|
// * 串口接收线程
|
// *
|
// * @author 2019年06月26日
|
// */
|
// private static class HDLReadDatasThread extends Thread {
|
//
|
// @Override
|
// public void run() {
|
// super.run();
|
// HDLLog.I("接收线程 开启");
|
//
|
// while (bOpenSuccess) {
|
// int size = 0;
|
// try {
|
// if (mInputStream == null) return;
|
//
|
// byte[] buffer = new byte[64];
|
// size = mInputStream.read(buffer);
|
// for (int i = 0; i < size; i++) {
|
// mReceiveDatasList.add(buffer[i]);
|
// }
|
//
|
// while (0 < mReceiveDatasList.size()) {
|
// HDLLog.I("arraylist.size():" + mReceiveDatasList.size());
|
// if (mReceiveDatasList.size() < 3) break;//2019-07-02
|
// int len = -1;
|
// int startIndex = 0;
|
// for (startIndex = 0; startIndex < mReceiveDatasList.size(); startIndex++) {
|
// if ((mReceiveDatasList.get(startIndex) & 0xFF) == 0xAA
|
// && (mReceiveDatasList.get(startIndex + 1) & 0xFF) == 0xAA) {
|
// len = (mReceiveDatasList.get(startIndex + 2) & 0xFF) + 2;//发现len会出现负数增加 & 0xFF 运算
|
// break;
|
// }
|
// }
|
// if (len == -1 || mReceiveDatasList.size() < len) break;
|
//
|
// HDLLog.I("startIndex:" + startIndex + " LEN:" + len);
|
// for (int i = 0; i < startIndex; i++) {
|
// if (mReceiveDatasList.size() < 1) break;//2019-07-02
|
// mReceiveDatasList.remove(0);
|
// }
|
// byte[] tempBytes = new byte[len];
|
// for (int i = 0; i < tempBytes.length; i++) {
|
// if (mReceiveDatasList.size() < 1) break;//2019-07-02
|
//
|
// tempBytes[i] = mReceiveDatasList.get(0);
|
// mReceiveDatasList.remove(0);
|
// }
|
// HandleHDLdata(tempBytes);
|
// }
|
// } catch (Exception e) {
|
// e.printStackTrace();
|
// HDLLog.I("error:" + e.getMessage());
|
// }
|
// }
|
// HDLLog.I("接收线程 关闭");
|
// }
|
// }
|
|
/**
|
* 串口接收线程
|
* 对接HDL协议
|
* 引导头 控制域 数据长度 数据 校验码
|
* 0xA8
|
*
|
* @author 2019年07月12日
|
*/
|
private static class HDLReadMCUDatasThread extends Thread {
|
|
@Override
|
public void run() {
|
super.run();
|
HDLLog.I("接收线程 开启");
|
while (bOpenSuccess) {
|
int size = 0;
|
try {
|
Thread.sleep(1);//2019-07 降低CPU占用率
|
if (mInputStream == null) return;
|
byte[] buffer = new byte[64];
|
|
size = mInputStream.read(buffer);
|
// HDLLog.I("mReceiveDatasList： " + HDLStringUtils.ByteArrToHex(buffer, 0, buffer.length) );
|
for (int i = 0; i < size; i++) {
|
mReceiveDatasList.add(buffer[i]);
|
}
|
|
while (0 < mReceiveDatasList.size()) {
|
// HDLLog.I("arraylist.size():" + mReceiveDatasList.size());
|
if (mReceiveDatasList.size() < 3) break;//2019-07-02
|
if (mReceiveDatasList.size() > 3000) { //数据缓存太多错误情况下 清空一次
|
mReceiveDatasList.clear();
|
break;//2019-07-24
|
}
|
|
int len = -1;
|
int startIndex = 0;
|
|
for (startIndex = 0; startIndex < mReceiveDatasList.size(); startIndex++) {
|
if ((mReceiveDatasList.get(startIndex) & 0xFF) == 0xAA
|
&& (mReceiveDatasList.get(startIndex + 1) & 0xFF) == 0xAA) {
|
len = (mReceiveDatasList.get(startIndex + 2) & 0xFF) + 2;//发现len会出现负数增加 & 0xFF 运算
|
break;
|
}
|
}
|
|
if (len == -1 || mReceiveDatasList.size() < len) break;
|
// HDLLog.I("startIndex:" + startIndex + " LEN:" + len);
|
for (int i = 0; i < startIndex; i++) {
|
if (mReceiveDatasList.size() < 1) break;//2019-07-02
|
mReceiveDatasList.remove(0);
|
}
|
byte[] tempBytes = new byte[len];
|
for (int i = 0; i < tempBytes.length; i++) {
|
if (mReceiveDatasList.size() < 1) break;//2019-07-02
|
|
tempBytes[i] = mReceiveDatasList.get(0);
|
mReceiveDatasList.remove(0);
|
}
|
|
HandleHDLdata(tempBytes);
|
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
HDLLog.I("error:" + e.getMessage());
|
}
|
}
|
HDLLog.I("接收线程 关闭");
|
}
|
}
|
|
// /**
|
// * 485数据接收线程
|
// *
|
// * @author 2019年06月26日
|
// */
|
// private static class HDLRead485DatasThread extends Thread {
|
//
|
// @Override
|
// public void run() {
|
// super.run();
|
// HDLLog.I("485接收线程 开启");
|
// while (bOpenSuccess) {
|
// int size = 0;
|
// try {
|
// Thread.sleep(10);
|
// while (0 < mReceive485DatasList.size()) {
|
//// HDLLog.I("485arraylist.size():" + mReceive485DatasList.size());
|
// if (mReceive485DatasList.size() < 3) break;//2019-07-02
|
// if (mReceive485DatasList.size() > 500) { //数据缓存太多错误情况下 清空一次
|
// mReceive485DatasList.clear();
|
// break;//2019-07-24
|
// }
|
// int len = -1;
|
// int startIndex = 0;
|
// for (startIndex = 0; startIndex < mReceive485DatasList.size(); startIndex++) {
|
// if ((mReceive485DatasList.get(startIndex) & 0xFF) == 0xAA
|
// && (mReceive485DatasList.get(startIndex + 1) & 0xFF) == 0xAA) {
|
// len = (mReceive485DatasList.get(startIndex + 2) & 0xFF) + 2;//发现len会出现负数增加 & 0xFF 运算
|
// break;
|
// }
|
// }
|
// if (len == -1 || mReceive485DatasList.size() < len) break;
|
//
|
//// HDLLog.I("startIndex:" + startIndex + " LEN:" + len);
|
// for (int i = 0; i < startIndex; i++) {
|
// if (mReceive485DatasList.size() < 1) break;//2019-07-02
|
// mReceive485DatasList.remove(0);
|
// }
|
// byte[] tempBytes = new byte[len];
|
// for (int i = 0; i < tempBytes.length; i++) {
|
// if (mReceive485DatasList.size() < 1) break;//2019-07-02
|
//
|
// tempBytes[i] = mReceive485DatasList.get(0);
|
// mReceive485DatasList.remove(0);
|
// }
|
// HandleHDLdata(tempBytes);
|
// }
|
// } catch (Exception e) {
|
// e.printStackTrace();
|
// HDLLog.I("error:" + e.getMessage());
|
// }
|
// }
|
// HDLLog.I("485接收线程 关闭");
|
// }
|
// }
|
|
|
/**
|
* 串口发送线程
|
*/
|
private static class HDLSendDatasThread extends Thread {
|
@Override
|
public void run() {
|
super.run();
|
HDLLog.I("发送线程 开启");
|
while (bOpenSuccess) {
|
try {
|
Thread.sleep(100);
|
} catch (Exception e) {
|
e.getMessage();
|
}
|
for (int i = 0; i < mSendDatasList.size(); i++) {
|
try {
|
Thread.sleep(50);
|
} catch (Exception e) {
|
|
}
|
try {
|
byte[] sendBytes = mSendDatasList.get(i);
|
try {
|
mOutputStream.flush();
|
mOutputStream.write(sendBytes);
|
// HDLLog.I(
|
// "sendBytes：" + HDLStringUtils.ByteArrToHex(sendBytes, 0, sendBytes.length));
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
mSendDatasList.remove(i);
|
i--;
|
} catch (Exception ex) {
|
ex.getMessage();
|
}
|
}
|
}
|
HDLLog.I("发送线程 关闭");
|
}
|
}
|
|
// /**
|
// * 发送MUC串口协议数据包
|
// * @param mcuDataList
|
// * @param bPassThrough 是否为透传
|
// */
|
// public static void sendMCUData(final MCUCrc mcuDataList, Boolean bPassThrough) {
|
// if(HDLSerialPortCore.bPassThrough != bPassThrough ){
|
// HDLSerialPortCore.bPassThrough = bPassThrough;
|
// }
|
// //打印接受数据
|
// HDLLog.I("HHHHHsendMCUData： "+ HDLStringUtils.ByteArrToHex(mcuDataList.getMCUSendBytes(),0, mcuDataList.getMCUSendBytes().length));
|
// if (!bOpenSuccess) return;
|
// mSendDatasList.add(mcuDataList.getMCUSendBytes());
|
// }
|
|
/**
|
* 发送MUC串口协议数据包
|
*
|
* @param mcuDataList
|
*/
|
public static void sendMCUData(final MCUCrc mcuDataList) {
|
//打印接受数据
|
// HDLLog.I("HHHHHsendMCUData： "+ HDLStringUtils.ByteArrToHex(mcuDataList.getMCUSendBytes(),0, mcuDataList.getMCUSendBytes().length));
|
if (!bOpenSuccess) return;
|
mSendDatasList.add(mcuDataList.getMCUSendBytes());
|
}
|
|
|
/**
|
* 发送数据包
|
* 点对点或广播
|
*
|
* @param sendDatas
|
*/
|
public static void sendData(final Crc sendDatas) {
|
if (!bOpenSuccess) return;
|
mSendDatasList.add(sendDatas.GetSendBytes());
|
}
|
|
/**
|
* 发送组播
|
*
|
* @param sendDatas
|
*/
|
public static void sendMulticastData(final Crc sendDatas) {
|
if (!bOpenSuccess) return;
|
mSendDatasList.add(sendDatas.GetSendBytes());
|
}
|
|
|
/**
|
* 判断是否为HDL AA AA 开头数据
|
*
|
* @param bytes
|
* @return
|
*/
|
private static boolean isHDLDataWithHead(byte[] bytes) {
|
boolean isWant = true;
|
if ((bytes[0] & 0xFF) != 0xAA) {
|
isWant = false;
|
}
|
if ((bytes[1] & 0xFF) != 0xAA) {
|
isWant = false;
|
}
|
return isWant;
|
}
|
|
|
/**
|
* 处理HDL Data
|
*
|
* @param receiveBytes
|
*/
|
private synchronized static void HandleHDLdata(byte[] receiveBytes) {
|
if (receiveBytes.length < 14) {
|
return;
|
}
|
// 打印接收数据
|
// HDLLog.I("receiveBytes HandleHDLdata: " + HDLStringUtils.ByteArrToHex(receiveBytes, 0, receiveBytes.length));
|
|
//2019-8-21 校验Crc
|
if (!Crc.checkCRC(receiveBytes)) {
|
HDLLog.I("checkCRC：检验失败");
|
return;
|
}
|
// HDLLog.I("checkCRC：检验成功");
|
|
// //校验是否为0xAA 0xAA 开头数据数据
|
// if (!isHDLDataWithHead(receiveBytes)) {
|
// return;
|
// }
|
|
//打印接收数据
|
// HDLLog.I("receiveBytes HandleHDLdata: " + HDLStringUtils.ByteArrToHex(receiveBytes, 0, receiveBytes.length));
|
|
//数据长度
|
int addDataLength = (receiveBytes[2] & 0xFF) - 11;
|
//附加数据
|
byte[] usefulBytes = new byte[addDataLength];
|
//复制附加数据
|
System.arraycopy(receiveBytes, 11, usefulBytes, 0, addDataLength);
|
|
//操作码
|
int command = (receiveBytes[7] & 0xFF) * 256 + (receiveBytes[8] & 0xFF);
|
//源子网号
|
int sourceSubnetID = receiveBytes[3] & 0xFF;
|
//源设备号
|
int sourceDeviceID = receiveBytes[4] & 0xFF;
|
//目标子网号
|
int targetSubnetID = receiveBytes[9] & 0xFF;
|
//目标设备号
|
int targetDeviceID = receiveBytes[10] & 0xFF;
|
// //参数
|
// UdpDataBean udpDataBean = new UdpDataBean();
|
// udpDataBean.sourceSubnetID = sourceSubnetID;
|
// udpDataBean.sourceDeviceID = sourceDeviceID;
|
// udpDataBean.desSubnetID = targetSubnetID;
|
// udpDataBean.desDeviceID = targetDeviceID;
|
// udpDataBean.command = command;
|
//
|
// udpDataBean.addBytes = usefulBytes;
|
//// HandleOutsideData(targetSubnetID, targetDeviceID, command, usefulBytes, receiveBytes, udpDataBean);
|
// HandleInsideData(udpDataBean);
|
|
//s2019-8-20 增加目标子网号设备号判断
|
if ((targetSubnetID == 0xFF && targetDeviceID == 0xFF)
|
|| (targetSubnetID == Crc.localSubnetID && targetDeviceID == Crc.localDeviceID)) {
|
//参数
|
UdpDataBean udpDataBean = new UdpDataBean();
|
udpDataBean.sourceSubnetID = sourceSubnetID;
|
udpDataBean.sourceDeviceID = sourceDeviceID;
|
udpDataBean.desSubnetID = targetSubnetID;
|
udpDataBean.desDeviceID = targetDeviceID;
|
udpDataBean.command = command;
|
|
udpDataBean.addBytes = usefulBytes;
|
HandleInsideData(udpDataBean);
|
|
}
|
|
}
|
|
|
/**
|
* 处理内部命令数据
|
*
|
* @param sendDatas
|
*/
|
private static void HandleInsideData(UdpDataBean sendDatas) {
|
switch (sendDatas.command) {
|
case Configuration.DEVICES_SEARCH_BACK_COMMAND:
|
// 先判断搜索模式，家居搜索则只需要判断两个随机数。酒店搜索则需要判断两个随机数和ip地址
|
if (HandleSearch.curSearchMode == HandleSearch.GET_BUS_DEVICES) {
|
if (sendDatas.addBytes[0] == HandleSearch.random1
|
&& sendDatas.addBytes[1] == HandleSearch.random2) {
|
HDLDeviceManager.handle(sendDatas, sendDatas.command);
|
}
|
} else {
|
// if (sendDatas.addBytes[0] == HandleSearch.random1
|
// && sendDatas.addBytes[1] == HandleSearch.random2
|
// && HandleSearch.rcuIp.equals(sendDatas.ipAddress)
|
// ) {
|
// HDLDeviceManager.handle(sendDatas, sendDatas.command);
|
//
|
// }
|
if (sendDatas.addBytes[0] == HandleSearch.random1
|
&& sendDatas.addBytes[1] == HandleSearch.random2
|
) {
|
HDLDeviceManager.handle(sendDatas, sendDatas.command);
|
}
|
}
|
|
break;
|
|
/***2020-04-01 新增通用开关**/
|
case Configuration.COMMON_SWITCH_CTRL_BACK_COMMAND:
|
case Configuration.COMMON_SWITCH_STATE_BACK_COMMAND:
|
case Configuration.LIGHT_CTRL_BACK_COMMAND:
|
case Configuration.CURTAIN_CTRL_BACK_COMMAND:
|
case Configuration.AIR_CTRL_BACK_COMMAND:
|
case Configuration.LOGIC_CTRL_BACK_COMMAND:
|
case Configuration.LOGIC_STATE_BACK_COMMAND:
|
case Configuration.LIGHT_STATE_BACK_COMMAND:
|
case Configuration.SECURITY_ARMING_CTRL_BACK_COMMAND://20190729安防模块 布防设置反馈
|
case Configuration.SECURITY_STATE_BACK_COMMAND://20190729 读取安防设置反馈
|
case Configuration.SECURITY_ALARM_CTRL_BACK_COMMAND://20190729 报警设置反馈
|
case Configuration.CURTAIN_STATE_BACK_COMMAND:
|
case Configuration.CURTAIN_STATE_BROADCAST_BACK_COMMAND://2019-12-16 新增广播状态监听
|
case Configuration.AIR_STATE_BACK_COMMAND:
|
case Configuration.AIR_HVAC_CTRL_BACK_COMMAND:
|
case Configuration.AIR_HVAC_STATE_BACK_COMMAND:
|
// case Configuration.RCU_ROOM_CAST_COMMAND:
|
// case Configuration.RCU_CURTAIN_CAST_COMMAND:
|
case Configuration.DEVICES_READ_BACK_COMMAND://读取备注命令
|
case Configuration.DEVICES_MODIFY_BACK_COMMAND://修改基本信息回复
|
case Configuration.MODULE_UPDATE_REMARK_BACK_COMMAND://修改模块备注回复
|
case Configuration.WARNING_COMMAND:
|
case Configuration.SENSOR_STATE_BACK_COMMAND:
|
case Configuration.SENSOR_BROADCAST_STATE_BACK_COMMAND://2019-11-1 增加
|
case Configuration.DRY_CONTACT_STATE_BACK_COMMAND:
|
case Configuration.DRY_CONTACT_BROADCAST_STATE_COMMAND://2019-11-5 增加干接点状态回复
|
// case Configuration.AUDIO_CTRL_READ_COMMAND:
|
case Configuration.AUDIO_CTRL_READ_BACK_COMMAND:
|
// case Configuration.AUDIO_MenuPlay_INSTRUCTION_COMMAND:
|
case Configuration.AUDIO_MenuPlay_INSTRUCTION_BACK_COMMAND:
|
|
HDLDeviceManager.handle(sendDatas, sendDatas.command);
|
break;
|
|
|
// case Configuration.RCU_SEARCH_COMMAND:
|
//// if (sendDatas.port == Configuration.RCU_SEND_PORT) {
|
// HDLLog.I( "收到搜索RCU命令");
|
// HDLDeviceManager.handle(sendDatas, sendDatas.command);
|
//// }
|
//
|
// break;
|
// case Configuration.RCU_READ_SDK_INFO_COMMAND:
|
//// if (sendDatas.desSubnetID == Crc.localSubnetID && sendDatas.desDeviceID == Crc.localDeviceID
|
//// ) {
|
//// HDLLog.I( "E508收到");
|
//// HDLDeviceManager.handle(sendDatas, Configuration.RCU_READ);
|
//// }
|
//// if (sendDatas.port == Configuration.RCU_SEND_PORT) {
|
// HDLLog.I( "收到读取SDK信息命令");
|
// HDLDeviceManager.handle(sendDatas, sendDatas.command);
|
//// }
|
|
// break;
|
case Configuration.MANUAL_ADD_DEVICE_COMMAND:
|
//固定随机数181、250
|
if (sendDatas.addBytes[0] == ((byte) 181)
|
&& sendDatas.addBytes[1] == ((byte) 250)) {
|
HDLDeviceManager.handle(sendDatas, sendDatas.command);
|
}
|
break;
|
case Configuration.MANUAL_ADD_REMARK_COMMAND:
|
HDLDeviceManager.handle(sendDatas, sendDatas.command);
|
break;
|
default:
|
break;
|
}
|
}
|
|
|
// /**
|
// * 判断是否为HDL数据
|
// * @param bytes
|
// * @return
|
// */
|
// private static boolean isHDLData(byte[] bytes) {
|
//
|
// boolean isWant = true;
|
// for (int index = 0; index < bytes.length; index++) {
|
// switch (index) {
|
// case 0:
|
// if (bytes[index] != 0x48) {
|
// isWant = false;
|
// }
|
// break;
|
// case 1:
|
// if (bytes[index] != 0x44) {
|
// isWant = false;
|
// }
|
// break;
|
// case 2:
|
// if (bytes[index] != 0x4C) {
|
// isWant = false;
|
// }
|
// break;
|
// case 3:
|
// if (bytes[index] != 0x4D) {
|
// isWant = false;
|
// }
|
// break;
|
// case 4:
|
// if (bytes[index] != 0x49) {
|
// isWant = false;
|
// }
|
// break;
|
// case 5:
|
// if (bytes[index] != 0x52) {
|
// isWant = false;
|
// }
|
// break;
|
// case 6:
|
// if (bytes[index] != 0x41) {
|
// isWant = false;
|
// }
|
// break;
|
// case 7:
|
// if (bytes[index] != 0x43) {
|
// isWant = false;
|
// }
|
// break;
|
// case 8:
|
// if (bytes[index] != 0x4C) {
|
// isWant = false;
|
// }
|
// break;
|
// case 9:
|
// if (bytes[index] != 0x45) {
|
// isWant = false;
|
// }
|
// break;
|
//
|
// default:
|
// break;
|
// }
|
// }
|
// return isWant;
|
// }
|
//
|
// /**
|
// * 处理HDL Data
|
// *
|
// * @param receiveBytes
|
// */
|
// private synchronized static void HandleMCUdata(byte[] receiveBytes) {
|
// if (receiveBytes.length < 5) {
|
// return;
|
// }
|
//
|
// //打印接受数据
|
// HDLLog.I("receiveBytes HandleMCUdata: " + HDLStringUtils.ByteArrToHex(receiveBytes, 0, receiveBytes.length));
|
// //操作码
|
// int command = receiveBytes[1] & 0xFF;
|
// //数据长度
|
// int addDataLength = (receiveBytes[2] & 0xFF) * 256 + (receiveBytes[3] & 0xFF);
|
// //附加数据
|
// byte[] usefulBytes = new byte[addDataLength];
|
// //复制附加数据
|
// System.arraycopy(receiveBytes, 4, usefulBytes, 0, addDataLength);
|
//
|
// //参数
|
// MCUDataBean mMCUDataBean = new MCUDataBean();
|
// mMCUDataBean.command = command;
|
// mMCUDataBean.receiveBytes = usefulBytes;
|
//
|
// HandleMCUData(mMCUDataBean);
|
//
|
// }
|
|
//
|
// /**
|
// * 处理MCU返回的命令数据
|
// *
|
// * @param mMCUDataBean
|
// */
|
// private static void HandleMCUData(MCUDataBean mMCUDataBean) {
|
// switch (mMCUDataBean.command) {
|
// case MCUConstants.MCU_COMMAND_SEND_BACK: //0x80 上报数据
|
// if (!HDLSerialPortCore.bPassThrough) {
|
//// HandleHDLdata(mMCUDataBean.receiveBytes); //不是透传的话，处理485数据
|
//
|
// AddReceive485DatasList(mMCUDataBean.receiveBytes);
|
// } else {
|
// HDLDeviceManager.HandleMCUData(mMCUDataBean);
|
//
|
// }
|
// break;
|
// case MCUConstants.MCU_SEND_UPGRADE_DATA_BACK: //0x05 发送升级数据返回 注意，当文件地址为0xF5F5F5F5的时候，代表发生错误，升级包不对，会退出升级模式。当文件地址为0xF8F8F8F8,代表成功，成功后会重启,监听到重启完毕，才代表完成。
|
// handleSendUpgradeDataBack(mMCUDataBean);
|
// break;
|
// default:
|
// HDLDeviceManager.HandleMCUData(mMCUDataBean);
|
// break;
|
// }
|
// }
|
//
|
//// /**
|
//// *
|
//// * @param receive485Bytes
|
//// */
|
//// private static void AddReceive485DatasList(byte[] receive485Bytes) {
|
//// for (int i = 0; i < receive485Bytes.length; i++) {
|
//// mReceive485DatasList.add(receive485Bytes[i]);
|
//// }
|
//// }
|
//
|
//
|
// private static void handleSendUpgradeDataBack(MCUDataBean mMCUDataBean) {
|
// try {
|
// int addressIndex = HDLUtlis.byteArrayToInt(mMCUDataBean.receiveBytes);
|
// HDLLog.I("addressIndex：" + addressIndex);
|
// if (addressIndex == 0xF5F5F5F5) {
|
// //当文件地址为0xF5F5F5F5的时候，代表发生错误，升级包不对，会退出升级模式
|
// sendIMcuOtaListeneronFailure(EventCode.FAILURE_DATA_ERROR, "升级错误，升级包不对");
|
// } else if (addressIndex == 0xF8F8F8F8) {
|
// //当文件地址为0xF8F8F8F8,代表成功，成功后会重启,监听到重启完毕
|
// sendIMcuOtaListenerOnProgress(100);
|
// sendIMcuOtaListenerOnSuccess();
|
// upgradeFileDatas = null;//升级文件清空
|
// } else {
|
// //继续升级 返送下一个升级包 并返回进度
|
// if (addressIndex > upgradeFileDatas.length) {
|
// HDLLog.E("addressIndex 大于升级包长度");
|
// return;
|
// }
|
//
|
// HDLCommand.mcuSendUpgradeData(getNextUpgradebytes(mMCUDataBean.receiveBytes, addressIndex));
|
// int progress = addressIndex * 100 / (upgradeFileDatas.length - 1);
|
// sendIMcuOtaListenerOnProgress(progress);
|
// }
|
// } catch (Exception e) {
|
// e.printStackTrace();
|
// HDLLog.E("handleSendUpgradeDataBack 出错");
|
// }
|
//
|
// }
|
//
|
// /**
|
// * 获取下一段升级包数据
|
// *
|
// * @param index
|
// */
|
// private static byte[] getNextUpgradebytes(byte[] addressBytes, int index) {
|
// byte[] newBytes = new byte[1030];//1024+6
|
// System.arraycopy(addressBytes, 0, newBytes, 0, 4);
|
// int sub = upgradeFileDatas.length - 1 - index;
|
// if (sub >= 1024) {
|
// System.arraycopy(upgradeFileDatas, index, newBytes, 6, 1024);
|
// } else {
|
// System.arraycopy(upgradeFileDatas, index, newBytes, 6, sub);
|
// }
|
// newBytes[4] = 0x04;//默认数据长度为1024
|
// newBytes[5] = 0x00;
|
//
|
// return newBytes;
|
// }
|
//
|
//
|
// /**
|
// * 设置监听事件
|
// *
|
// * @param listener
|
// */
|
// public static void setIMcuOtaListener(IMcuOtaListener listener) {
|
// mIMcuOtaListener = listener;
|
// }
|
//
|
// public static void removeIMcuOtaListener() {
|
// mIMcuOtaListener = null;
|
// }
|
//
|
// /**
|
// * onProgress
|
// *
|
// * @param progress
|
// */
|
// public static void sendIMcuOtaListenerOnProgress(int progress) {
|
// if (mIMcuOtaListener != null) {
|
// progress = HDLUtlis.getTrueProgressInt(progress);//确保progress 在0到100
|
// mIMcuOtaListener.onProgress(progress);
|
// }
|
// }
|
//
|
// /**
|
// * onSuccess
|
// */
|
// public static void sendIMcuOtaListenerOnSuccess() {
|
// if (mIMcuOtaListener != null) {
|
// mIMcuOtaListener.onSuccess();
|
// }
|
// }
|
//
|
// /**
|
// * onFailure
|
// *
|
// * @param code 错误码
|
// * @param error 失败原因
|
// */
|
// public static void sendIMcuOtaListeneronFailure(int code, String error) {
|
// if (mIMcuOtaListener != null) {
|
// mIMcuOtaListener.onFailure(code, error);
|
// }
|
// }
|
//
|
|
}
|
