修改为根据ip地址识别设备

whyclj

2020-08-31 bcf67488c65c420984de5b68e2aad77e31bcf75d

修改为根据ip地址识别设备

 BattMonitor_FBS9600SMore/src/com/dev_fbs9600s/data/FBS9600S_Cmd.java

@@ -8,7 +8,7 @@




public class FBS9600S_Cmd {

    public final static int BYTE_LEN = 7;

    public final static int BYTE_LEN = 6;

    public final static int DATA_NULL = 0;

    

    public int dev_id = 1;

@@ -46,10 +46,10 @@
        if(bf.limit() < BYTE_LEN)

            return false;

        ByteBuffer tmpbuf = bf;

        dev_id = ComBase.changeShortToInt(tmpbuf.getShort());

        //dev_id = ComBase.changeShortToInt(tmpbuf.getShort());

        //System.err.println(dev_id);

        tmpbuf.compact();

        tmpbuf.flip();

        //tmpbuf.compact();

        //tmpbuf.flip();

        int crc0 = tmpbuf.getShort(tmpbuf.limit() - 2)& 0xFFFF;

        int crc1 = Crc16.CalCRC16(tmpbuf, tmpbuf.limit()-2)& 0xFFFF;

        crc1 = ((crc1<<8) + (crc1>>8)) & 0xffff;


 BattMonitor_FBS9600SMore/src/com/dev_fbs9600s/data/FBS9600S_SocketClient_Thread_New.java

New file
@@ -0,0 +1,525 @@
package com.dev_fbs9600s.data;



import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.util.Date;



import com.battmonitor.base.Com;

import com.battmonitor.data.BattData_RT;

import com.battmonitor.data.BattData_RT_Array;

import com.battmonitor.sql.MysqlConnPool;

import com.dev.btse.comm.FBS9100S_SocketClient2;

import com.dev.btse.comm.FBS9100_Task_Thread_SQL;

import com.dev.btse.data.ComFn;

import com.dev.btse.data.Ecb_Aes;

import com.dev.btse.data.FBS9100_ComBase;

import com.dev.btse.data.FBS9100_SysState;



public class FBS9600S_SocketClient_Thread_New extends Thread{

    private MysqlConnPool mysql_pool;

    private BattData_RT_Array battData;

    private Socket socket;

    public BattData_RT[] BattData_RT = new BattData_RT[FBS9600S_ComBase.BattGroupCountMax];

	
    public FBS9600S_SystemState sysState;                //当前汇集器的状态

    private FBS9600S_SystemParam sysParam;                //主汇集器的参数

    private FBS9600S_SystemParam nowParam;                //当前汇集器的参数

    private FBS9600S_MonData monData;                    //单体数据

    public int dev_id = 0;

    public String dev_ip = "127.0.0.1";

    private int nowMonIndex = 0;                        //当前已读取单体总数

	
    private int mainConcen_addr = 1;                    //主汇集器的设备地址

    private boolean S_thread_run_flag = true;

    private int m_BattMonCount = 0;                        //单体总数量(当前机房总的单体数量)

    private int rx_errcount_for_live_of_thread = 0;        //用于统计socket通信中的异常次数统计

    private ByteBuffer bytebuffer_for_socket_RX = ByteBuffer.allocate(1500);

    public boolean is_success_dev = false;

	
	
	
	
    public FBS9600S_SocketClient_Thread_New(MysqlConnPool mysql_pool,BattData_RT_Array battData,Socket socket){

        this.mysql_pool = mysql_pool;

        this.battData = battData;

        this.socket = socket;

		
        int group_max = FBS9100_ComBase.BattGroupCountMax;

        for(int n=0; n<group_max; n++) {

            BattData_RT[n] = null;

        }

		
        String ip_str = this.socket.getInetAddress().getHostAddress();

        System.err.println("ip_str:"+ip_str+"电池组总数："+battData.getItemCount());

        S_thread_run_flag = false;

        for(int i=0;i<battData.getItemCount();i++) {

            BattData_RT rdData = battData.getItem(i);

            if(rdData.FBSDeviceId /10000000 == 96) {

                //9600设备

                //if(rdData.FBSDeviceIp.equals(ip_str)) {

                if(ip_str.endsWith(rdData.FBSDeviceIp)) {

                    dev_id = rdData.FBSDeviceId;

                    dev_ip = rdData.FBSDeviceIp;

                    BattData_RT[rdData.GroupIndexInFBSDevice%group_max] = rdData;

                    m_BattMonCount += rdData.MonCount;

                    S_thread_run_flag = true;

                    is_success_dev = true;

                }

            }

        }

		
		
        //System.out.println("总单体总数为："+m_BattMonCount);

        sysState = new FBS9600S_SystemState(dev_id,dev_ip);

        nowParam = new FBS9600S_SystemParam();

        monData = new FBS9600S_MonData();

		
        //checkDevType();                         //检测设备类型

    }

	
    /**

     * 
     */

    public void checkDevType() {

        int group_max = FBS9100_ComBase.BattGroupCountMax;

        FBS9600S_Cmd cmd = new FBS9600S_Cmd(1,FBS9600S_ComBase.CMD_READ_MODBUS,FBS9600S_ComBase.CMD_SystemParam_Addr,FBS9600S_SystemParam.REGCOUNT);

        for(int i=0;i<3;i++) {

            if(SocketComm(cmd,cmd.createByteBuffer(FBS9600S_SystemParam.REGCOUNT))) {

                for(int k = 0;k<battData.getItemCount();k++) {

                    BattData_RT rdData = battData.getItem(k);

                    if(rdData.FBSDeviceId /10000000 == 96) {

                        //9600设备

                        if(rdData.FBSDeviceId == dev_id) {

                            //System.out.println("$$$$$$$$$$$$$$$$$");

                            dev_ip = rdData.FBSDeviceIp;

                            BattData_RT[rdData.GroupIndexInFBSDevice%group_max] = rdData;

                            m_BattMonCount += rdData.MonCount;

                            S_thread_run_flag = true;

                            is_success_dev = true;

                        }

                    }

                }

            }	
            if(is_success_dev) {

                //System.out.println("识别成功"+dev_id+" at "+Com.getDateTimeFormat(new Date(), Com.DTF_YMDhms));

                if(m_BattMonCount > FBS9600S_ComBase.MonomerCountMax) {

                    m_BattMonCount = FBS9600S_ComBase.MonomerCountMax;

                }

                break;

            }

        }

		
    }

	
    @Override

    public void run() {

        int dev_addr = 1;                                //开始的汇集器地址

		
        if(is_success_dev) {

            FBS9600S_SocketClient_Thread_SQL.insertOrUpdateFBS9600StateByDev_id(mysql_pool,sysState);

        }

        while(S_thread_run_flag && is_success_dev) {

            try {

                FBS9600S_Cmd cmd = null;

                boolean readBattParamOk = false;

                cmd = new FBS9600S_Cmd(dev_addr,FBS9600S_ComBase.CMD_READ_MODBUS,FBS9600S_ComBase.CMD_SystemParam_Addr,FBS9600S_SystemParam.REGCOUNT);

                if(SocketComm(cmd,cmd.createByteBuffer(FBS9600S_SystemParam.REGCOUNT))) {                //读取成功参数

                    sleep(50);

                    //已读取到当前汇集器的参数

                    int readCount = (int)Math.ceil((double)nowParam.monCount/100);                        //读取次数(当前汇集器的单体数目超过100)

                    //System.err.println("第"+dev_addr+"#汇集器读取次数:"+readCount);

                    for(int i=0;i<readCount;i++) {

                        {

                            //读取单体电压

                            cmd = new FBS9600S_Cmd(dev_addr,FBS9600S_ComBase.CMD_READ_MODBUS,FBS9600S_ComBase.CMD_BattMonVolStart_Addr+i*FBS9600S_MonData.REGCOUNT,FBS9600S_MonData.REGCOUNT);

                            SocketComm(cmd,cmd.createByteBuffer(FBS9600S_MonData.REGCOUNT));

                            sleep(50);

                        }

                        {

                            //读取单体温度

                            cmd = new FBS9600S_Cmd(dev_addr,FBS9600S_ComBase.CMD_READ_MODBUS,FBS9600S_ComBase.CMD_BattMonTmpStart_Addr+i*FBS9600S_MonData.REGCOUNT,FBS9600S_MonData.REGCOUNT);

                            SocketComm(cmd,cmd.createByteBuffer(FBS9600S_MonData.REGCOUNT));

                            sleep(50);

                        }

                        {

                            //读取单体内阻

                            cmd = new FBS9600S_Cmd(dev_addr,FBS9600S_ComBase.CMD_READ_MODBUS,FBS9600S_ComBase.CMD_BattMonResStart_Addr+i*FBS9600S_MonData.REGCOUNT,FBS9600S_MonData.REGCOUNT);

                            SocketComm(cmd,cmd.createByteBuffer(FBS9600S_MonData.REGCOUNT));

                            sleep(50);

                        }

//                        {

//                            //读取单体均衡

//                            cmd = new FBS9600S_Cmd(dev_addr,FBS9600S_ComBase.CMD_READ_MODBUS,FBS9600S_ComBase.CMD_BattMonJhCurrStart_Addr+i*FBS9600S_MonData.REGCOUNT,FBS9600S_MonData.REGCOUNT);

//                            SocketComm(cmd,cmd.createByteBuffer(FBS9600S_MonData.REGCOUNT));

//                            sleep(50);

//                        }

                    }									
                    nowMonIndex += nowParam.monCount;

                    readBattParamOk = true;

                }				
                //读取汇集器的设备状态

                cmd = new FBS9600S_Cmd(dev_addr,FBS9600S_ComBase.CMD_READ_MODBUS,FBS9600S_ComBase.CMD_SystemState_Addr,FBS9600S_SystemState.REGCOUNT);

                SocketComm(cmd,cmd.createByteBuffer(FBS9600S_SystemState.REGCOUNT));

                sleep(50);

				
                if(readBattParamOk) {

                    //已读取成功过的汇集器跳过

                    dev_addr ++;

                }

                if(dev_addr >= FBS9600S_ComBase.ConcentratorMaxAdrr || (dev_addr>BattData_RT[0].BattGroupNum && nowMonIndex >= m_BattMonCount)) {

                    //System.out.println("重置汇集器编号。。。。。。。。。。。。。。。。。。。。。。。");

                    //当读取到最大的汇集器数量或者当前单体数量已读取完毕

                    dev_addr = 1;

                    nowMonIndex = 0;

                }

            } catch (Exception e) {

                e.printStackTrace();

            } finally {

				
            }

        }

        System.out.println("设备ID:"+dev_id+"  通讯结束");

        if(this.socket != null) {

            try {

                socket.close();

            } catch (IOException e) {

                //e.printStackTrace();

            }

        }

    }

	
    public boolean SocketComm(FBS9600S_Cmd m_CMD, ByteBuffer bf) 
    {

        boolean res_t = false;

        try {

            socket.setSoTimeout(3000);

            if(S_thread_run_flag) {

                InputStream in = socket.getInputStream();

                OutputStream out = socket.getOutputStream();

                //----------------- clear rx buff for tcp resend packet ----------------//

                byte[] rx_buf_t = new byte[1024];

		        
                int buf_clr_read_count = 0;

//                while(in.available() > 0) {

//                    //System.out.println("99999999999");

//                    in.read(rx_buf_t);

//                    if(buf_clr_read_count >= 10) {

//                        System.out.println(ComFn.bytesToHexString(rx_buf_t, rx_buf_t.length));

//                        S_thread_run_flag = false;

//                        System.err.println(this.getName()

//                                            + " dev_id: " + m_StatAndParam.dev_id 
//                                            + " socket rx_buff clear error......");

//                        res_t = false;

//                        return res_t;

//                    }

//                }

                //----------------------------------------------------------------------//

                //--------------------- socket write -----------------------------------//

                byte[] cipher_tx_t = null;

                cipher_tx_t = makeCommBuf(m_CMD, bf, false);

		        	
                //System.err.println("发送数据："+ComFn.bytesToHexString(cipher_tx_t, cipher_tx_t.length));

                //=====================================================================//

                Date d1 = new Date();

                int rx_read_time_out = 0; 
                out.write(cipher_tx_t);

                out.flush();

			    
                bytebuffer_for_socket_RX.order(ByteOrder.BIG_ENDIAN);

                bytebuffer_for_socket_RX.clear();

                while(true) {

                    if(in.available() > 0) { 
                        rx_read_time_out = 0; 
                        int rx_len_t = in.read(rx_buf_t);

                        if((bytebuffer_for_socket_RX.position()+rx_len_t) 
                                < (bytebuffer_for_socket_RX.capacity()-1)) {

                            bytebuffer_for_socket_RX.put(rx_buf_t, 0, rx_len_t);

                        }

                    } else { 
                        rx_read_time_out += 1;

                        if((bytebuffer_for_socket_RX.position()>=7) && (rx_read_time_out>20)){

                            res_t = true;

                            break;

                        }

		        		
                        if(rx_read_time_out > 220) { 
                            break; 
                        } 
                    } 
                    Thread.sleep(10); 
                }

		        
                bytebuffer_for_socket_RX.flip();

		        
                Date d2 = new Date();

                long comm_tms = (d2.getTime() - d1.getTime());

//                if(comm_tms < 200) {

//                    Thread.sleep(200 - comm_tms);

//                }

                /*

                System.out.println(this.getName() 
                                    + "  dev_id:" + m_StatAndParam.dev_id

                                    + "  cmd:" + cmd

                                    + "  d2-d1:" + (comm_tms)+"ms"

                                    + "  rx_len:" + bytebuffer_for_socket_RX.limit()

                                    //+ "  tx_count:" + m_StatAndParam.m_FBS_VCData.m_SysState.CommCount

                                    //+ "  rx_err_sum:" + m_StatAndParam.m_FBS_VCData.m_SysState.ErrCommCount

                                    //+ "  rx_err_count:" + rx_errcount_for_live_of_thread

                                    + Com.getNowTimeWithAt());

                */

                byte[] cipher_buf = new byte[bytebuffer_for_socket_RX.limit()];

                byte[] plain_buf = new byte[bytebuffer_for_socket_RX.limit()];

                bytebuffer_for_socket_RX.get(plain_buf);

                //System.out.println("接收数据："+ComFn.bytesToHexString(plain_buf, plain_buf.length));

				
                if((cipher_buf.length >= 7) && (true == getDataFromCommBuf(plain_buf,m_CMD))) {

		        	
                    rx_errcount_for_live_of_thread = 0;

                    res_t = true;

                } else {

                    res_t = false;

		        	
                    rx_errcount_for_live_of_thread++;

                    //m_StatAndParam.m_SysState.setErrCommCountInc(bytebuffer_for_socket_RX.limit());

                }

            } else {

                S_thread_run_flag = false;

                sysState.addErrCommCount();

            }

        } catch (IOException | InterruptedException e) {

            //e.printStackTrace();

            res_t = false;

            S_thread_run_flag = false;

        } finally {

            //System.out.println(m_CMD.data_addr+""+res_t+"===="+rx_errcount_for_live_of_thread+"$$$$"+S_thread_run_flag);

            if(res_t) {

                sysState.addCommCount();

            }else {

                sysState.addErrCommCount();

            }

            //若在通信的过程中出现连续5次通信异常关闭连接

            if(rx_errcount_for_live_of_thread >= 5){

                S_thread_run_flag = false;

            }

        }

        return res_t;

    }



    /**

     *     解析读取的数据

     * @param plain_buf

     * @param m_CMD

     * @return

     */

    private boolean getDataFromCommBuf(byte[] plain_buf, FBS9600S_Cmd m_CMD) {

        boolean isSuccess = false;

        ByteBuffer bf = ByteBuffer.allocate(plain_buf.length);

        bf.order(ByteOrder.BIG_ENDIAN);

        bf.put(plain_buf);

        bf.flip();

        FBS9600S_Cmd  cmd = new FBS9600S_Cmd();

        if(cmd.putByteBuffer(bf)) {

            if(FBS9600S_ComBase.CMD_READ_MODBUS == cmd.cmd) {

                //读取数据

                if(cmd.data_result == FBS9600S_SystemState.REGCOUNT*2) {

                    FBS9600S_SystemState sysstate = new FBS9600S_SystemState();

                    //读取设备状态信息

                    if(sysstate.putByteBuffer(bf)) {

                        isSuccess = true;

                        //System.err.println("读取设备状态成功"+cmd.dev_addr);

                        getBattGroupState(sysstate,cmd.dev_addr);						
                    }					
                }

				
                if(cmd.data_result == FBS9600S_SystemParam.REGCOUNT*2) {

                    dev_id = cmd.dev_id+960000000;

                    //System.err.println(dev_id);

                    //读取汇集器参数

                    if(nowParam.putByteBuffer(bf)) {

                        //System.out.println(nowParam.dev_addr+"##############"+mainConcen_addr);

                        if(nowParam.dev_addr == m_CMD.dev_addr) {

                            //System.err.println("读取汇集器参数成功");

                            sysParam = nowParam.clone();

                            isSuccess = true;

                        }

                    }

                }

				
                if(cmd.data_result == FBS9600S_MonData.REGCOUNT*2 && nowParam.dev_addr == cmd.dev_addr) {

                    int readCount = (int)Math.ceil((float)nowParam.monCount/100);            //读取次数

                    int start = 0,count = 0;

                    float wavecurr = 1;

                    int arr_index = 0;

                    //读取单体电压

                    if(m_CMD.data_addr >= FBS9600S_ComBase.CMD_BattMonVolStart_Addr && m_CMD.data_addr < FBS9600S_ComBase.CMD_BattMonVolEnd_Addr) {

                        arr_index = m_CMD.data_addr - FBS9600S_ComBase.CMD_BattMonVolStart_Addr;

                        int nowReadCount = arr_index/100+1;                    //当前读取次数

                        start = nowMonIndex + (nowReadCount -1)*100;

                        if(nowReadCount < readCount) {

                            count = 100;

                        }else {

                            count = nowParam.monCount%100==0?100:(nowParam.monCount%100);

                        }

                        if(monData.putByteBuffer(bf, FBS9600S_ComBase.DataType_MonVol, wavecurr)) {

                            getFBS9600SMonData(monData.monVol, FBS9600S_ComBase.DataType_MonVol, start,count,arr_index);

                            isSuccess = true;

                            //System.err.println("读取单体电压成功");

                        }

                    }

					
                    //读取单体温度

                    if(m_CMD.data_addr >= FBS9600S_ComBase.CMD_BattMonTmpStart_Addr && m_CMD.data_addr < FBS9600S_ComBase.CMD_BattMonTmpEnd_Addr) {

                        arr_index = m_CMD.data_addr - FBS9600S_ComBase.CMD_BattMonTmpStart_Addr;

                        int nowReadCount = arr_index/100+1;                    //当前读取次数

                        start = nowMonIndex + (nowReadCount -1)*100;

                        if(nowReadCount < readCount) {

                            count = 100;

                        }else {

                            count = nowParam.monCount%100==0?100:(nowParam.monCount%100);

                        }

                        //System.err.println("start"+start+"\tcount:"+count);

                        if(monData.putByteBuffer(bf, FBS9600S_ComBase.DataType_MonTmp, wavecurr)) {

                            getFBS9600SMonData(monData.monTmp, FBS9600S_ComBase.DataType_MonTmp,start, count,arr_index);

                            isSuccess = true;

                            //System.err.println("读取单体温度成功");

                        }

                    }

					
                    //读取单体内阻

                    if(m_CMD.data_addr >= FBS9600S_ComBase.CMD_BattMonResStart_Addr && m_CMD.data_addr < FBS9600S_ComBase.CMD_BattMonResEnd_Addr) {

                        //wavecurr = (sysState.resTestMethod == FBS9600S_ComBase.ResTestType_WaveReco)?sysState.avg_rippcurr:1;

                        arr_index = m_CMD.data_addr - FBS9600S_ComBase.CMD_BattMonResStart_Addr;

                        int nowReadCount = arr_index/100+1;                    //当前读取次数

                        start = nowMonIndex + (nowReadCount -1)*100;

                        if(nowReadCount < readCount) {

                            count = 100;

                        }else {

                            count = nowParam.monCount%100==0?100:(nowParam.monCount%100);

                        }

						
                        if(monData.putByteBuffer(bf, FBS9600S_ComBase.DataType_MonRes, wavecurr)) {

                            getFBS9600SMonData(monData.monRes, FBS9600S_ComBase.DataType_MonRes, start, count,arr_index);

                            isSuccess = true;

                            //System.err.println("读取单体内阻成功");

                        }

                    }

					
                    //读取单体均衡

                    if(m_CMD.data_addr >= FBS9600S_ComBase.CMD_BattMonJhCurrStart_Addr && m_CMD.data_addr < FBS9600S_ComBase.CMD_BattMonJhCurrEnd_Addr) {

                        arr_index = m_CMD.data_addr - FBS9600S_ComBase.CMD_BattMonJhCurrStart_Addr;

                        int nowReadCount = arr_index/100+1;                    //当前读取次数

                        start = nowMonIndex + (nowReadCount -1)*100;

                        if(nowReadCount < readCount) {

                            count = 100;

                        }else {

                            count = nowParam.monCount%100==0?100:(nowParam.monCount%100);

                        }

                        if(monData.putByteBuffer(bf, FBS9600S_ComBase.DataType_MonJHCurr, wavecurr)) {

                            getFBS9600SMonData(monData.monJHCurr, FBS9600S_ComBase.DataType_MonJHCurr, start, count,arr_index);

                            isSuccess = true;

                            //System.err.println("读取单体均衡成功");

                        }

                    }

                }

            }

        }

        return isSuccess;

    }

	
    //获取当前电池组的状态

    private void getBattGroupState(FBS9600S_SystemState sysState2, int dev_addr) {

		
        for(int n=0;n<FBS9600S_ComBase.BattGroupCountMax;n++) {

            //根据当前机房内电池组编号匹配当前主汇集器的状态(接入了组端电压和电流传感器的汇集器)

            if(BattData_RT[n] != null && BattData_RT[n].BattGroupNum == dev_addr) {

                //System.err.println(BattData_RT[n].BattGroupNum +"=="+ dev_addr+"更新电池组状态");

                sysState = sysState2.clone();

                BattData_RT[n].mTestData.setDevFBS9100S_WorkState(0, 
                        sysState2.batt_state+1,

                        sysState2.work_state);

    			
                //--------------------- 再读取端电压 -----------------------------------------//

                //--------------------- 如果软件版本大于35,在线电压和组端电压保留2位小数-------//

                //BattData_RT[n].mTestData.updateGroupTempFrom_FBSDev((float)(vc_data.batttemp[n]));

                BattData_RT[n].mTestData.updateGroupVolFrom_FBSDev((float)(sysState2.group_vol));

                //---------------------------------------------------------------------------//

                //--------------------- 接着读取电流 -----------------------------------------//

                BattData_RT[n].mTestData.updateCurrFrom_FBSDev((float) sysState2.group_curr*(sysState2.batt_state==1?(-1):1));

                //---------------------------------------------------------------------------//

                //--------------------- 然后读取内阻测试状态  ---------------------------------//

                BattData_RT[n].mTestData.batt_res_test_state = sysState2.dev_state;

                BattData_RT[n].mTestData.batt_res_test_cnt = sysState2.resTestCount;

                //--------------------- DCDC节能模块状态数据 ---------------------------------//

                //m_RTData[n].m_DCDC_Data.copyData(m_StatAndParam.m_al_DCDC_Data[0]);

                //---------------------------------------------------------------------------//

                //--------------------- 先更新单体数据,再更新电池状态数据 ----------------------//

                BattData_RT[n].updata_BattRtData_To_RamDb();

                BattData_RT[n].updata_BattRtSate_To_RamDb();

                //---------------------------------------------------------------------------//

				
                FBS9600S_SocketClient_Thread_SQL.UpdateFBS9600StateByDev_id(mysql_pool,sysState);

                break;

            }

        }

		
    }



    //设置单体数据

    public void getFBS9600SMonData(float[] monData,int dataType,int start,int count,int arr_index) {

        int mon_index = 0;

        int mon_count = 0;

        for(int n=0;n<FBS9600S_ComBase.BattGroupCountMax;n++) {

            if(BattData_RT[n] != null) {

                for(int k =0;k<BattData_RT[n].al_MonVol.size();k++) {

                    if((mon_index+BattData_RT[n].MonCount)<start) {

                        mon_index += BattData_RT[n].MonCount;

                        break;

                    }

                    if(mon_index >= FBS9100_ComBase.MonomerCountMax || mon_count >= count) {

                        break;

                    }

                    if(mon_index >= start && mon_count < count && mon_index<(start+count)) {							
                        if(FBS9600S_ComBase.DataType_MonVol == dataType) {

                            //BattData_RT[n].al_MonVol.get(k).monVol = (float)Math.random()+100+start+mon_count++;

                            BattData_RT[n].al_MonVol.get(k).monVol = monData[mon_count++];

                        }else if(FBS9600S_ComBase.DataType_MonTmp == dataType) {

                            //BattData_RT[n].al_MonVol.get(k).monTmp = (float)Math.random()+400+start+mon_count++;

                            BattData_RT[n].al_MonVol.get(k).monTmp = monData[mon_count++];

                            //System.out.print(mon_index+"***"+n+"-"+k+"\t"+monData[mon_count-1]+"\t==="+BattData_RT[n].al_MonVol.get(k).monTmp);

                        }else if(FBS9600S_ComBase.DataType_MonRes == dataType) {

                            //BattData_RT[n].al_MonVol.get(k).monRes = (float)Math.random()+800+start+mon_count++;

                            BattData_RT[n].al_MonVol.get(k).monRes = monData[mon_count++];

                        }else if(FBS9600S_ComBase.DataType_MonJHCurr == dataType) {

                            //BattData_RT[n].al_MonVol.get(k).monJHcurr = start+mon_count++;

                            BattData_RT[n].al_MonVol.get(k).monJHcurr = monData[mon_count++];

                        }

                    }

                    mon_index++;

                }

				
//                System.out.println();

//                if(FBS9600S_ComBase.DataType_MonTmp == dataType) {

//                    for(int i=0;i<BattData_RT[n].al_MonVol.size();i++) {

//                        System.err.print(i+":"+BattData_RT[n].al_MonVol.get(i).monTmp+"\t");

//                    }

//                }

//                System.out.println();

            }			
        }

    }



    /*

     *    构造发送数据

     */

    private byte[] makeCommBuf(FBS9600S_Cmd m_CMD, ByteBuffer bf, boolean aes_en) {

        ByteBuffer bbf = FBS9600S_ComBuf.makeFbs9600CommBuf(m_CMD, bf, aes_en);

        byte byte_rest[] = new byte[bbf.limit()];

        bbf.get(byte_rest);

        return byte_rest;

    }

	
}


 BattMonitor_FBS9600SMore/src/com/dev_fbs9600s/data/FBS9600S_SocketClient_Thread_SQL.java

@@ -37,6 +37,64 @@
        }

    }

    

	
    /**

     * 更新9600系统状态

     * @param pool

     * @param devdata

     */

    public static void insertOrUpdateFBS9600StateByDev_id(MysqlConnPool pool,FBS9600S_SystemState state) {

        String sql_str_base = Sql_Mysql.FBS9100State_Table +

                  " SET dev_id = '"+ state.dev_id+"', "

                + " dev_ip='"+ state.dev_ip+"',"  
                + " record_datetime='"+Com.getDateTimeFormat(new Date(), Com.DTF_YMDhms)+"',"

                + " dev_workstate = '"+state.work_state+"',"

                + " dev_captest_groupvol='"+state.group_vol+"',"

                + " dev_captest_curr='"+state.group_curr+"',"

                + " dev_commcount='"+state.CommCount+"',"

                + " dev_errcommcount='"+state.ErrCommCount+"' ";

		 			
        Sql_Mysql sql = new Sql_Mysql(pool.getConn());

        String sql_str_replace = " REPLACE INTO " + sql_str_base;

        try {

            sql.sqlMysqlExecute(sql_str_replace);

        } catch (SQLException e) {

            //System.err.println("执行 insertOrUpdateFBS9600StateByDev_id 异常    at"+Com.getDateTimeFormat(new Date(), Com.DTF_YMDhms));

            e.printStackTrace();

        } finally{

            sql.close_con();

        }

    }

	
    /**

     * 更新9600系统状态

     * @param pool

     * @param devdata

     */

    public static void UpdateFBS9600StateByDev_id(MysqlConnPool pool,FBS9600S_SystemState state) {

        String sql_str_base = Sql_Mysql.FBS9100State_Table +

                  " SET dev_id = '"+ state.dev_id+"', "

                + " dev_ip='"+ state.dev_ip+"',"  
                + " record_datetime='"+Com.getDateTimeFormat(new Date(), Com.DTF_YMDhms)+"',"

                + " dev_workstate = '"+state.work_state+"',"

                + " dev_captest_groupvol='"+state.group_vol+"',"

                + " dev_captest_curr='"+state.group_curr+"',"

                + " dev_commcount='"+state.CommCount+"',"

                + " dev_errcommcount='"+state.ErrCommCount+"' "

                + " WHERE dev_id = " + state.dev_id;

		 			
        Sql_Mysql sql = new Sql_Mysql(pool.getConn());

        String sql_str_replace = " Update " + sql_str_base;

        try {

            sql.sqlMysqlExecute(sql_str_replace);

        } catch (SQLException e) {

            //System.err.println("执行 insertOrUpdateFBS9600StateByDev_id 异常    at"+Com.getDateTimeFormat(new Date(), Com.DTF_YMDhms));

            e.printStackTrace();

        } finally{

            sql.close_con();

        }

    }

	
    //更新当前线程的启动时间以及软件程序的版本号

    public static boolean updateServerStartInfTo_RamDB_Table(MysqlConnPool conn_pool, double ver)

    {


 BattMonitor_FBS9600SMore/src/com/dev_fbs9600s/data/FBS9600S_SystemState.java

@@ -9,7 +9,7 @@
    public static final int REGCOUNT = 26;        //寄存器数量

    

    public int dev_id;

    public int dev_ip;

    public String dev_ip;

    

    public Date record_datetime;                //记录时间

    public int work_state;                        //ϵͳ״̬

@@ -41,6 +41,18 @@
    public int backup15;

    public int backup16;

    

    public int        CommCount = 0;                        //通信计数

    public int        ErrCommCount = 0;                    //错误计数

	
	
    public FBS9600S_SystemState() {

		
    }

	
    public FBS9600S_SystemState(int dev_id,String dev_ip) {

        this.dev_ip = dev_ip;

        this.dev_id = dev_id;

    }

    

    public FBS9600S_SystemState clone() {

        FBS9600S_SystemState syState  = new FBS9600S_SystemState();

@@ -76,9 +88,26 @@
        syState.backup14 = this.backup14;

        syState.backup15 = this.backup15;

        syState.backup16 = this.backup16;

		
        syState.ErrCommCount = this.ErrCommCount;

        syState.CommCount = this.CommCount;

        return syState;

    }

    

    public void addErrCommCount() {

        this.ErrCommCount ++;

        if(this.ErrCommCount > 99999990) {

            this.ErrCommCount = 1;

        }

    }

	
    public void addCommCount() {

        this.CommCount++;

        if(this.CommCount > 999999990) {

            this.CommCount = 1;

        }

    }

	
    public boolean putByteBuffer(ByteBuffer bf) {

        if(bf.limit() < REGCOUNT*2) {

            return false;