#include "remote_ctrl.h"
|
#include <QDebug>
|
|
|
quint8 Remote_Ctrl::devAddr = 1;
|
|
Remote_Ctrl::Remote_Ctrl(Work_Thread *wt)
|
{
|
workThread = wt;
|
}
|
|
void Remote_Ctrl::setRemoteDevAddr(const quint8 addr)
|
{
|
devAddr = addr;
|
}
|
|
bool Remote_Ctrl::CheckLen(FRAME_DATA *recv)
|
{
|
if(recv->Len >= FRAMEHEAD && recv->Len <= sizeof(FRAME_DATA)){
|
return true;
|
}
|
|
return false;
|
}
|
|
bool Remote_Ctrl::CheckSYNCode(FRAME_DATA *recv)
|
{
|
bool res = false;
|
quint32 sCode = recv->SYNCode;
|
if((sCode&SYSCODECHECK) == SYSCODE){
|
quint32 id = (sCode&SYSCODECHECKID);
|
id = (quint8)(id>>24);
|
if( (devAddr==id) || (0xAA==id) || (0xFF==id) ){
|
res = true;
|
}
|
}
|
|
return res;
|
}
|
|
bool Remote_Ctrl::CheckCRC(FRAME_DATA *recv)
|
{
|
unsigned short Temp = recv->CRC;
|
recv->CRC =0;
|
recv->CRC = CRC16::CalCRC16(recv,recv->Len);
|
//qDebug("crc1 = 0x%X,crc2 = 0x%X",recv->CRC,Temp);
|
if(recv->CRC == Temp)
|
return true;
|
|
return false;
|
}
|
|
bool Remote_Ctrl::ReadFrameHead(FRAME_DATA *recv, FRAME_DATA *sent)
|
{
|
if(CheckSYNCode(recv) == true)
|
{
|
if(CheckLen(recv) == false){
|
sent->RecState = LEN_ERR;
|
}
|
|
return true;
|
}
|
else
|
return false;
|
}
|
|
bool Remote_Ctrl::ReadFrameData(FRAME_DATA *recv, FRAME_DATA *sent)
|
{
|
// qDebug("******* OK *********");
|
// return true;
|
|
|
|
|
if(ReadFrameHead(recv,sent) == true){
|
|
if(sent->RecState == SUCCEED){
|
if(CheckCRC(recv) == false){
|
sent->RecState = CRC_ERR;
|
}
|
}
|
|
return true;
|
}
|
|
return false;
|
}
|
|
quint16 Remote_Ctrl::getVersion(FRAME_DATA *recv,FRAME_DATA *sent)
|
{
|
sent->RecState = recv->RecState;
|
QString battname = Phone_Version;
|
memcpy(sent->info,battname.toUtf8().data(),battname.toUtf8().length());
|
|
return battname.toUtf8().length();
|
}
|
|
quint16 Remote_Ctrl::getMonData(FRAME_DATA *sent)
|
{
|
COMM_MON_DATA mondata;
|
memset(&mondata,0,sizeof(COMM_MON_DATA));
|
|
mondata.GroupVol[0] = workThread->modTestData.ADCVdc/10;
|
mondata.GroupCur[0] = workThread->modTestData.ADCIdc/10;
|
mondata.BattStatus[0] = workThread->testStateData.workState + 0x80;
|
|
quint16 battsum = workThread->packData.cell_count;
|
quint16 tempsum = workThread->packData.temp_count;
|
|
mondata.tempcount = tempsum;
|
|
memcpy(mondata.MonomerVol,workThread->packData.cell_vol,battsum*sizeof(quint16));
|
memcpy(mondata.MonomerTemp,workThread->packData.cell_temp,tempsum*sizeof(quint16));
|
|
quint8 *pinfo = (quint8 *)sent->info;
|
memcpy(pinfo,&mondata, HEAD_MONDATA + battsum*sizeof(quint16));
|
pinfo += HEAD_MONDATA + battsum*sizeof(quint16);
|
memcpy(pinfo,&(mondata.MonomerTemp), tempsum*sizeof(quint16));
|
|
return (HEAD_MONDATA + battsum*sizeof(quint16) + tempsum*sizeof(quint16));
|
}
|
|
quint16 Remote_Ctrl::getTestData(FRAME_DATA *sent)
|
{
|
COMM_TEST_DATA testdata;
|
memset(&testdata,0,sizeof(testdata));
|
|
testdata.OnlineVol = 0;
|
testdata.GroupVol = workThread->modTestData.ADCVdc;
|
testdata.testStartTime = workThread->getTestStartTime();
|
testdata.testtime = workThread->testStateData.testTime;
|
|
testdata.KeyState = 0;
|
|
if(workThread->testStateData.workState == WORK_STATE_DISCHG)
|
testdata.monomerCount = 0;
|
else if(workThread->testStateData.workState == WORK_STATE_CHARGE)
|
testdata.monomerCount = 0;
|
|
testdata.test_curr = workThread->modTestData.ADCIdc;
|
testdata.AllCap = workThread->testStateData.testCap;
|
testdata.SMaxIndex = 0;
|
testdata.SMaxVol = 0;
|
testdata.SMinIndex = 0;
|
testdata.SMinVol = 0;
|
testdata.cycleTimes = 0;
|
testdata.celltemp[0] = workThread->packData.cell_temp[0];
|
testdata.celltemp[1] = workThread->packData.cell_temp[1];
|
testdata.celltemp[2] = workThread->packData.cell_temp[2];
|
testdata.celltemp[3] = workThread->packData.cell_temp[3];
|
|
testdata.stoptype = workThread->testStateData.alarmState;
|
|
testdata.startfailedtype = workThread->testStateData.startState;
|
|
testdata.pack_vol_inside = workThread->packData.pack_vol_inside;
|
testdata.pack_vol_outside = workThread->packData.pack_vol_outside;
|
testdata.pack_current = workThread->packData.pack_current;
|
testdata.soc = workThread->packData.soc;
|
testdata.soh = workThread->packData.soh;
|
testdata.error[0] = workThread->packData.error[0];
|
testdata.error[1] = workThread->packData.error[1];
|
|
memcpy(sent->info,&testdata,sizeof(COMM_TEST_DATA));
|
|
return sizeof(COMM_TEST_DATA);
|
}
|
|
quint16 Remote_Ctrl::getCommTestParam(FRAME_DATA *sent)
|
{
|
COMM_TEST_PARAM comm_param;
|
memset(&comm_param,0x00,sizeof(COMM_TEST_PARAM));
|
|
comm_param.test_mode = 0; //放电类型;
|
comm_param.acstop_op = 0; //停电处理
|
comm_param.nominal_cap = 100; //标称容量
|
comm_param.hourly_rate = 10; //小时率
|
comm_param.preset_cur = workThread->testParam.disParam.dis_curr/10; //放电电流, 分辨率0.1
|
comm_param.preset_cap = workThread->testParam.disParam.dis_cap/10; //放电容量,分辨率0.1AH
|
comm_param.preset_time = workThread->testParam.disParam.dis_time; //预放时间,分钟
|
comm_param.mon_lower = workThread->testParam.disParam.cell_vol_low/10; //单体下限,分辨率0.01
|
comm_param.group_lower = workThread->testParam.disParam.sum_vol_low/10; //组端下限,分辨率0.1
|
comm_param.dischg_soc = workThread->testParam.disParam.dis_soc;
|
comm_param.mon_number = 30; //单体数量
|
comm_param.group_number = 1; //组数
|
comm_param.lower_number = 1; //下限个数
|
comm_param.mon_vol = 32; //只取值1.2, 2.0，6.0，12.0，3.2，3.7
|
comm_param.dischg_mode = 0; //放电模式:0恒流放电 1恒功率放电
|
comm_param.pre_power = 0; //预放功率
|
comm_param.pre_res = 0; //放电阻值
|
comm_param.chrg_curr = workThread->testParam.chgParam.chg_curr/10; //充电电流 分辨率0.1
|
comm_param.chrg_vol = workThread->testParam.chgParam.sum_vol_high/10; //充电电压 分辨率0.1
|
comm_param.chrg_vol_2 = workThread->testParam.chgParam.sum_vol_high/10; //浮充电压 分辨率0.1//范围小于充电电压
|
comm_param.chrg_cap = workThread->testParam.chgParam.chg_cap/10; //充电容量 分辨率0.1AH
|
comm_param.chrg_time = workThread->testParam.chgParam.chg_time; //充电时长
|
comm_param.chrg_time_2 = workThread->testParam.chgParam.chg_time; //浮充时长
|
comm_param.chrg_stopcurr = workThread->testParam.curr_end/10; //截止电流 分辨率0.1
|
comm_param.grp_uppervol = workThread->testParam.chgParam.sum_vol_high/10; //组端上限 分辨率0.1
|
comm_param.mon_uppervol = workThread->testParam.chgParam.cell_vol_high/10; //单体上限 分辨率0.01
|
comm_param.charge_soc = workThread->testParam.chgParam.chg_soc;
|
comm_param.mon_uppernum = 1; //单体上限数量
|
comm_param.chrg_temp = workThread->testParam.temp_high; //充电过温 分辨率0.1
|
comm_param.dischrg_temp = workThread->testParam.temp_high; //放电过温 分辨率0.1
|
comm_param.cycle_start = TestTypeDischarge - workThread->testParam.test_type; //活化起点 0放电 ，1充电
|
comm_param.cycle_times = 1; //活化次数
|
comm_param.waitdis_time = 1; //充完静置
|
comm_param.waitchr_time = 1; //放完静置
|
comm_param.cell_diffvol = workThread->testParam.cell_vol_diff;
|
|
comm_param.BattPackAddr = workThread->packParam.pack_devaddr;
|
|
memcpy(sent->info,&comm_param,sizeof(COMM_TEST_PARAM));
|
|
return sizeof(COMM_TEST_PARAM);
|
}
|
|
quint16 Remote_Ctrl::getCommPackParam(FRAME_DATA *sent)
|
{
|
memcpy(sent->info,&(workThread->packParam),sizeof(PACK_PARAM));
|
|
return sizeof(PACK_PARAM);
|
}
|
|
quint16 Remote_Ctrl::getPackBarcode(FRAME_DATA *sent)
|
{
|
QString barcode = workThread->packBarcode;
|
memcpy(sent->info,barcode.toUtf8().data(),barcode.toUtf8().length());
|
|
return barcode.toUtf8().length();
|
}
|
|
void Remote_Ctrl::setPackBarcode(FRAME_DATA *recv){
|
|
int len = recv->Len - FRAMEHEAD;
|
|
if(len>0 && len<250){
|
char barcode[256];
|
|
barcode[len] = '\0';
|
|
memcpy(barcode,recv->info,len);
|
|
QString barcodestr(barcode);
|
|
qDebug()<<barcodestr;
|
|
workThread->setPackBarcodeStr(barcodestr);
|
}
|
}
|
|
quint16 Remote_Ctrl::exePassthroughData(FRAME_DATA *recv,FRAME_DATA *sent)
|
{
|
int len = recv->Len-FRAMEHEAD;
|
|
workThread->rs485_Pack->lock_RS485();
|
|
// for(int n=0;n<8;n++){
|
// qDebug("tx - 0x%X",recv->info[n]);
|
// }
|
// qDebug("-----");
|
|
int rxlen = workThread->rs485_Pack->Tx_Rx_Data(recv->info,len,sent->info,300);
|
|
// for(int n=0;n<8;n++){
|
// qDebug("rx - 0x%X",sent->info[n]);
|
// }
|
|
if(0 == rxlen){
|
sent->RecState = PACK_COMM_ERR;
|
}
|
|
workThread->rs485_Pack->unlock_RS485();
|
|
return rxlen;
|
}
|
|
quint16 Remote_Ctrl::getPackDataModbus(FRAME_DATA *recv,FRAME_DATA *sent)
|
{
|
quint16 len = 0;
|
|
/*
|
for(int n=0;n<8;n++){
|
qDebug("0x%X",recv->info[n]);
|
}
|
qDebug("************************************************");
|
*/
|
|
if( (recv->info[0]==0x06) && (recv->info[1]==0x03) ){
|
quint16 regaddr = recv->info[2]*256+recv->info[3];
|
quint16 regnum = recv->info[4]*256+recv->info[5];
|
|
sent->info[0] = recv->info[0];
|
sent->info[1] = recv->info[1];
|
|
if(regnum > 124){
|
regnum = 124;
|
}
|
|
if( (regaddr>=Halo_RegAddr_Version && regaddr<(Halo_RegAddr_Version+Halo_RegCount_Version))
|
|| (regaddr>=Halo_RegAddr_Soc && regaddr<(Halo_RegAddr_Soc+Halo_RegCount_Soc)) ){
|
|
quint16 *pdata = 0;
|
|
if(regaddr>=Halo_RegAddr_Version && regaddr<(Halo_RegAddr_Version+Halo_RegCount_Version)){
|
if((regaddr+regnum)>(Halo_RegAddr_Version+Halo_RegCount_Version)){
|
regnum = (Halo_RegAddr_Version+Halo_RegCount_Version)-regaddr;
|
}
|
|
pdata = (quint16 *)(&(workThread->packData_Origin.soft_version));
|
pdata += regaddr-Halo_RegAddr_Version;
|
}
|
else if(regaddr>=Halo_RegAddr_Soc && regaddr<(Halo_RegAddr_Soc+Halo_RegCount_Soc)){
|
if((regaddr+regnum)>(Halo_RegAddr_Soc+Halo_RegCount_Soc)){
|
regnum = (Halo_RegAddr_Soc+Halo_RegCount_Soc)-regaddr;
|
}
|
|
pdata = (quint16 *)(&(workThread->packData_Origin.soc));
|
pdata += regaddr-Halo_RegAddr_Soc;
|
|
}
|
|
sent->info[2] = regnum*2;
|
for(qint8 n=0;n<regnum;n++){
|
//qDebug("regaddr = %d,regnum = %d,n = %d,data = %d",regaddr,regnum,n+1,pdata[n]);
|
sent->info[3+n*2] = pdata[n]/256;
|
sent->info[4+n*2] = pdata[n]%256;
|
}
|
//qDebug("*******************************************************************");
|
unsigned short crc = CRC16::CalModbusCRC16(sent->info, 3+2*regnum);
|
sent->info[3+2*regnum] = (quint8)(crc>>8);
|
sent->info[4+2*regnum] = (quint8)crc;
|
|
len = 5+2*regnum;
|
}
|
else{
|
sent->RecState = PACK_COMM_ERR;
|
}
|
}
|
else{
|
sent->RecState = PACK_COMM_ERR;
|
}
|
|
return len;
|
}
|
|
void Remote_Ctrl::setCommTestParam(FRAME_DATA *recv)
|
{
|
COMM_TEST_PARAM comm_param;
|
memcpy(&comm_param,recv->info,sizeof(COMM_TEST_PARAM));
|
|
TEST_PARAM testparam;
|
testparam = workThread->testParam;
|
|
testparam.disParam.dis_curr = comm_param.preset_cur*10;
|
testparam.disParam.dis_cap = comm_param.preset_cap*10;
|
testparam.disParam.dis_time = comm_param.preset_time;
|
testparam.disParam.cell_vol_low = comm_param.mon_lower*10;
|
testparam.disParam.sum_vol_low = comm_param.group_lower*10;
|
testparam.disParam.dis_soc = comm_param.dischg_soc;
|
|
testparam.chgParam.chg_curr = comm_param.chrg_curr*10;
|
testparam.chgParam.sum_vol_high = comm_param.chrg_vol*10;
|
testparam.chgParam.chg_cap = comm_param.chrg_cap*10;
|
testparam.chgParam.chg_time = comm_param.chrg_time;
|
testparam.chgParam.cell_vol_high = comm_param.mon_uppervol*10;
|
testparam.chgParam.chg_soc = comm_param.charge_soc;
|
testparam.curr_end = comm_param.chrg_stopcurr*10;
|
|
testparam.cell_vol_diff = comm_param.cell_diffvol;
|
testparam.temp_high = comm_param.chrg_temp;
|
//testparam.test_type = TestTypeDischarge-comm_param.cycle_start;
|
|
workThread->saveTestParam(testparam);
|
}
|
|
void Remote_Ctrl::setCommPackParam(FRAME_DATA *recv)
|
{
|
PACK_PARAM comm_param;
|
memcpy(&comm_param,recv->info,sizeof(PACK_PARAM));
|
|
if(comm_param.pack_devaddr < 1){
|
comm_param.pack_devaddr = 1;
|
}
|
|
//PACK_PARAM packparam;
|
//packparam = workThread->packParam;
|
|
//packparam = comm_param;
|
|
workThread->savePackParam(comm_param);
|
}
|
|
bool Remote_Ctrl::processRxData(FRAME_DATA *recv, FRAME_DATA *sent,const quint8 contype)
|
{
|
//如果需要蓝牙和网络同时使用，可加上 QMutexLocker locker(&ble_net_mutex);
|
|
//qDebug("RX: SYNCode = 0x%X,Len = 0x%X,CMD = 0x%X,RecState = 0x%X,type = 0x%X,workState = 0x%X,Alarm = 0x%X,CRC = 0x%X",recv->SYNCode,recv->Len,recv->CMD,recv->RecState,recv->type,recv->workState,recv->Alarm,recv->CRC);
|
|
if(ReadFrameData(recv, sent)){
|
remote_state = workThread->remoteState;
|
passthrough_Stat = workThread->passthroughState;
|
|
//if( (0==remote_state.enter_slave) && (recv->CMD != EnterSlave) )
|
//sent->RecState = SLAVEMODE_ERR;
|
|
//透传中，只能响应透传和退出透传指令
|
if( (1==passthrough_Stat.passing) && (recv->CMD!=EnterPackPassthrough) && (recv->CMD!=ExitPackPassthrough) ){
|
sent->RecState = SYSTEM_WORKING;
|
}
|
//进入透传时，必须非工作状态
|
else if( (0==passthrough_Stat.passing) && (recv->CMD==EnterPackPassthrough) ){
|
if( (workThread->testStateData.workState != WORK_STATE_STOPPED)
|
|| (1==passthrough_Stat.execing) ){
|
sent->RecState = PASSTHROUGH_ERR;
|
}
|
}
|
|
if(sent->RecState == SUCCEED){
|
|
remote_state.heart_ticks = 0;
|
|
remote_state.conn_type = contype;
|
|
remote_state.enter_slave = 1;
|
|
switch (recv->CMD){
|
case Heartbeat:{
|
}
|
break;
|
case ExitSlave:{
|
remote_state.enter_slave = 0;
|
remote_state.to_workpage = 0;
|
remote_state.conn_type = 0;
|
}
|
break;
|
case EnterSlave:{
|
remote_state.enter_slave = 1;
|
}
|
break;
|
|
case GetCellData:{
|
sent->Db1 = workThread->packData.cell_count/256;
|
sent->Db2 = workThread->packData.cell_count%256;
|
}
|
break;
|
|
case SetDischargeParam:
|
case SetChargeParam:{
|
//if(sizeof(COMM_TEST_PARAM) == (recv->Len - FRAMEHEAD))
|
{
|
setCommTestParam(recv);
|
}
|
}
|
break;
|
|
case GetDischargeParam:
|
case GetChargeParam:{
|
}
|
break;
|
|
case StartDischarge:
|
case PausetDischarge:
|
case StartCharge:
|
case PauseCharge:
|
case StopDischarge:
|
case StopCharge:{
|
remote_state.to_workpage = 1;
|
|
TEST_PARAM testparam = workThread->testParam;
|
if(recv->CMD == StartDischarge){
|
if(WORK_STATE_STOPPED == workThread->testStateData.workState){
|
if(START_OK == workThread->startErrorCheck()){
|
if(TestTypeDischarge != testparam.test_type){
|
testparam.test_type = TestTypeDischarge;
|
workThread->saveTestParam(testparam);
|
}
|
|
workThread->setWorkThreadCMD(workThread->CMD_StartTest);
|
}
|
else{
|
sent->RecState = START_ERR;
|
}
|
}
|
else{
|
sent->RecState = START_ERR;
|
}
|
}
|
else if(recv->CMD == StartCharge){
|
if(WORK_STATE_STOPPED == workThread->testStateData.workState){
|
if(START_OK == workThread->startErrorCheck()){
|
|
if(TestTypeCharge != testparam.test_type){
|
testparam.test_type = TestTypeCharge;
|
workThread->saveTestParam(testparam);
|
}
|
|
workThread->setWorkThreadCMD(workThread->CMD_StartTest);
|
}
|
else{
|
sent->RecState = START_ERR;
|
}
|
}
|
else{
|
sent->RecState = START_ERR;
|
}
|
}
|
else{
|
if(WORK_STATE_STOPPED != workThread->testStateData.workState){
|
workThread->setWorkThreadCMD(workThread->CMD_StopTest);
|
}
|
}
|
}
|
break;
|
|
case GetDischargeData:
|
case GetChargeData:{
|
sent->Db2 = 0;
|
}
|
break;
|
|
case GetVersion:{
|
}
|
break;
|
|
case EnterPackPassthrough:{
|
passthrough_Stat.passing = 1;
|
workThread->rs485_Pack->pausePackComm();
|
workThread->setPassthroughState(passthrough_Stat);
|
}
|
break;
|
|
case EasyPackPassthrough:{
|
}
|
break;
|
|
case ExitPackPassthrough:{
|
passthrough_Stat.passing = 0;
|
workThread->rs485_Pack->remsumPackComm();
|
workThread->setPassthroughState(passthrough_Stat);
|
}
|
break;
|
|
case GetPackParam:
|
case GetPackBarcode:
|
case GetPackData:{
|
}
|
break;
|
|
case SetPackParam:{
|
//if(sizeof(PACK_PARAM) == (recv->Len - FRAMEHEAD))
|
{
|
setCommPackParam(recv);
|
}
|
}
|
break;
|
|
case SetPackBarcode:{
|
//qDebug("Set Pack Barcode....");
|
setPackBarcode(recv);
|
}
|
break;
|
|
case ActivePack:{
|
//qDebug("Active The Pack....");
|
workThread->setWorkThreadCMD(workThread->CMD_SetActivePack);
|
}
|
break;
|
|
|
|
|
}
|
|
workThread->setRemoteState(remote_state);
|
|
prepareSendData(recv,sent);
|
}
|
|
return true;
|
}
|
|
return false;
|
}
|
|
void Remote_Ctrl::prepareSendData(FRAME_DATA *recv,FRAME_DATA *sent)
|
{
|
sent->SYNCode = SYSCODE | (devAddr<<24); //recv->SYNCode;
|
sent->CMD = recv->CMD;
|
sent->Len = FRAMEHEAD;
|
sent->TType = 0x80 + workThread->getPageIndex();
|
sent->workState = workThread->testStateData.workState;
|
sent->Alarm = workThread->testStateData.alarmState;
|
|
switch (recv->CMD){
|
case Heartbeat:
|
case ExitSlave:{
|
|
}
|
break;
|
|
case EnterSlave:{
|
sent->Db1 = 0x20;
|
}
|
break;
|
|
case GetCellData:{
|
sent->Len += getMonData(sent);
|
}
|
break;
|
|
case GetDischargeParam:
|
case GetChargeParam:{
|
sent->Len += getCommTestParam(sent);
|
}
|
break;
|
|
case GetDischargeData:
|
case GetChargeData:{
|
sent->Len += getTestData(sent);
|
}
|
break;
|
|
case GetVersion:{
|
sent->Len += getVersion(recv,sent);
|
}
|
break;
|
|
case EasyPackPassthrough:
|
case EnterPackPassthrough:{
|
sent->Len += exePassthroughData(recv,sent);
|
}
|
break;
|
|
case GetPackData:{
|
sent->Len += getPackDataModbus(recv,sent);
|
}
|
break;
|
|
case GetPackParam:{
|
sent->Len += getCommPackParam(sent);
|
}
|
break;
|
|
case GetPackBarcode:{
|
sent->Len += getPackBarcode(sent);
|
}
|
break;
|
|
case ActivePack:{
|
}
|
break;
|
}
|
|
sent->CRC = CRC16::CalCRC16(sent,sent->Len);
|
}
|
