package com.socket;
|
|
|
import android.os.Handler;
|
import android.os.Message;
|
import android.util.Log;
|
import android.webkit.WebView;
|
|
import com.alarms.AlarmParam.*;
|
import com.alarms.BattAlarmCheckThread;
|
import com.alarms.BattAlarmData;
|
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.fgkj.dto.Battinf;
|
import com.google.gson.Gson;
|
import com.util.Com;
|
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
|
/**
|
* 电池组组操作相关类
|
*/
|
public class BattDataThread extends Thread{
|
public static final int TESTTYPE_NULL = 0; //
|
public static final int TESTTYPE_CHRTEST = 2; //充电测试
|
public static final int TESTTYPE_DISTEST = 3; //放电测试
|
public static final int TESTTYPE_RESTEST = 5; //内阻测试
|
|
public static final String TAG = "BattDataThread";
|
|
|
public transient Handler mSocketHandler = null;
|
private transient CommSockClientThread clientThread = null;
|
public boolean isInstall = false; //是否安装
|
public int battIndex = 1; //电池组ID 默认电池组ID
|
public boolean isAlarmClear = true;
|
public transient Concentrator_Param param; //汇集器参数
|
public Concentrator_State state; //汇集器状态
|
public Battinf battinf; //电池组信息
|
public transient DBHelper dbHelper;
|
public transient WebView webView;
|
|
|
public Date lastUpdateTime = new Date(0,1,1); //上一次获取数据时间
|
public boolean isOutTime = true; //通讯是否超时 超时重连时会重新获取设备的系统参数
|
public long loseTimeLong = 0; //断开连接时长
|
|
private BattDataThread(){
|
|
}
|
|
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(); //串口通讯线程 //每个电池组通用同一个串口线程
|
|
//内阻记录线程
|
BattResDataRecordThread battResDataRecordThread = new BattResDataRecordThread(this,dbHelper);
|
battResDataRecordThread.start();
|
|
//充放电记录线程
|
//BattTestDataRecordThread battTestDataRecordThread = new BattTestDataRecordThread(dbHelper,this);
|
//battTestDataRecordThread.start();
|
|
|
|
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();
|
//Log.e(TAG, "handleMessage: cmd:"+model.cmd+"\t cmd_type:"+model.cmd_type );
|
//操作执行成功
|
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(); //统计当前设备的单体数量
|
//state.monCount = 300; //统计当前设备的单体数量
|
Log.e(TAG, "handleMessage: 获取设备参数成功" +state.monCount);
|
}
|
|
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){
|
//读取单体电压成功
|
int index = (model.cmd - Concentrator_ComBase.CMD_MODEBUS_BATTMONVOL_INDEX);
|
//Log.e(TAG, "handleMessage: 获取单体电压成功" );
|
state.cloneMonVol((Concentrator_State)model.data,index);
|
}else if(model.cmd >= Concentrator_ComBase.CMD_MODEBUS_BATTMONTMP_INDEX && model.cmd < Concentrator_ComBase.CMD_MODEBUS_BATTMONRES_INDEX){
|
//读取单体温度成功
|
int index = (model.cmd - Concentrator_ComBase.CMD_MODEBUS_BATTMONTMP_INDEX);
|
//Log.e(TAG, "handleMessage: 获取单体温度成功" );
|
state.cloneMonTmp((Concentrator_State)model.data,index);
|
}else if(model.cmd >= Concentrator_ComBase.CMD_MODEBUS_BATTMONRES_INDEX && model.cmd < (Concentrator_ComBase.CMD_MODEBUS_BATTMONRES_INDEX+300)){
|
//读取单体内阻成功
|
int index = (model.cmd - Concentrator_ComBase.CMD_MODEBUS_BATTMONRES_INDEX);
|
//Log.e(TAG, "handleMessage: 获取单体内阻成功" );
|
state.cloneMonRes((Concentrator_State)model.data,index);
|
}
|
}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 + "重启汇集器成功" );
|
}
|
}
|
}else{
|
if(model.cmd == Concentrator_ComBase.CMD_RESTART_INDEX && isInstall && !isOutTime){
|
model.code = 1;
|
}
|
}
|
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 {
|
|
if(isInstall){
|
//Log.e(TAG, "run: &&&&&&&&&&&&&&&&"+battIndex+"&&&&&&&&&&&&&&&&&&&&&&&&&&&install" + isInstall+"\tOutTime"+isOutTime+"\t"+Com.getDateTimeFormat(lastUpdateTime,Com.DTF_YMDhms));
|
//如果当前电池组已安装则实时获取当前电池组的单体信息
|
if( isOutTime ){
|
if(runCount %15 == 0) {
|
//超时之后只获取当前的系统参数
|
readSystemParam(""); //读取系统参数
|
}
|
}else{
|
if(runCount %15 == 0){
|
//读取系统状态
|
readSystemState("");
|
}
|
|
if(runCount % 25 == 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();
|
loseTimeLong = Math.abs(nowTime.getTime() - lastUpdateTime.getTime())/1000;
|
if(loseTimeLong > 60){
|
isOutTime = true; //60秒未通讯判定为通讯超时
|
}else{
|
isOutTime = false;
|
}
|
sleep(200);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
/**
|
*
|
* @return
|
*/
|
public BattDataThread cloneRtData(){
|
BattDataThread battDataThread = new BattDataThread();
|
battDataThread.state = this.state;
|
battDataThread.battinf =this.battinf;
|
return battDataThread;
|
}
|
|
|
//获取系统参数
|
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;
|
//Log.e(TAG, battIndex+"sendMessageToSocketClient: isStall"+ isInstall);
|
return (clientThread.mHandler.sendMessage(childMsg));
|
}
|
|
/**
|
* 根据当前对象构造BattInf对象
|
* @return
|
*/
|
public Battinf createBattInf(){
|
Battinf battinf = new Battinf();
|
battinf.setBattGroupId(battIndex);
|
battinf.setBattFloatCurrent(3);
|
battinf.setBattGroupName1("电池组");
|
battinf.setBattGroupName("电池组"+battIndex);
|
battinf.setBattInUseDate(new Date());
|
battinf.setBattProducer("");
|
battinf.setMonCapStd(param.monStdCap);
|
battinf.setMonCount(state.monCount);
|
battinf.setMonResStd(0.2);
|
battinf.setMonSerStd(5000);
|
battinf.setMonTmpStd(24);
|
return battinf;
|
}
|
|
@Override
|
public String toString() {
|
return "BattDataThread{" +
|
"mSocketHandler=" + mSocketHandler +
|
", clientThread=" + clientThread +
|
", isInstall=" + isInstall +
|
", battIndex=" + battIndex +
|
", param=" + param +
|
", state=" + state +
|
", battinf=" + battinf +
|
", dbHelper=" + dbHelper +
|
", webView=" + webView +
|
", lastUpdateTime=" + lastUpdateTime +
|
", isOutTime=" + isOutTime +
|
", loseTimeLong=" + loseTimeLong +
|
'}';
|
}
|
|
|
public static void main(String[] args) {
|
List list = new ArrayList<>();
|
for(int i = 0;i<10;i++){
|
BattDataThread battDataThread = new BattDataThread();
|
list.add(battDataThread.state);
|
list.add(battDataThread.battinf);
|
}
|
Gson gson = new Gson();
|
System.out.println(gson.toJson(list));
|
|
}
|
}
|
