package com.socket;
|
|
|
import android.os.Handler;
|
import android.os.Message;
|
import android.util.Log;
|
import android.webkit.WebView;
|
|
import com.concentrator.Concentrator_ComBase;
|
import com.concentrator.Concentrator_Param;
|
import com.concentrator.Concentrator_State;
|
import com.fgkj.action.ServiceModel;
|
import com.fgkj.dao.ActionUtil;
|
import com.fgkj.dao.DBHelper;
|
import com.google.gson.Gson;
|
import com.util.Com;
|
|
import java.util.Date;
|
|
/**
|
* 电池组组操作相关类
|
*/
|
public class BattDataThread extends Thread{
|
public static final String TAG = "BattDataThread";
|
|
|
public Handler mSocketHandler = null;
|
private CommSockClientThread clientThread = null;
|
public boolean isInstall = false; //是否安装
|
public int battIndex = 1; //电池组ID 默认电池组ID
|
public Concentrator_Param param; //汇集器参数
|
public Concentrator_State state; //汇集器状态
|
public DBHelper dbHelper;
|
public WebView webView;
|
|
|
public Date lastUpdateTime = new Date(); //上一次获取数据时间
|
public boolean isOutTime = true; //通讯是否超时 超时重连时会重新获取设备的系统参数
|
|
|
public BattDataThread(int battIndex, DBHelper dbHelper,WebView webView){
|
this.webView = webView;
|
this.dbHelper = dbHelper;
|
this.battIndex = battIndex;
|
param = new Concentrator_Param();
|
state = new Concentrator_State();
|
clientThread = CommSockClientThread.createClientThread(); //串口通讯线程 //每个电池组通用同一个串口线程
|
this.mSocketHandler = new Handler(){
|
@Override
|
public void handleMessage(Message msg) {
|
ServiceModel model = (ServiceModel)msg.obj;
|
if(model != null){
|
if(model.code ==1){
|
lastUpdateTime = new Date();
|
//操作执行成功
|
if(model.cmd_type == Concentrator_ComBase.CMD_MODEBUS_READCMD){
|
//读取成功
|
if(model.cmd == Concentrator_ComBase.CMD_MODEBUS_SYSTEMPARAM_INDEX ){
|
//读取设备参数成功
|
param.clone((Concentrator_Param)model.data); //获取当前设备额参数
|
state.monCount = param.countMonCount(); //统计当前设备的单体数量
|
//Log.e(TAG, "handleMessage: 获取设备参数成功" );
|
}
|
|
if(model.cmd == Concentrator_ComBase.CMD_MODEBUS_DEVICESTATE_INDEX){
|
//读取设备状态成功
|
state.cloneSystemState((Concentrator_State) model.data);
|
//Log.e(TAG, "handleMessage: 获取设备状态成功" );
|
}else if(model.cmd >= Concentrator_ComBase.CMD_MODEBUS_BATTMONVOL_INDEX && model.cmd < Concentrator_ComBase.CMD_MODEBUS_BATTMONTMP_INDEX){
|
//读取单体电压成功
|
//Log.e(TAG, "handleMessage: 获取单体电压成功" );
|
state.cloneMonVol((Concentrator_State)model.data);
|
}else if(model.cmd >= Concentrator_ComBase.CMD_MODEBUS_BATTMONTMP_INDEX && model.cmd < Concentrator_ComBase.CMD_MODEBUS_BATTMONRES_INDEX){
|
//读取单体温度成功
|
//Log.e(TAG, "handleMessage: 获取单体温度成功" );
|
state.cloneMonTmp((Concentrator_State)model.data);
|
}else if(model.cmd >= Concentrator_ComBase.CMD_MODEBUS_BATTMONRES_INDEX && model.cmd < (Concentrator_ComBase.CMD_MODEBUS_BATTMONRES_INDEX+300)){
|
//读取单体内阻成功
|
//Log.e(TAG, "handleMessage: 获取单体内阻成功" );
|
state.cloneMonRes((Concentrator_State)model.data);
|
}
|
}else if(model.cmd_type == Concentrator_ComBase.CMD_MODEBUS_WRITECMD){
|
//设置成功
|
if(model.cmd == Concentrator_ComBase.CMD_MODEBUS_SYSTEMPARAM_INDEX ){
|
//设置参数成功
|
}
|
}else if(model.cmd_type == Concentrator_ComBase.CMD_MODEBUS_SINGLEWRITECMD){
|
//单点设置成功(启动/停止内阻测试，重启系统)
|
if(model.cmd == Concentrator_ComBase.CMD_STARTRESTEST_INDEX){
|
//
|
Log.e(TAG, "handleMessage: battindex"+battIndex + "启动内阻测试成功" );
|
}else if(model.cmd == Concentrator_ComBase.CMD_STOPRESTTEST_INDEX){
|
Log.e(TAG, "handleMessage: battindex"+battIndex + "停止内阻测试成功" );
|
}else if(model.cmd == Concentrator_ComBase.CMD_RESTART_INDEX){
|
Log.e(TAG, "handleMessage: battindex"+battIndex + "重启汇集器成功" );
|
}
|
}
|
}
|
if(model.methodName != null && model.methodName.length()>0){
|
ActionUtil.SendCallDataToJS(model.methodName,model,webView,ActionUtil.getGson());
|
}
|
}
|
}
|
};
|
}
|
|
|
@Override
|
public void run() {
|
Log.e(TAG, "run: battindex"+battIndex +"\t start at "+ Com.getDateTimeFormat(new Date(),Com.DTF_YMDhms));
|
Date nowTime = new Date(); //当前时间
|
|
int monRCount = 0; //单体读取
|
int runCount = 0; //执行次数
|
while(true){
|
try {
|
|
//Log.e(TAG, "run: &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&install" + isInstall+"\tOutTime"+isOutTime);
|
if(isInstall){
|
//如果当前电池组已安装则实时获取当前电池组的单体信息
|
if( isOutTime ){
|
//超时之后只获取当前的系统参数
|
readSystemParam(""); //读取系统参数
|
}else{
|
if(runCount %15 == 0){
|
//读取系统状态
|
readSystemState("");
|
}
|
|
if(runCount % 15 == 0){
|
int maxCount = (int)Math.ceil((double)state.monCount/100); //最多需要读取次数
|
int monindex = monRCount % maxCount; //单体索引
|
//读取单体电压
|
readBattMonVol(monindex,"");
|
|
//读取单体温度
|
readBattMonTmp(monindex,"");
|
|
//读取单体内阻
|
readBattMonRes(monindex,"");
|
|
monRCount++;
|
}
|
}
|
}
|
runCount ++;
|
nowTime = new Date();
|
long timeCount = (nowTime.getTime() - lastUpdateTime.getTime())/1000;
|
if(timeCount > 60){
|
isOutTime = true; //60秒未通讯判定为通讯超时
|
}else{
|
isOutTime = false;
|
}
|
|
|
|
sleep(200);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
//获取系统参数
|
public void readSystemParam(String method){
|
sendMessageToSocketClient(this.mSocketHandler, Concentrator_ComBase.CMD_MODEBUS_SYSTEMPARAM_INDEX,Concentrator_ComBase.CMD_MODEBUS_READCMD,"",method);
|
}
|
|
//设置系统参数
|
public void writeSystemParam(String method,String json){
|
sendMessageToSocketClient(this.mSocketHandler, Concentrator_ComBase.CMD_MODEBUS_SYSTEMPARAM_INDEX,Concentrator_ComBase.CMD_MODEBUS_WRITECMD,json,method);
|
}
|
|
//获取系统状态
|
public void readSystemState(String method){
|
sendMessageToSocketClient(this.mSocketHandler, Concentrator_ComBase.CMD_MODEBUS_DEVICESTATE_INDEX,Concentrator_ComBase.CMD_MODEBUS_READCMD,"",method);
|
}
|
|
//获取电池组单体电压
|
public void readBattMonVol(int monindex,String method){
|
sendMessageToSocketClient(this.mSocketHandler, (Concentrator_ComBase.CMD_MODEBUS_BATTMONVOL_INDEX + monindex*100),Concentrator_ComBase.CMD_MODEBUS_READCMD,"",method);
|
}
|
|
//获取电池组单体温度
|
public void readBattMonTmp(int monindex,String method){
|
sendMessageToSocketClient(this.mSocketHandler, (Concentrator_ComBase.CMD_MODEBUS_BATTMONTMP_INDEX + monindex*100),Concentrator_ComBase.CMD_MODEBUS_READCMD,"",method);
|
}
|
|
//获取电池组单体内阻
|
public void readBattMonRes(int monindex,String method){
|
sendMessageToSocketClient(this.mSocketHandler, (Concentrator_ComBase.CMD_MODEBUS_BATTMONRES_INDEX+ monindex*100),Concentrator_ComBase.CMD_MODEBUS_READCMD,"",method);
|
}
|
|
//启动内阻测试
|
public void startBattResTest(String method){
|
sendMessageToSocketClient(this.mSocketHandler, Concentrator_ComBase.CMD_STARTRESTEST_INDEX,Concentrator_ComBase.CMD_MODEBUS_SINGLEWRITECMD,"",method);
|
}
|
|
//停止内阻测试
|
public void stopBattResTest(String method){
|
sendMessageToSocketClient(this.mSocketHandler, Concentrator_ComBase.CMD_STOPRESTTEST_INDEX,Concentrator_ComBase.CMD_MODEBUS_SINGLEWRITECMD,"",method);
|
}
|
|
//重启汇集器
|
public void reStartSystem(String method){
|
sendMessageToSocketClient(this.mSocketHandler, Concentrator_ComBase.CMD_RESTART_INDEX,Concentrator_ComBase.CMD_MODEBUS_SINGLEWRITECMD,"",method);
|
}
|
|
/**
|
* 发送消息给串口读取指定的信息
|
* @param handler
|
* @param cmd
|
* @param json
|
* @return
|
*/
|
private boolean sendMessageToSocketClient(Handler handler, int cmd,int cmd_type,String json,String methodName)
|
{
|
ServiceModel model = new ServiceModel();
|
model.cmd = cmd;
|
model.cmd_type = cmd_type;
|
model.mhandler = handler;
|
model.msg = json;
|
model.methodName = methodName; //回掉方法名称
|
model.battindex = battIndex; //当前电池组id
|
|
Message childMsg = clientThread.mHandler.obtainMessage();
|
childMsg.obj = model;
|
return (clientThread.mHandler.sendMessage(childMsg));
|
}
|
|
}
|
