package com.battdata_rt;
|
import java.sql.ResultSet;
|
import java.sql.SQLException;
|
import java.util.ArrayList;
|
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
|
import com.base.AppConfig;
|
import com.base.ComBase;
|
import com.dec.fbs9100.AppParam;
|
import com.dec.fbs9100.FBS9100_ComBase;
|
import com.dec.fbs9100.FBS9100_SysState;
|
import com.dec.fbs9100.MysqlConnPool;
|
import com.dec.fbs9100.Sql_Mysql;
|
|
public class BattData_RT {
|
public static final int DEF_CommTimeOutMax = 7200;
|
private MysqlConnPool m_Conn_Pool;
|
|
private boolean MonDataFromCInterfaceOk = false;
|
|
private boolean MonDataIsUseForIdce8200 = false;
|
private boolean mIDCE8200_ConState = false;
|
private int mIDCE8200CommTimeout = 0;
|
|
public int StationId;
|
public String StationName;
|
public byte[] StationIp = new byte[4];
|
public int BattGroupId = 0;
|
public int BattCurrDeviceId = 0;
|
public int[] BattCurrValueId = new int[16];
|
|
public int FBSDeviceId = 0;
|
public String FBSDeviceIp = " ";
|
public String FBSDeviceName = " ";
|
private String FBSRegCode = " ";
|
public int GroupIndexInFBSDevice = 1;
|
public String FBSDeviceIp_WG = " ";
|
public String FBSDeviceIp_YM = " ";
|
|
public int BattGroupNum;
|
public int BattState;
|
public int MonCount = 1;
|
public float MonStdVol;
|
public float MonStdCap;
|
|
private boolean StoreBattRes_DataEn = false;
|
private boolean StoreDataBusy = false;
|
private boolean MysqlDataTable_Exist = false;
|
public boolean MysqlDataResInfTable_Exist = false;
|
public boolean MysqlRecordInf_Exist = false;
|
|
public InsertDataToMysql_Task mSqlTask = null;
|
|
public ArrayList<MonVolData> al_MonVol = new ArrayList<MonVolData>();
|
public ArrayList<MonVolData> al_MonVol_RtOld = new ArrayList<MonVolData>();
|
public ArrayList<MonVolData> al_MonVol_History = new ArrayList<MonVolData>();
|
public ArrayList<ArrayList<Integer>> al_MonVol_C_Id = new ArrayList<ArrayList<Integer>>();
|
|
public BattStatData mTestData;
|
|
private int mCommTimeCoutCount = 0;
|
public int mMaxMonNum = 0;
|
public float mMaxMonVol = 0;
|
public int mMinMonNum = 0;
|
public float mMinMonVol = 0;
|
|
private AppParam mAppParam = new AppParam();
|
|
private float mBattFloatCurrLevel = (float) 15.0;
|
private float mBattFloatVolLevel = (float) (MonStdVol*MonCount*1.125);
|
|
private int mTestTimeLongMin = 1*60;
|
public int mSaveDataTimeInterval = 10;
|
private float mDataHistoryNewLevel = (float) 0.01;
|
private int mTestDataRecordCountMax = 10000;
|
|
private int commPort = 102;
|
|
Logger logger = null;
|
public String icdName = " "; //icd文件名称
|
/*********************************************************************************/
|
/*********************************************************************************/
|
public BattData_RT(AppConfig cfg, AppParam param, MysqlConnPool pool)
|
{
|
logger = LogManager.getLogger(this.getClass());
|
|
mTestData = new BattStatData(cfg.getSourceBattDataType(), cfg.getSybSrvCurrChargeDirPos());
|
|
mAppParam.copyAppParam(param);
|
//System.out.println("mAppParam.getTestTimeLongMinimum(AppParam.AppParam_Discharge):"+mAppParam.getTestTimeLongMinimum(AppParam.AppParam_Discharge));
|
m_Conn_Pool = pool;
|
if(null != m_Conn_Pool)
|
{
|
mSqlTask = new InsertDataToMysql_Task();
|
}
|
}
|
/*********************************************************************************/
|
public void updata_BattRtSate_To_RamDb() {
|
BattData_RT_SQL.updateBattState_RT_RamDB_Table(m_Conn_Pool, this);
|
}
|
/*********************************************************************************/
|
public void updata_BattRtData_To_RamDb() {
|
BattData_RT_SQL.updateBattData_RT_RamDB_Table(m_Conn_Pool, this);
|
}
|
/*********************************************************************************/
|
public void updata_BattRtAlARM_To_RamDb() {
|
BattData_RT_SQL.updateBattAlarm_RT_RamDB_Table(m_Conn_Pool, this);
|
}
|
/*********************************************************************************/
|
public BattData_RT updata_SetIp() {
|
return BattData_RT_SQL.selectRT_BttInf_Table(m_Conn_Pool, this);
|
}
|
/*********************************************************************************/
|
|
public void make_al_MonVol_C_Id()
|
{
|
al_MonVol_C_Id.clear();
|
ArrayList<Integer> tmp_al_id = null;
|
|
int start_index = 0;
|
for(int m=0; m<al_MonVol.size(); m++)
|
{
|
int tmp_id = al_MonVol.get(m).cInterfaceId;
|
|
if((start_index < 1) || (start_index > 24)
|
|| ((tmp_id-2) > tmp_al_id.get(start_index - 1))
|
|| ((tmp_id+2) < tmp_al_id.get(start_index - 1)))
|
{
|
start_index = 0;
|
tmp_al_id = new ArrayList<Integer>();
|
al_MonVol_C_Id.add(tmp_al_id);
|
}
|
|
tmp_al_id.add(tmp_id);
|
start_index++;
|
}
|
}
|
|
public void make_al_MonVol_Auto_C_Id()
|
{
|
al_MonVol_C_Id.clear();
|
ArrayList<Integer> tmp_al_id = null;
|
|
tmp_al_id = new ArrayList<Integer>();
|
for(int m=0; m<al_MonVol.size(); m++)
|
{
|
int tmp_id = al_MonVol.get(m).cInterfaceId;
|
tmp_al_id.add(tmp_id);
|
}
|
|
al_MonVol_C_Id.add(tmp_al_id);
|
}
|
|
public void setStoreBattRes_DataEnStat(boolean stat)
|
{
|
StoreBattRes_DataEn = stat;
|
}
|
public boolean getStoreBattRes_DataEnStat()
|
{
|
return StoreBattRes_DataEn;
|
}
|
|
public void setMonitorParam(int test_type)
|
{
|
float det_vol = MonStdVol / 2;
|
if(det_vol < 1)
|
det_vol = 1;
|
|
if(BattStatData.BATTSTATE_DISCHARGE == test_type) {
|
mTestTimeLongMin = mAppParam.getTestTimeLongMinimum(AppParam.AppParam_Discharge);
|
mSaveDataTimeInterval = mAppParam.getSaveDataTimeInterval(AppParam.AppParam_Discharge);
|
mDataHistoryNewLevel = det_vol * mAppParam.getMonVolChangeLevel(AppParam.AppParam_Discharge);
|
mTestDataRecordCountMax = mAppParam.getTestDataRecordCountMax(AppParam.AppParam_Discharge);
|
} else {
|
mTestTimeLongMin = mAppParam.getTestTimeLongMinimum(AppParam.AppParam_Charge);
|
mSaveDataTimeInterval = mAppParam.getSaveDataTimeInterval(AppParam.AppParam_Charge);
|
mDataHistoryNewLevel = det_vol * mAppParam.getMonVolChangeLevel(AppParam.AppParam_Charge);
|
mTestDataRecordCountMax = mAppParam.getTestDataRecordCountMax(AppParam.AppParam_Charge);
|
}
|
}
|
|
public void updateMonCnt(int new_mon_cnt)
|
{
|
if((new_mon_cnt>0) && (new_mon_cnt<FBS9100_ComBase.MonomerCountMax)) {
|
int mon_cnt = this.al_MonVol.size();
|
if(new_mon_cnt > mon_cnt) {
|
while(new_mon_cnt > this.al_MonVol.size()) {
|
MonVolData data = new MonVolData(0, 0, this.BattGroupId*1000 + this.al_MonVol.size()+1);
|
this.al_MonVol.add(data);
|
this.al_MonVol_RtOld.add(data.clone());
|
|
/**
|
* 2022-07-05 @lijun this.al_MonVol_RtOld添加默认值
|
*/
|
setMonVol_RtOldDefaultVal();
|
this.al_MonVol_History.add(data.clone());
|
}
|
//----------- 增加的时候最后设置单体数量 ----------------
|
this.MonCount = new_mon_cnt;
|
|
} else if(new_mon_cnt < mon_cnt) {
|
//----------- 减少的时候最先设置单体数量 ----------------
|
this.MonCount = new_mon_cnt;
|
|
while(new_mon_cnt < this.al_MonVol.size()) {
|
this.al_MonVol.remove(this.al_MonVol.size()-1);
|
this.al_MonVol_RtOld.remove(this.al_MonVol_RtOld.size()-1);
|
this.al_MonVol_History.remove(this.al_MonVol_History.size()-1);
|
}
|
}
|
}
|
}
|
|
public void setBattFloatVolCurrLevel(float vol_lev, float curr_level)
|
{
|
mBattFloatVolLevel = vol_lev;
|
mBattFloatCurrLevel = curr_level;
|
}
|
|
public float getBattFloatVolLev()
|
{
|
return mBattFloatVolLevel;
|
}
|
public float getBattFloatCurrLev()
|
{
|
return mBattFloatCurrLevel;
|
}
|
public String getDevRegCode()
|
{
|
return FBSRegCode;
|
}
|
public void setDevRegCode(String reg_code)
|
{
|
FBSRegCode = reg_code;
|
}
|
|
public boolean isMonDataFromCInterfaceOk()
|
{
|
return MonDataFromCInterfaceOk;
|
}
|
public void setMonDataFromCInterfaceOk(boolean stat)
|
{
|
MonDataFromCInterfaceOk = stat;
|
}
|
|
public boolean isMonDataUseForIdce8200()
|
{
|
return MonDataIsUseForIdce8200;
|
}
|
public void setMonDataUseForIdce8200(boolean stat)
|
{
|
MonDataIsUseForIdce8200 = stat;
|
}
|
|
/********************************************************************************/
|
public boolean checkIfIdce8200ComMTimeout()
|
{
|
boolean time_ount = false;
|
if(mIDCE8200CommTimeout >= 60)
|
{
|
time_ount = true;
|
mIDCE8200_ConState = false;
|
setMonDataUseForIdce8200(false);
|
}
|
if(mIDCE8200CommTimeout < 1000)
|
mIDCE8200CommTimeout++;
|
|
return time_ount;
|
}
|
public float MonStdVol() {
|
return MonStdVol;
|
}
|
public float MonStdCap() {
|
return MonStdCap;
|
}
|
public boolean getIdce8200ComState()
|
{
|
return mIDCE8200_ConState;
|
}
|
|
public void updateMonVolFromIDCE8200(int mon_index, float vol)
|
{
|
mIDCE8200_ConState = true;
|
mIDCE8200CommTimeout = 0;
|
setMonDataUseForIdce8200(true);
|
|
al_MonVol.get(mon_index).monVol = vol;
|
}
|
|
public void updateMonVolFromSQL_SERVER()
|
{
|
if(true == isMonDataFromCInterfaceOk())
|
{
|
return;
|
}
|
|
float sumvol = 0;
|
for(int bt_index=0; bt_index<al_MonVol.size(); bt_index++)
|
{
|
if(false == isMonDataUseForIdce8200())
|
{
|
al_MonVol.get(bt_index).monVol = al_MonVol.get(bt_index).monVol_TMP;
|
}
|
sumvol += al_MonVol.get(bt_index).monVol;
|
}
|
mTestData.groupVol = sumvol;
|
}
|
|
public void updateMonVolFrom_C_Interface(int mon_c_id, float mon_vol)
|
{
|
float sumvol = 0;
|
for(int var=0; var<al_MonVol.size(); var++)
|
{
|
MonVolData mvol = al_MonVol.get(var);
|
if(mon_c_id == mvol.cInterfaceId)
|
{
|
if(false == isMonDataUseForIdce8200())
|
{
|
mvol.monVol = mon_vol;
|
}
|
|
if((mon_vol > 0.1) && (false == isMonDataFromCInterfaceOk()))
|
{
|
setMonDataFromCInterfaceOk(true);
|
}
|
}
|
|
sumvol += al_MonVol.get(var).monVol;
|
}
|
mTestData.groupVol = sumvol;
|
}
|
/********************************************************************************/
|
|
public int getBattCount()
|
{
|
return MonCount;
|
}
|
public byte getBattState()
|
{
|
return mTestData.battState;
|
}
|
public byte getBattTestType()
|
{
|
return mTestData.battTestState;
|
}
|
public float getOnlineVol()
|
{
|
return mTestData.onlineVol;
|
}
|
public float getGroupVol()
|
{
|
return mTestData.groupVol;
|
}
|
public float getGroupTmp()
|
{
|
return mTestData.groupTmp;
|
}
|
public float getTestCurr()
|
{
|
return mTestData.testCurr;
|
}
|
public float getTestCap()
|
{
|
return mTestData.testCap;
|
}
|
public long getTestStartTime()
|
{
|
return mTestData.startTestTime.getTime();
|
}
|
public long getTestRecordTime()
|
{
|
return mTestData.recordTime.getTime();
|
}
|
public int getTestTimeLong()
|
{
|
return mTestData.testTimeLong;
|
}
|
public float getBattRealCap()
|
{
|
return mTestData.battRealCap;
|
}
|
public float getBattRestCap()
|
{
|
return mTestData.battRestCap;
|
}
|
public int getBattRestTime()
|
{
|
return mTestData.battRestTime;
|
}
|
public float getGroupCurr() {
|
return mTestData.group_curr;
|
}
|
|
/**
|
* ��������������������������������������������������������������
|
* @param al_vol
|
*/
|
public void makeMaxMinMonVol(ArrayList<MonVolData> al_vol)
|
{
|
if(null != al_vol)
|
{
|
float maxvol = -80000;
|
float minvol = 80000;
|
for(int n=0; n<al_vol.size(); n++)
|
{
|
if(maxvol < al_vol.get(n).monVol)
|
{
|
maxvol = al_vol.get(n).monVol;
|
mMaxMonNum = n+1;
|
}
|
if(minvol > al_vol.get(n).monVol)
|
{
|
minvol = al_vol.get(n).monVol;
|
mMinMonNum = n+1;
|
}
|
}
|
mMaxMonVol = maxvol;
|
mMinMonVol = minvol;
|
}
|
}
|
|
|
public float getMaxMonVol()
|
{
|
float maxvol = -80000;
|
for(int n=0; n<al_MonVol.size(); n++)
|
{
|
if(maxvol < al_MonVol.get(n).monVol)
|
{
|
maxvol = al_MonVol.get(n).monVol;
|
mMaxMonNum = n+1;
|
}
|
}
|
return maxvol;
|
}
|
public float getMinMonVol()
|
{
|
float minvol = 80000;
|
for(int n=0; n<al_MonVol.size(); n++)
|
{
|
if(minvol > al_MonVol.get(n).monVol)
|
{
|
minvol = al_MonVol.get(n).monVol;
|
mMinMonNum = n+1;
|
}
|
}
|
return minvol;
|
}
|
public float getGroupVolFromMonVol()
|
{
|
float gvol = 0;
|
for(int n=0; n<al_MonVol.size(); n++)
|
{
|
gvol += al_MonVol.get(n).monVol;
|
}
|
return gvol;
|
}
|
//------------------------------------------------------------------------------------//
|
public void makeDataClearByCommTimeOut() {
|
if(this.mCommTimeCoutCount < (DEF_CommTimeOutMax+100)) {
|
this.mCommTimeCoutCount += 1;
|
}
|
if(this.mCommTimeCoutCount >= DEF_CommTimeOutMax) {
|
mTestData.TestCurr_RT = 0;
|
mTestData.testCurr = 0;
|
}
|
}
|
public void makeDataResetByCommTimeOut() {
|
this.mCommTimeCoutCount = 0;
|
}
|
//------------------------------------------------------------------------------------//
|
private boolean make_al_MonVol_History()
|
{
|
boolean data_new = false;
|
for(int n=0; n<al_MonVol_History.size(); n++)
|
{
|
float tmp_dt = al_MonVol.get(n).monVol;
|
if(Math.abs((al_MonVol_History.get(n).monVol - tmp_dt)) > mDataHistoryNewLevel)
|
{
|
al_MonVol_History.get(n).data_new = true;
|
al_MonVol_History.get(n).monVol = tmp_dt;
|
data_new = true;
|
}
|
}
|
|
return data_new;
|
}
|
public float get_al_MonVol_History(int index)
|
{
|
float vol = 0;
|
if((index>=0) && (index<al_MonVol_History.size()))
|
{
|
vol = al_MonVol_History.get(index).monVol;
|
}
|
return vol;
|
}
|
public boolean is_al_MonVol_History_New(int index)
|
{
|
boolean isnew = false;
|
if((index>=0) && (index<al_MonVol_History.size()))
|
{
|
isnew = al_MonVol_History.get(index).data_new;
|
}
|
return isnew;
|
}
|
private void clear_al_MonVol_History_New()
|
{
|
for(int n=0; n<al_MonVol_History.size(); n++)
|
al_MonVol_History.get(n).data_new = false;
|
}
|
private void set_al_MonVol_History_New()
|
{
|
for(int n=0; n<al_MonVol_History.size(); n++)
|
{
|
//if(al_MonVol_History.get(n).monVol != al_MonVol.get(n).monVol)
|
{
|
al_MonVol_History.get(n).data_new = true;
|
al_MonVol_History.get(n).monVol = al_MonVol.get(n).monVol;
|
}
|
}
|
}
|
//------------------------------------------------------------------------------------//
|
private void calBattRestCap(double b_curr, double b_testcap)
|
{
|
double curr = Math.abs(b_curr);
|
double testcap = Math.abs(b_testcap);
|
int HourRate = ComBase.GetHourRate(MonStdCap, curr);
|
|
mTestData.battRestCap = (float) Math.abs(ComBase.GetMonomerCap(MonStdCap,
|
HourRate,
|
testcap,
|
getMaxMonVol(),
|
getMinMonVol(),
|
MonStdVol,
|
ComBase.CapType_Rest));
|
mTestData.battRestTime = ComBase.GetRestTimeSecond(mTestData.battRestCap, curr);
|
mTestData.battRealCap = (float) (mTestData.battRestCap + testcap * ComBase.N_TO_10H(HourRate));
|
}
|
//==============================================================//
|
//==============================================================//
|
//����al_MonVol����������������������0.001
|
public boolean checkIfHaveZeroMonVol()
|
{
|
boolean have_zero_vol = false;
|
|
for(int n=0; n<al_MonVol.size(); n++)
|
{
|
if(n >= 10000)
|
break;
|
|
if(al_MonVol.get(n).monVol <= 0.001)
|
{
|
have_zero_vol = true;
|
break;
|
}
|
}
|
|
return have_zero_vol;
|
}
|
|
private void initTestData(byte test_type)
|
{
|
int count = 1;
|
if(BattStatData.BATTSTATE_FLOAT != test_type)
|
{
|
Sql_Mysql sql = new Sql_Mysql(m_Conn_Pool);
|
count = sql.getBattTestRecordCountNew(BattGroupId, Sql_Mysql.BattTestDataInf_Table);
|
sql.close_con();
|
}
|
|
if(count <= 0)
|
return;
|
|
setMonitorParam(test_type);
|
mTestData.init(mTestData.getDevFBS9100S_WorkState(), test_type, count);
|
|
MysqlDataTable_Exist = false;
|
MysqlDataResInfTable_Exist = false;
|
MysqlRecordInf_Exist = false;
|
}
|
|
public boolean checkIfDataNeedStore()
|
{
|
boolean store_state = false;
|
/***********************************************************************/
|
if(false == getStoreDataBusyTag())
|
{
|
float tmp_curr = mTestData.TestCurr_RT;
|
|
if((Math.abs(tmp_curr) < mBattFloatCurrLevel)
|
&& (FBS9100_SysState.IEC61850_SYS_STATE_DISCHARGING != mTestData.getDevFBS9100S_WorkState()))
|
{
|
if(BattStatData.BATTSTATE_FLOAT != mTestData.battTestState)
|
{
|
mTestData.battTestState = BattStatData.BATTSTATE_FLOAT;
|
mTestData.battState = BattStatData.BATTSTATE_FLOAT;
|
store_state = true;
|
}
|
}
|
|
if(false == store_state)
|
{
|
if(tmp_curr >= (mBattFloatCurrLevel+2))
|
{
|
if(BattStatData.BATTSTATE_DISCHARGE == mTestData.battTestState)
|
{
|
mTestData.battTestState = BattStatData.BATTSTATE_FLOAT;
|
mTestData.battState = BattStatData.BATTSTATE_FLOAT;
|
store_state = true;
|
}
|
else if(BattStatData.BATTSTATE_FLOAT == mTestData.battTestState)
|
{
|
initTestData(BattStatData.BATTSTATE_CHARGE);
|
}
|
}
|
else if(tmp_curr <= ((mBattFloatCurrLevel+2)*(-1)))
|
{
|
if(BattStatData.BATTSTATE_CHARGE == mTestData.battTestState)
|
{
|
mTestData.battTestState = BattStatData.BATTSTATE_FLOAT;
|
mTestData.battState = BattStatData.BATTSTATE_FLOAT;
|
store_state = true;
|
}
|
else if(BattStatData.BATTSTATE_FLOAT == mTestData.battTestState)
|
{
|
initTestData(BattStatData.BATTSTATE_DISCHARGE);
|
}
|
} else {//edit by mxpopstar @2020.08.21
|
if(BattStatData.BATTSTATE_FLOAT == mTestData.battTestState) {
|
if(FBS9100_SysState.IEC61850_SYS_STATE_DISCHARGING == mTestData.getDevFBS9100S_WorkState()) {
|
initTestData(BattStatData.BATTSTATE_DISCHARGE);
|
//printBattRtDataDebugInf_FBS9100S(6);
|
} /*else if(FBS9100_SysState.IEC61850_SYS_STATE_CHARGING == mTestData.getDevFBS9100S_WorkState()) {
|
initTestData(BattStatData.BATTSTATE_CHARGE);
|
//printBattRtDataDebugInf_FBS9100S(7);
|
}*/
|
}
|
}
|
}
|
|
if(false == store_state)
|
{
|
mTestData.testCurr = tmp_curr;
|
}
|
}
|
|
if((BattStatData.BATTSTATE_DISCHARGE == mTestData.battTestState)
|
|| (BattStatData.BATTSTATE_CHARGE == mTestData.battTestState))
|
{
|
mTestData.calTestCap(1);
|
calBattRestCap(mTestData.testCurr, mTestData.testCap);
|
|
boolean dt_new = make_al_MonVol_History();
|
if(mTestData.recordNum < mTestDataRecordCountMax)
|
{
|
if((true == dt_new) || ((mTestData.dataCalCount % mSaveDataTimeInterval)==0))
|
{
|
set_al_MonVol_History_New();
|
store_state = true;
|
}
|
}
|
}
|
else
|
{
|
if(mTestData.groupVol > mBattFloatVolLevel) {
|
mTestData.battState = BattStatData.BATTSTATE_JUNCHARGE;
|
} else {
|
mTestData.battState = BattStatData.BATTSTATE_FLOAT;
|
}
|
}
|
|
/************************** edit by mxpopstar @ 2020-08-30 ****************************/
|
if(true == store_state) {
|
mTestData.checkAndSetLoaderType();
|
}
|
/*************************************************************************************/
|
|
if(true == getStoreDataBusyTag())
|
store_state = false;
|
else
|
{
|
if(true == store_state)
|
setStoreDataBusyTag();
|
}
|
|
/***********************************************************************/
|
return store_state;
|
}
|
|
public void clearStoreDataBusyTag()
|
{
|
StoreDataBusy = false;
|
}
|
private boolean getStoreDataBusyTag()
|
{
|
return StoreDataBusy;
|
}
|
private void setStoreDataBusyTag()
|
{
|
StoreDataBusy = true;
|
}
|
|
/**
|
* 2022-07-05 新增给al_MonVol_RtOld设置默认值
|
* @lijun
|
*/
|
public void setMonVol_RtOldDefaultVal() {
|
if(null != al_MonVol_RtOld) {
|
for(int n=0;n<al_MonVol_RtOld.size();n++) {
|
al_MonVol_RtOld.get(n).monVol = -1;
|
al_MonVol_RtOld.get(n).monTmp = -1;
|
al_MonVol_RtOld.get(n).monRes = -1;
|
al_MonVol_RtOld.get(n).monSer = -1;
|
al_MonVol_RtOld.get(n).connRes = -1;
|
al_MonVol_RtOld.get(n).mon_JH_curr = -1;
|
}
|
}
|
}
|
|
public class InsertDataToMysql_Task implements Runnable {
|
|
private void inserTestDataToDB(Sql_Mysql sql_v, int test_stoptype_t) {
|
boolean result = true;
|
for(int c=0; c<3; c++) {
|
try {
|
sql_v.mysql_con.setAutoCommit(false);
|
//------------------------------------------------------------//
|
String sql_str = BattData_RT_SQL.getInsertBattTestDataStr(BattData_RT.this);
|
sql_v.sqlMysqlExecute(sql_str);
|
//------------------------------------------------------------//
|
ArrayList<String> al_sql_str = BattData_RT_SQL.getInsertOrUpdateBattTestDataStopStr(BattData_RT.this);
|
for(int n=0; n<al_sql_str.size(); n++)
|
{
|
sql_v.sqlMysqlExecute(al_sql_str.get(n));
|
}
|
//------------------------------------------------------------//
|
if(1 == BattData_RT.this.mTestData.testRecordCount) {
|
MysqlRecordInf_Exist = true;
|
}
|
//------------------------------------------------------------//
|
ResultSet rest_t = sql_v.sqlMysqlQuery("SELECT COUNT(*) FROM " + Sql_Mysql.BattTestDataInf_Table
|
+ " WHERE BattGroupId=" + BattData_RT.this.BattGroupId
|
+ " AND test_record_count=" + BattData_RT.this.mTestData.testRecordCount);
|
if(rest_t.next()) {
|
if(rest_t.getInt(1) < 1) {
|
MysqlRecordInf_Exist = false;
|
}
|
}
|
//------------------------------------------------------------//
|
/**
|
* 2021-08-17 edit @lijun 注释为原方法，下面的方法为了在记录历史放电放电数据时记录一笔当前电池组的内阻数据
|
*/
|
//sql_str = BattData_RT_SQL.getInsertOrUpdateBattTestDataInfStr(BattData_RT.this, test_stoptype_t);
|
sql_str = BattData_RT_SQL.getInsertOrUpdateBattTestDataInfStr(m_Conn_Pool,BattData_RT.this, test_stoptype_t);
|
sql_v.sqlMysqlExecute(sql_str);
|
//------------------------------------------------------------//
|
sql_v.mysql_con.commit();
|
|
mTestData.recordNum += 1;
|
mTestData.recordNum_BPM7100 += 1;
|
clear_al_MonVol_History_New();
|
|
MysqlDataResInfTable_Exist = true;
|
MysqlRecordInf_Exist = true;
|
} catch (SQLException e) {
|
try {
|
sql_v.mysql_con.rollback();
|
} catch (SQLException e1) {
|
// TODO Auto-generated catch block
|
logger.error(e1.toString(), e1);
|
}
|
|
logger.error(e.toString(), e);
|
result = false;
|
} finally {
|
try {
|
sql_v.mysql_con.setAutoCommit(true);
|
} catch (SQLException e1) {
|
// TODO Auto-generated catch block
|
logger.error(e1.toString(), e1);
|
}
|
if(true == result)
|
break;
|
else
|
{
|
try {
|
Thread.sleep(500);
|
} catch (InterruptedException e) {
|
logger.error(e.toString(), e);
|
}
|
}
|
}
|
}
|
}
|
|
@Override
|
public void run() {
|
Sql_Mysql sql = new Sql_Mysql(m_Conn_Pool);
|
String sql_str = null;
|
try {
|
sql.sqlMysqlUseDB(Sql_Mysql.DB_BATT_TESTDATA);
|
|
if(false == MysqlDataTable_Exist)
|
{
|
sql_str = BattData_RT_SQL.getCreateBattTestDataStr("`tb_BattTestDataStop_" + BattGroupId + "` ");
|
sql.sqlMysqlExecute(sql_str);
|
MysqlDataTable_Exist = sql.sqlMysqlCheckIfTableExist("tb_BattTestData_" + BattGroupId);
|
}
|
|
if(false == MysqlDataTable_Exist)
|
{
|
logger.warn("tb_BattTestData_" + BattGroupId + " is not exist, create it now...");
|
sql_str = BattData_RT_SQL.getCreateBattTestDataStr("`tb_BattTestData_" + BattGroupId + "` ");
|
sql.sqlMysqlExecute(sql_str);
|
}
|
|
if(BattStatData.BATTSTATE_FLOAT != mTestData.battTestState) {
|
inserTestDataToDB(sql, -1);
|
} else {
|
if(BattStatData.TEST_LOADER_FBS9100S == mTestData.getLoaderType()) {
|
//set_al_MonVol_History_New(); edit by mxpopstar @20200821
|
inserTestDataToDB(sql, mTestData.test_stoptype);
|
} else {
|
//save all discharge and charge data when tested by btse, edit by mxpopstar @20200922
|
if(mTestData.testTimeLong < mTestTimeLongMin) {
|
try {
|
sql.mysql_con.setAutoCommit(false);
|
ArrayList<String> al_str = BattData_RT_SQL.getDeleteBattTestDataStr(BattData_RT.this);
|
for(int n=0; n<al_str.size(); n++) {
|
sql.sqlMysqlExecute(al_str.get(n));
|
logger.warn(al_str.get(n));
|
}
|
sql.mysql_con.commit();
|
|
} catch (SQLException e) {
|
sql.mysql_con.rollback();
|
logger.error(e.toString(), e);
|
} finally {
|
sql.mysql_con.setAutoCommit(true);
|
}
|
}
|
}
|
}
|
} catch (SQLException e) {
|
logger.error(e.toString(), e);
|
} finally {
|
sql.close_con();
|
clearStoreDataBusyTag();
|
}
|
}
|
}
|
|
public static int getDefCommtimeoutmax() {
|
return DEF_CommTimeOutMax;
|
}
|
public MysqlConnPool getM_Conn_Pool() {
|
return m_Conn_Pool;
|
}
|
public boolean isMonDataIsUseForIdce8200() {
|
return MonDataIsUseForIdce8200;
|
}
|
public boolean ismIDCE8200_ConState() {
|
return mIDCE8200_ConState;
|
}
|
public int getmIDCE8200CommTimeout() {
|
return mIDCE8200CommTimeout;
|
}
|
public int getStationId() {
|
return StationId;
|
}
|
public String getStationName() {
|
return StationName;
|
}
|
public byte[] getStationIp() {
|
return StationIp;
|
}
|
public int getBattGroupId() {
|
return BattGroupId;
|
}
|
public int getBattCurrDeviceId() {
|
return BattCurrDeviceId;
|
}
|
public int[] getBattCurrValueId() {
|
return BattCurrValueId;
|
}
|
public int getFBSDeviceId() {
|
return FBSDeviceId;
|
}
|
public String getFBSDeviceIp() {
|
return FBSDeviceIp;
|
}
|
public String getFBSDeviceName() {
|
return FBSDeviceName;
|
}
|
public String getFBSRegCode() {
|
return FBSRegCode;
|
}
|
public int getGroupIndexInFBSDevice() {
|
return GroupIndexInFBSDevice;
|
}
|
public String getFBSDeviceIp_WG() {
|
return FBSDeviceIp_WG;
|
}
|
public String getFBSDeviceIp_YM() {
|
return FBSDeviceIp_YM;
|
}
|
public int getBattGroupNum() {
|
return BattGroupNum;
|
}
|
public int getMonCount() {
|
return MonCount;
|
}
|
public float getMonStdVol() {
|
return MonStdVol;
|
}
|
public float getMonStdCap() {
|
return MonStdCap;
|
}
|
public boolean isStoreBattRes_DataEn() {
|
return StoreBattRes_DataEn;
|
}
|
public boolean isStoreDataBusy() {
|
return StoreDataBusy;
|
}
|
public boolean isMysqlDataTable_Exist() {
|
return MysqlDataTable_Exist;
|
}
|
public boolean isMysqlDataResInfTable_Exist() {
|
return MysqlDataResInfTable_Exist;
|
}
|
public boolean isMysqlRecordInf_Exist() {
|
return MysqlRecordInf_Exist;
|
}
|
public InsertDataToMysql_Task getmSqlTask() {
|
return mSqlTask;
|
}
|
public ArrayList<MonVolData> getAl_MonVol() {
|
return al_MonVol;
|
}
|
public ArrayList<MonVolData> getAl_MonVol_RtOld() {
|
return al_MonVol_RtOld;
|
}
|
public ArrayList<MonVolData> getAl_MonVol_History() {
|
return al_MonVol_History;
|
}
|
public ArrayList<ArrayList<Integer>> getAl_MonVol_C_Id() {
|
return al_MonVol_C_Id;
|
}
|
public BattStatData getmTestData() {
|
return mTestData;
|
}
|
public int getmCommTimeCoutCount() {
|
return mCommTimeCoutCount;
|
}
|
public int getmMaxMonNum() {
|
return mMaxMonNum;
|
}
|
public float getmMaxMonVol() {
|
return mMaxMonVol;
|
}
|
public int getmMinMonNum() {
|
return mMinMonNum;
|
}
|
public float getmMinMonVol() {
|
return mMinMonVol;
|
}
|
public AppParam getmAppParam() {
|
return mAppParam;
|
}
|
public float getmBattFloatCurrLevel() {
|
return mBattFloatCurrLevel;
|
}
|
public float getmBattFloatVolLevel() {
|
return mBattFloatVolLevel;
|
}
|
public int getmTestTimeLongMin() {
|
return mTestTimeLongMin;
|
}
|
public int getmSaveDataTimeInterval() {
|
return mSaveDataTimeInterval;
|
}
|
public float getmDataHistoryNewLevel() {
|
return mDataHistoryNewLevel;
|
}
|
public int getmTestDataRecordCountMax() {
|
return mTestDataRecordCountMax;
|
}
|
public Logger getLogger() {
|
return logger;
|
}
|
public void setM_Conn_Pool(MysqlConnPool m_Conn_Pool) {
|
this.m_Conn_Pool = m_Conn_Pool;
|
}
|
public void setMonDataIsUseForIdce8200(boolean monDataIsUseForIdce8200) {
|
MonDataIsUseForIdce8200 = monDataIsUseForIdce8200;
|
}
|
public void setmIDCE8200_ConState(boolean mIDCE8200_ConState) {
|
this.mIDCE8200_ConState = mIDCE8200_ConState;
|
}
|
public void setmIDCE8200CommTimeout(int mIDCE8200CommTimeout) {
|
this.mIDCE8200CommTimeout = mIDCE8200CommTimeout;
|
}
|
public void setStationId(int stationId) {
|
StationId = stationId;
|
}
|
public void setStationName(String stationName) {
|
StationName = stationName;
|
}
|
public void setStationIp(byte[] stationIp) {
|
StationIp = stationIp;
|
}
|
public void setBattGroupId(int battGroupId) {
|
BattGroupId = battGroupId;
|
}
|
public void setBattCurrDeviceId(int battCurrDeviceId) {
|
BattCurrDeviceId = battCurrDeviceId;
|
}
|
public void setBattCurrValueId(int[] battCurrValueId) {
|
BattCurrValueId = battCurrValueId;
|
}
|
public void setFBSDeviceId(int fBSDeviceId) {
|
FBSDeviceId = fBSDeviceId;
|
}
|
public void setFBSDeviceIp(String fBSDeviceIp) {
|
FBSDeviceIp = fBSDeviceIp;
|
}
|
public int getCommPort() {
|
return commPort;
|
}
|
public void setCommPort(int commPort) {
|
this.commPort = commPort;
|
}
|
public void setFBSDeviceName(String fBSDeviceName) {
|
FBSDeviceName = fBSDeviceName;
|
}
|
public void setFBSRegCode(String fBSRegCode) {
|
FBSRegCode = fBSRegCode;
|
}
|
public void setGroupIndexInFBSDevice(int groupIndexInFBSDevice) {
|
GroupIndexInFBSDevice = groupIndexInFBSDevice;
|
}
|
public void setFBSDeviceIp_WG(String fBSDeviceIp_WG) {
|
FBSDeviceIp_WG = fBSDeviceIp_WG;
|
}
|
public void setFBSDeviceIp_YM(String fBSDeviceIp_YM) {
|
FBSDeviceIp_YM = fBSDeviceIp_YM;
|
}
|
public void setBattGroupNum(int battGroupNum) {
|
BattGroupNum = battGroupNum;
|
}
|
public void setBattState(int battState) {
|
BattState = battState;
|
}
|
public void setMonCount(int monCount) {
|
MonCount = monCount;
|
}
|
public void setMonStdVol(float monStdVol) {
|
MonStdVol = monStdVol;
|
}
|
public void setMonStdCap(float monStdCap) {
|
MonStdCap = monStdCap;
|
}
|
public void setStoreBattRes_DataEn(boolean storeBattRes_DataEn) {
|
StoreBattRes_DataEn = storeBattRes_DataEn;
|
}
|
public void setStoreDataBusy(boolean storeDataBusy) {
|
StoreDataBusy = storeDataBusy;
|
}
|
public void setMysqlDataTable_Exist(boolean mysqlDataTable_Exist) {
|
MysqlDataTable_Exist = mysqlDataTable_Exist;
|
}
|
public void setMysqlDataResInfTable_Exist(boolean mysqlDataResInfTable_Exist) {
|
MysqlDataResInfTable_Exist = mysqlDataResInfTable_Exist;
|
}
|
public void setMysqlRecordInf_Exist(boolean mysqlRecordInf_Exist) {
|
MysqlRecordInf_Exist = mysqlRecordInf_Exist;
|
}
|
public void setmSqlTask(InsertDataToMysql_Task mSqlTask) {
|
this.mSqlTask = mSqlTask;
|
}
|
public void setAl_MonVol(ArrayList<MonVolData> al_MonVol) {
|
this.al_MonVol = al_MonVol;
|
}
|
public void setAl_MonVol_RtOld(ArrayList<MonVolData> al_MonVol_RtOld) {
|
this.al_MonVol_RtOld = al_MonVol_RtOld;
|
}
|
public void setAl_MonVol_History(ArrayList<MonVolData> al_MonVol_History) {
|
this.al_MonVol_History = al_MonVol_History;
|
}
|
public void setAl_MonVol_C_Id(ArrayList<ArrayList<Integer>> al_MonVol_C_Id) {
|
this.al_MonVol_C_Id = al_MonVol_C_Id;
|
}
|
public void setmTestData(BattStatData mTestData) {
|
this.mTestData = mTestData;
|
}
|
public void setmCommTimeCoutCount(int mCommTimeCoutCount) {
|
this.mCommTimeCoutCount = mCommTimeCoutCount;
|
}
|
public void setmMaxMonNum(int mMaxMonNum) {
|
this.mMaxMonNum = mMaxMonNum;
|
}
|
public void setmMaxMonVol(float mMaxMonVol) {
|
this.mMaxMonVol = mMaxMonVol;
|
}
|
public void setmMinMonNum(int mMinMonNum) {
|
this.mMinMonNum = mMinMonNum;
|
}
|
public void setmMinMonVol(float mMinMonVol) {
|
this.mMinMonVol = mMinMonVol;
|
}
|
public void setmAppParam(AppParam mAppParam) {
|
this.mAppParam = mAppParam;
|
}
|
public void setmBattFloatCurrLevel(float mBattFloatCurrLevel) {
|
this.mBattFloatCurrLevel = mBattFloatCurrLevel;
|
}
|
public void setmBattFloatVolLevel(float mBattFloatVolLevel) {
|
this.mBattFloatVolLevel = mBattFloatVolLevel;
|
}
|
public void setmTestTimeLongMin(int mTestTimeLongMin) {
|
this.mTestTimeLongMin = mTestTimeLongMin;
|
}
|
public void setmSaveDataTimeInterval(int mSaveDataTimeInterval) {
|
this.mSaveDataTimeInterval = mSaveDataTimeInterval;
|
}
|
public void setmDataHistoryNewLevel(float mDataHistoryNewLevel) {
|
this.mDataHistoryNewLevel = mDataHistoryNewLevel;
|
}
|
public void setmTestDataRecordCountMax(int mTestDataRecordCountMax) {
|
this.mTestDataRecordCountMax = mTestDataRecordCountMax;
|
}
|
public void setLogger(Logger logger) {
|
this.logger = logger;
|
}
|
|
|
|
}
|
