//---------------------------------------------------------------------
|
#include <QApplication>
|
#include <QDateTime>
|
#include <stdio.h> /*标准输入输出定义*/
|
#include <stdlib.h> /*标准函数库定义*/
|
#include <string.h>
|
#include <unistd.h> /*Unix 标准函数定义*/
|
#include <sys/types.h>
|
#include <sys/stat.h>
|
#include <fcntl.h> /*文件控制定义*/
|
#include <termios.h> /*PPSIX 终端控制定义*/
|
#include <errno.h> /*错误号定义*/
|
#include "slavepc.h"
|
#include "crc16.h"
|
#include "filemanage.h"
|
#include "classxml.h"
|
|
#define SYSCODE 0xAAAAAAAA
|
#define Version 12
|
|
#define ADJ_VOL 0
|
#define ADJ_DIS 1
|
#define ADJ_CHR 2
|
|
|
|
//#define EN_THREAD_WORK_DEBUG
|
#ifdef EN_THREAD_WORK_DEBUG
|
#define THREAD_WORK_DEBUG qDebug
|
#else
|
#define THREAD_WORK_DEBUG(...)
|
#endif
|
|
SlavePC::SlavePC(Working_Page *page)
|
{
|
work_page = page;
|
RUN_EN = false;
|
|
this->OpenDev(PCCommPort);
|
this->SetDevAttr(19200,8,1,'N');
|
|
connect(this,SIGNAL(SendInterface(int)),work_page->work_thread,SLOT(RecvInterface(int)));
|
connect(this,SIGNAL(sendParam(int)),work_page,SLOT(operatorCMD_Work(int)));
|
|
}
|
|
SlavePC::~SlavePC()
|
{
|
RUN_EN = false;
|
quit();
|
wait();
|
}
|
|
//---------------------------------------------------------------------
|
//---------------------------------------------------------------------
|
/**
|
*@brief 设置串口通信速率
|
*@param fd 类型 int 打开串口的文件句柄
|
*@param speed 类型 int 串口速度
|
*@return void
|
*/
|
//---------------------------------------------------------------------
|
//---------------------------------------------------------------------
|
static int speed_arr[] = { B115200, B57600, B38400, B19200, B9600};
|
static int name_arr[] = { 115200, 57600, 38400, 19200, 9600};
|
void SlavePC::set_speed(int fd, int speed)
|
{
|
int status;
|
struct termios Opt;
|
tcgetattr(fd, &Opt);
|
for ( unsigned int i= 0; i < sizeof(speed_arr) / sizeof(int); i++)
|
{
|
if(speed == name_arr[i])
|
{
|
tcflush(fd, TCIOFLUSH);
|
cfsetispeed(&Opt, speed_arr[i]);
|
cfsetospeed(&Opt, speed_arr[i]);
|
status = tcsetattr(fd, TCSANOW, &Opt);
|
if(status != 0)
|
{
|
perror("tcsetattr fd1");
|
return;
|
}
|
tcflush(fd,TCIOFLUSH);
|
}
|
}
|
}
|
//---------------------------------------------------------------------
|
/**
|
*@brief 设置串口数据位，停止位和效验位
|
*@param fd 类型 int 打开的串口文件句柄
|
*@param databits 类型 int 数据位 取值 为 7 或者8
|
*@param stopbits 类型 int 停止位 取值为 1 或者2
|
*@param parity 类型 int 效验类型 取值为N,E,O,,S
|
*/
|
//---------------------------------------------------------------------
|
int SlavePC::set_Parity(int fd,int databits,int stopbits,int parity)
|
{
|
struct termios options;
|
if(tcgetattr(fd, &options) != 0)
|
{
|
perror("SetupSerial 1");
|
return(-1);
|
}
|
|
//--------------- 二进制传输模式 -------------------------
|
options.c_iflag = 0;
|
options.c_oflag = 0;
|
//------------------------------------------------------
|
|
options.c_cflag &= ~CSIZE;
|
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);/*Input*/
|
options.c_oflag &= ~OPOST;/*Output*/
|
switch (databits) /*设置数据位数*/
|
{
|
case 7:
|
options.c_cflag |= CS7;
|
break;
|
case 8:
|
options.c_cflag |= CS8;
|
break;
|
default:
|
fprintf(stderr,"Unsupported data size\n");
|
return (-1);
|
}
|
switch (parity)
|
{
|
case 'n':
|
case 'N':
|
options.c_cflag &= ~PARENB; /* Clear parity enable */
|
options.c_iflag &= ~INPCK; /* Enable parity checking */
|
break;
|
case 'o':
|
case 'O':
|
options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/
|
options.c_iflag |= INPCK; /* Disnable parity checking */
|
break;
|
case 'e':
|
case 'E':
|
options.c_cflag |= PARENB; /* Enable parity */
|
options.c_cflag &= ~PARODD; /* 转换为偶效验*/
|
options.c_iflag |= INPCK; /* Disnable parity checking */
|
break;
|
case 'S':
|
case 's': /*as no parity*/
|
options.c_cflag &= ~PARENB;
|
options.c_cflag &= ~CSTOPB;
|
break;
|
default:
|
fprintf(stderr,"Unsupported parity\n");
|
return (-1);
|
}
|
/* 设置停止位*/
|
switch (stopbits)
|
{
|
case 1:
|
options.c_cflag &= ~CSTOPB;
|
break;
|
case 2:
|
options.c_cflag |= CSTOPB;
|
break;
|
default:
|
fprintf(stderr,"Unsupported stop bits\n");
|
return (-1);
|
}
|
/* Set input parity option */
|
if (parity != 'n')
|
options.c_iflag |= INPCK;
|
|
tcflush(fd, TCIFLUSH);
|
options.c_cc[VTIME] = 0; /* 0.1S */
|
options.c_cc[VMIN] = 0;
|
/* Update the options and do it NOW */
|
if (tcsetattr(fd,TCSANOW,&options) != 0)
|
{
|
perror("SetupSerial 3");
|
return (-1);
|
}
|
return (0);
|
}
|
//---------------------------------------------------------------------
|
int SlavePC::OpenDev(const char *Dev)
|
{
|
FD = open(Dev, O_RDWR|O_NOCTTY|O_NDELAY);
|
|
return FD;
|
}
|
//---------------------------------------------------------------------
|
void SlavePC::SetDevAttr(int bitrate, char bitlen,
|
char stopbitlen, char checktype)
|
{
|
if(FD < 0)
|
return;
|
|
set_speed(FD, bitrate);
|
|
if(set_Parity(FD, bitlen, stopbitlen, checktype) < 0)
|
{
|
qDebug("Set Parity Error\n");
|
}
|
|
if(fcntl(FD, F_SETFL, FNDELAY) < 0)//非阻塞，覆盖前面open的属性
|
{
|
qDebug("fcntl failed\n");
|
}
|
}
|
//---------------------------------------------------------------------
|
int SlavePC::WriteDev(void *buf, int len)
|
{
|
if(FD < 0)
|
return 0;
|
|
return write(FD, (char *)buf, len);
|
}
|
//---------------------------------------------------------------------
|
int SlavePC::ReadDev(void *buf, int len)
|
{
|
if(FD < 0)
|
return 0;
|
|
char *pbuff = (char *)buf;
|
return (read(FD, pbuff, len));
|
}
|
|
bool SlavePC::CheckLen(FRAME_DATA *recv)
|
{
|
if(recv->Len >= 18)
|
{
|
return true;
|
}
|
return false;
|
}
|
bool SlavePC::CheckSYNCode(FRAME_DATA *recv)
|
{
|
if(recv->SYNCode == SYSCODE)
|
{
|
return true;
|
}
|
return false;
|
}
|
bool SlavePC::CheckCRC(FRAME_DATA *recv)
|
{
|
unsigned short Temp = recv->CRC;
|
recv->CRC =0;
|
recv->CRC = CRC16::CalCRC16(recv,recv->Len);
|
if(recv->CRC == Temp)
|
{
|
return true;
|
}
|
return false;
|
}
|
bool SlavePC::WriteFrameData(FRAME_DATA *Sent)
|
{
|
if(Sent->Len == WriteDev(Sent,Sent->Len))
|
return true;
|
else
|
return false;
|
}
|
|
bool SlavePC::ReadFrameHead(FRAME_DATA *recv, FRAME_DATA *Sent)
|
{
|
if(ReadDev(recv,18)==18)
|
{
|
if(CheckSYNCode(recv) == true)
|
{
|
if(CheckLen(recv) == false)
|
{
|
Sent->RecState = LEN_ERR;
|
}
|
return true;
|
}
|
}
|
return false;
|
}
|
|
bool SlavePC::ReadFrameData(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
if(ReadFrameHead(&recv,&Sent) == true)
|
{
|
if(Sent.RecState == SUCCEED)
|
{
|
if(CheckCRC(&recv) == false)
|
{
|
Sent.RecState = CRC_ERR;
|
}
|
}
|
return true;
|
}
|
return false;
|
}
|
//----------------------------------------------------------------------------------
|
|
quint16 SlavePC::getMonData(quint8 *info,quint16 MonNum)
|
{
|
static quint8 cnt = 0;
|
static quint8 bak_state = 0;
|
MON_DATA mondata;
|
memset(&mondata,0,sizeof(MON_DATA));
|
for(int i=0;i<4;i++)
|
{
|
mondata.GroupVol[i] = work_page->work_thread->fboData.SumVoltage;
|
mondata.GroupCur[i] = work_page->work_thread->fboData.SubCurrent[i];
|
mondata.reserved[0] = work_page->work_thread->fboData.OnlineVol;
|
if(work_page->work_thread->DATAVERSION == 0x05)
|
mondata.reserved[3] = work_page->work_thread->DATAVERSION<<8;
|
if(work_page->work_thread->localData.SysWorkState == Discharging || work_page->work_thread->localData.SysWorkState == Paused_Dischg)
|
{
|
bak_state = work_page->work_thread->localData.SysWorkState;
|
cnt = 5;
|
}
|
else
|
cnt = 0;
|
|
if((cnt > 0) && (work_page->work_thread->localData.SysWorkState == WorkStopped))
|
{
|
cnt--;
|
mondata.BattStatus[0] = bak_state + 0x80;
|
mondata.GroupCur[0] = 0;
|
}
|
else
|
{
|
mondata.BattStatus[0] = work_page->work_thread->localData.SysWorkState + 0x80;
|
bak_state = work_page->work_thread->localData.SysWorkState;
|
if(work_page->work_thread->localData.SysWorkState == WorkStopped/* && work_page->work_thread->localData.deviceTestType != TYPE_ON_LINE*/)
|
mondata.GroupCur[0] = 0;
|
}
|
}
|
mondata.BattStatus[1] = 0x80;
|
mondata.BattStatus[2] = 0x80;
|
mondata.BattStatus[3] = 0x80;
|
if(MonNum>300)
|
MonNum = 100;
|
memcpy(mondata.MonomerVol,work_page->work_thread->fboData.SingleVol,MonNum*2);
|
memcpy(info,&mondata,32 + MonNum*2);
|
|
return 32 + MonNum*2;
|
}
|
|
//quint16 SlaveCtrl::getAdjData(quint8 *info)
|
//{
|
// ADJ_DATA adjdata;
|
// memset(&adjdata,0,sizeof(adjdata));
|
// adjdata.OnlineVol = work_page->work_thread->fboData.OnlineVol;
|
// adjdata.GroupVol = 0.1*work_page->work_thread->fboData.SumVoltage;
|
// adjdata.dis_cur = 0.1*work_page->work_thread->fboData.SumCurrent;
|
// adjdata.chr_cur = 0.1*work_page->work_thread->fboData.SumCurrent;
|
// adjdata.out_cur = 0;
|
|
// memcpy(info,&adjdata,sizeof(ADJ_DATA));
|
// return sizeof(ADJ_DATA);
|
//}
|
|
quint16 SlavePC::getTestData(quint8 *info)
|
{
|
TEST_DATA testdata;
|
memset(&testdata,0,sizeof(testdata));
|
testdata.OnlineVol = work_page->work_thread->fboData.OnlineVol;
|
testdata.GroupVol = work_page->work_thread->fboData.SumVoltage;
|
testdata.CurrTime = work_page->work_thread->getTestFileTime();
|
testdata.testtime = work_page->work_thread->fboData.m_TestTime;
|
|
if(work_page->work_thread->localData.SysWorkState == Paused_Dischg ||
|
work_page->work_thread->localData.SysWorkState == Paused_charge)
|
{
|
testdata.KeyState = 1;
|
}
|
else if(work_page->work_thread->localData.SysWorkState == Charging ||
|
work_page->work_thread->localData.SysWorkState == WaitForCharging)
|
{
|
testdata.KeyState = work_page->work_thread->localData.SysWorkState-1;
|
}
|
else
|
{
|
testdata.KeyState = work_page->work_thread->localData.SysWorkState;
|
}
|
if(work_page->work_thread->localData.SysWorkState == Discharging)
|
testdata.monomerCount = work_page->work_thread->localData.monomerLowCount;
|
// else if(work_page->work_thread->localData.SysWorkState == Charging)
|
// testdata.monomerCount = work_page->work_thread->localData.monomerHighCount;
|
|
testdata.curr_cur = work_page->work_thread->fboData.SumCurrent;//*0.1
|
testdata.AllCap = work_page->work_thread->fboData.AllCap;
|
testdata.SMaxIndex = work_page->work_thread->localData.SMaxIndex[0];
|
testdata.SMaxVol = work_page->work_thread->localData.SMaxVol[0];
|
testdata.SMinIndex = work_page->work_thread->localData.SMinIndex[0];
|
testdata.SMinVol = work_page->work_thread->localData.SMinVol[0];
|
testdata.dischgTimes = work_page->work_thread->localData.dischgTimes;
|
//testdata.HighTemp = work_page->work_thread->GetBYDInfo()->temp_hight;
|
//testdata.LowTTemp = work_page->work_thread->GetBYDInfo()->temp_low;
|
if(work_page->work_thread->localData.SysWorkState == WorkStopped/* && work_page->work_thread->localData.deviceTestType != TYPE_ON_LINE*/)
|
testdata.curr_cur = 0;
|
if(work_page->work_thread->fboData.SumVoltage<F0VOL)
|
{
|
testdata.reserved[0] = work_page->work_thread->localData.RLY_OK&(~IGBT_VALUE);
|
}
|
else
|
testdata.reserved[0] = work_page->work_thread->localData.RLY_OK;
|
|
memcpy(info,&testdata,sizeof(TEST_DATA));
|
|
return sizeof(TEST_DATA);
|
}
|
quint8 *SlavePC::getFileDataHead(FILE_LIST_DATA &data,TEST_DATA_INFO &test_info,quint8 total,quint8 Index)
|
{
|
data.TotalFileNum = total;
|
data.CurrFileIndex = Index;
|
data.TestStartTime = test_info.fbo_data_head_start.TestStartTime;
|
data.TestTimeLong = test_info.fbo_data_head_stop.TestTimeLong;
|
data.DataType = test_info.fbo_data_head_start.DataType;
|
data.TestCur = test_info.fbo_data_head_start.TestCur;
|
data.TestCap = test_info.fbo_data_head_stop.TestCap;
|
data.STDCap = test_info.fbo_data_head_start.STDCap;
|
data.MVLLimit = test_info.fbo_data_head_start.MVLLimit;
|
data.SumVLLimit = test_info.fbo_data_head_start.SumVLLimit;
|
data.BattSum = test_info.fbo_data_head_start.BattSum;
|
data.BattGroup = test_info.fbo_data_head_start.BattGroup;
|
data.StopType = test_info.fbo_data_head_stop.StopType;
|
data.MonomerVol = test_info.fbo_data_head_start.MonomerVol;
|
|
return (quint8 *)&data;
|
}
|
|
quint16 SlavePC::getPageFileData(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
quint8 i;
|
quint8 page = recv.Db1;
|
quint16 j=0;
|
FileManage fileManage;
|
QStringList nameList = fileManage.getFiles(work_page->batteryName+"/",".FBO");
|
|
TEST_DATA_INFO test_info;
|
FILE_LIST_DATA file_data;
|
|
if(page*8 > nameList.count())
|
{
|
Sent.RecState = FILE_DATA_ERR;
|
return 0;
|
}
|
|
for(i=0;i<8 && i+page*8<nameList.count();i++)
|
{
|
if(ClassXML::AnalysisDataFBO(dataDir+work_page->batteryName+"/"+nameList.at(i+page*8),test_info))
|
{
|
getFileDataHead(file_data,test_info,nameList.count(),i+page*8);
|
memcpy(Sent.info+j,&file_data,sizeof(FILE_LIST_DATA));
|
j += sizeof(FILE_LIST_DATA);
|
}
|
}
|
return j;
|
}
|
|
quint16 SlavePC::getFileSmallBlock(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
quint16 Cnt_len=0;
|
quint16 total_block=0;
|
quint16 file_index = recv.RecState*256+recv.type;
|
quint16 smallBlock = recv.workState*256+recv.Alarm;
|
FileManage fileManage;
|
QStringList nameList = fileManage.getFiles(work_page->batteryName+"/",".FBO");
|
|
if(file_index >= nameList.count())
|
{
|
Sent.RecState = FILE_DATA_ERR;
|
return 0;
|
}
|
if(ClassXML::ReadsmallBlockDataFBO(dataDir+work_page->batteryName+"/"+nameList.at(file_index),
|
Sent.info,Cnt_len,total_block,smallBlock))
|
{
|
Sent.Db1 = (total_block>>8)&0xFF;
|
Sent.Db2 = (total_block)&0xFF;
|
Sent.Db3 = (smallBlock>>8)&0xFF;
|
Sent.Db4 = (smallBlock)&0xFF;
|
return Cnt_len;
|
}
|
return 0;
|
}
|
quint16 SlavePC::getBattName(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
quint16 batt_index = recv.RecState*256+recv.type;
|
QStringList batt_list = FileManage::getDirs();
|
quint16 batt_total = batt_list.count();
|
|
if(batt_index >= batt_total)
|
{
|
Sent.RecState = FILE_DATA_ERR;
|
return 0;
|
}
|
Sent.Db1 = (batt_total>>8)&0xFF;
|
Sent.Db2 = batt_total&0xFF;
|
Sent.Db3 = recv.RecState;
|
Sent.Db4 = recv.type;
|
|
QString battname = batt_list.at(batt_index);
|
memcpy(Sent.info,battname.toUtf8().data(),battname.toUtf8().length());
|
return battname.toUtf8().length();
|
}
|
quint16 SlavePC::getfileName(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
quint16 batt_index = recv.RecState*256+recv.type;
|
quint16 file_index = recv.workState*256+recv.Alarm;
|
QStringList batt_list = FileManage::getDirs();
|
QStringList file_List = FileManage::getFiles(batt_list.at(batt_index)+"/",".FBO");
|
quint16 batt_total = batt_list.count();
|
quint16 file_total = file_List.count();
|
if(batt_index >= batt_total || file_index >= file_total)
|
{
|
if(file_index > 0)
|
{
|
Sent.RecState = FILE_DATA_ERR;
|
}
|
return 0;
|
}
|
|
Sent.Db1 = (file_total>>8)&0xFF;
|
Sent.Db2 = file_total&0xFF;
|
Sent.Db3 = recv.workState;
|
Sent.Db4 = recv.Alarm;
|
|
QString filename = file_List.at(file_index);
|
memcpy(Sent.info,filename.toUtf8().data(),filename.toUtf8().length());
|
return filename.toUtf8().length();
|
}
|
quint16 SlavePC::getSelectFile(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
QString path_name = QString::fromUtf8((const char *)recv.info,recv.Len-18);
|
//qDebug()<<"111111"<<path_name;
|
quint16 Cnt_len=0;
|
quint16 total_block=0;
|
quint16 smallBlock = recv.RecState*256+recv.type;
|
|
if(ClassXML::ReadsmallBlockDataFBO(dataDir+path_name,
|
Sent.info,Cnt_len,total_block,smallBlock))
|
{
|
if(smallBlock >= total_block)
|
{
|
Sent.RecState = FILE_DATA_ERR;
|
}
|
Sent.Db1 = (total_block>>8)&0xFF;
|
Sent.Db2 = (total_block)&0xFF;
|
Sent.Db3 = (smallBlock>>8)&0xFF;
|
Sent.Db4 = (smallBlock)&0xFF;
|
return Cnt_len;
|
}
|
Sent.RecState = OTHER_ERR;
|
return 0;
|
}
|
|
quint16 SlavePC::getVersion(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
Sent.RecState = recv.RecState;
|
QString battname = phoneVersion;
|
memcpy(Sent.info,battname.toUtf8().data(),battname.toUtf8().length());
|
return battname.toUtf8().length();
|
}
|
|
void SlavePC::SaveTestParam(const QString &fname,TEST_PARAM_XML &test_param)
|
{
|
if(ClassXML::CreateTestParamXml(fname,test_param)) //新建的
|
{
|
|
}
|
else //原有的
|
{
|
ClassXML::ModifyTestParamXml(fname,test_param);
|
}
|
}
|
|
void SlavePC::NewBattFile(quint8 *info)
|
{
|
QString newname((const char *)info);
|
if(work_page->batteryName != newname)
|
{
|
ClassXML::ModifyNewestPNameXml(newname);
|
work_page->batteryName = newname;
|
SaveTestParam(newname,work_page->test_param_xml);
|
}
|
}
|
bool SlavePC::SelectBatt(quint8 *info)
|
{
|
QString newname((const char *)info);
|
TEST_PARAM_XML testParam;
|
if(true == ClassXML::ReadTestParamXml(newname, testParam))
|
{
|
ClassXML::ModifyNewestPNameXml(newname);
|
work_page->batteryName = newname;
|
emit sendParam(PARAM_PAGE_CMD_PARAM);
|
return true;
|
}
|
return false;
|
}
|
void SlavePC::DeleteBatt(quint8 *info)
|
{
|
QString newname((const char *)info);
|
FileManage fileManage;
|
|
if(newname == Default_Battery)
|
{
|
fileManage.clearDirectoryFiles(Default_Battery,fileManage.getFiles(Default_Battery,".FBO"));
|
}
|
else
|
{
|
fileManage.removeDir(dataDir+newname);
|
}
|
|
if(work_page->batteryName == newname)
|
{
|
newname = Default_Battery;
|
ClassXML::ModifyNewestPNameXml(newname);
|
work_page->batteryName = newname;
|
emit sendParam(PARAM_PAGE_CMD_PARAM);
|
}
|
}
|
|
//----------------------------------------------------------------------------------
|
void SlavePC::SlaveClearHeart()
|
{
|
work_page->work_thread->localData.rs485_pc.heart_cnt = 0;
|
}
|
|
void SlavePC::SlaveDisposeCMD(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
if((work_page->work_thread->localData.rs485_pc.Enter_ctrl == 0)&&(recv.CMD != EnterSlave))
|
{
|
Sent.RecState = SLAVEMODE_ERR;
|
return;
|
}
|
|
switch (recv.CMD) {
|
case Heartbea:
|
//SlaveClearHeart(dev);
|
break;
|
case ExitSlave:
|
work_page->work_thread->localData.rs485_pc.Enter_ctrl = 0;
|
break;
|
case EnterSlave:
|
if(work_page->work_thread->localData.rs485_pc.Enter_ctrl)
|
{
|
break;
|
}
|
qDebug("get CMD = %x",recv.CMD);
|
work_page->work_thread->localData.rs485_pc.Enter_ctrl = 1;
|
if(work_page->work_thread->localData.SysWorkState == WorkStopped && work_page->work_thread->localData.pauseBtnState == 0)
|
{
|
emit SendInterface(FACE_HOME);
|
}
|
else
|
{
|
Sent.RecState = SLAVEMODE_ERR;
|
}
|
break;
|
case StartDischarge:
|
if((work_page->work_thread->localData.SysWorkState == WorkStopped||work_page->work_thread->localData.SysWorkState == Paused_Dischg)&&
|
work_page->work_thread->localData.pauseBtnState!=2)
|
emit sendParam(PARAM_PAGE_CMD_START_DIS);//emit sendStart(work_page->work_thread->CMD_StartDischarge,work_page->batteryName);
|
else
|
Sent.RecState = START_ERR;
|
break;
|
case PausetDischarge:
|
if(work_page->work_thread->localData.SysWorkState == Discharging || work_page->work_thread->localData.SysWorkState == Paused_Dischg)
|
emit sendParam(PARAM_PAGE_CMD_PAUSE);//emit sendStart(work_page->work_thread->CMD_PauseDischarge,work_page->batteryName);
|
else
|
Sent.RecState = START_ERR;
|
break;
|
case StopDischarge:
|
if(work_page->work_thread->localData.SysWorkState == Paused_Dischg || work_page->work_thread->localData.SysWorkState == Discharging)
|
emit sendParam(PARAM_PAGE_CMD_STOP);//emit sendStart(work_page->work_thread->CMD_StopDischarge,work_page->batteryName);
|
else
|
Sent.RecState = START_ERR;
|
break;
|
case StartCharge:
|
if(work_page->work_thread->localData.SysWorkState == WorkStopped ||work_page->work_thread->localData.SysWorkState == Paused_charge)
|
emit sendParam(PARAM_PAGE_CMD_START_CHR);//emit sendStart(work_page->work_thread->CMD_StartCharge,work_page->batteryName);
|
else
|
Sent.RecState = START_ERR;
|
break;
|
case PauseCharge:
|
if(work_page->work_thread->localData.SysWorkState == Charging)
|
emit sendParam(PARAM_PAGE_CMD_PAUSE);//emit sendStart(work_page->work_thread->CMD_PauseCharge,work_page->batteryName);
|
else
|
Sent.RecState = START_ERR;
|
break;
|
case StopCharge:
|
if(work_page->work_thread->localData.SysWorkState == Paused_charge || work_page->work_thread->localData.SysWorkState == Charging)
|
emit sendParam(PARAM_PAGE_CMD_STOP);//emit sendStart(work_page->work_thread->CMD_StopCharge,work_page->batteryName);
|
else
|
Sent.RecState = START_ERR;
|
break;
|
// case StartCycle:
|
// if(work_page->work_thread->localData.SysWorkState == WorkStopped && work_page->work_thread->localData.deviceTestType == TYPE_CYCLE_TEST)
|
// {
|
// if(START_DISCHG == testParam.cycle_start)
|
// emit sendParam(PARAM_PAGE_CMD_START_DIS);
|
// else if(START_CHARGE == testParam.cycle_start)
|
// emit sendParam(PARAM_PAGE_CMD_START_CHR);
|
// else
|
// Sent.RecState = START_ERR;
|
// }
|
// else
|
// Sent.RecState = START_ERR;
|
// break;
|
// case PauseCycle:
|
// if(work_page->work_thread->localData.SysWorkState != WorkStopped && work_page->work_thread->localData.deviceTestType == TYPE_CYCLE_TEST)
|
// emit sendParam(PARAM_PAGE_CMD_PAUSE);
|
// else
|
// Sent.RecState = START_ERR;
|
// break;
|
// case StopCycle:
|
// if(work_page->work_thread->localData.SysWorkState != WorkStopped && work_page->work_thread->localData.deviceTestType == TYPE_CYCLE_TEST)
|
// emit sendParam(PARAM_PAGE_CMD_STOP);
|
// else
|
// Sent.RecState = START_ERR;
|
// break;
|
// case Adjust_StartDischarge:
|
// if(work_page->work_thread->localData.SysWorkState == WorkStopped)
|
// emit sendStart(work_page->work_thread->CMD_Adj_StartDis,work_page->batteryName);
|
// else
|
// Sent.RecState = START_ERR;
|
// break;
|
// case Adjust_StartCharge:
|
// if(work_page->work_thread->localData.SysWorkState == WorkStopped)
|
// emit sendStart(work_page->work_thread->CMD_Adj_StartChr,work_page->batteryName);
|
// else
|
// Sent.RecState = START_ERR;
|
// break;
|
// case Adjust_Stop:
|
// if(work_page->work_thread->localData.SysWorkState == Discharging)
|
// emit sendStart(work_page->work_thread->CMD_Adj_StopDis,work_page->batteryName);
|
// else if(work_page->work_thread->localData.SysWorkState == Charging)
|
// emit sendStart(work_page->work_thread->CMD_Adj_StopChr,work_page->batteryName);
|
// else
|
// Sent.RecState = START_ERR;
|
// break;
|
// case SetAdjustParm:
|
// if(recv.RecState == ADJ_VOL)
|
// emit SendCurrAdjCMD(work_page->work_thread->CMD_SetGroupVol,
|
// (recv.type*256+recv.workState-work_page->work_thread->localData.sim_buf.ADCVdin));
|
// else if(recv.RecState == ADJ_DIS)
|
// emit SendCurrAdjCMD(work_page->work_thread->CMD_SetDisChargCur,
|
// (recv.type*256+recv.workState-work_page->work_thread->localData.sim_buf.ADCId));
|
// else if(recv.RecState == ADJ_CHR)
|
// emit SendCurrAdjCMD(work_page->work_thread->CMD_SetChargCur,
|
// (recv.type*256+recv.workState-work_page->work_thread->localData.sim_buf.ADCIc));
|
// else
|
// Sent.RecState = START_ERR;
|
// break;
|
|
case SetDischargeParam:
|
case SetChargeParam:
|
case SetCycleParam:
|
if(sizeof(COMM_TEST_PARAM) == (recv.Len - 18))
|
{
|
TEST_PARAM_XML testParam;
|
setTestCommParam(testParam,recv.info);
|
//memcpy(addr,recv.info,sizeof(testParam));
|
SaveTestParam(work_page->batteryName,testParam);
|
emit sendParam(PARAM_PAGE_CMD_PARAM);
|
}
|
break;
|
|
case EnterHome:
|
{
|
quint8 pageIndex = 0;
|
if(recv.Len > 18)
|
{
|
pageIndex = recv.info[0];
|
}
|
else
|
{
|
pageIndex = recv.RecState;
|
}
|
//qDebug("pageIndex = %d,work_page->work_thread->localData.Interface=%d",pageIndex,work_page->work_thread->localData.Interface);
|
if(pageIndex != work_page->work_thread->localData.Interface)
|
{
|
if(work_page->work_thread->localData.SysWorkState == Paused_Dischg ||
|
work_page->work_thread->localData.SysWorkState == Paused_charge ||
|
work_page->work_thread->localData.SysWorkState == Discharging ||
|
work_page->work_thread->localData.SysWorkState == Charging ||
|
work_page->work_thread->localData.SysWorkState == WaitForCharging)
|
Sent.RecState = SYSTEM_WORKING;
|
else
|
{
|
emit SendInterface(pageIndex);
|
}
|
}
|
break;
|
}
|
case NewBatt:
|
NewBattFile(recv.info);
|
break;
|
case ChangedBatt:
|
if(!SelectBatt(recv.info))
|
Sent.RecState = OTHER_ERR;
|
break;
|
case DelBatt:
|
DeleteBatt(recv.info);
|
break;
|
case ClearAlarm:
|
work_page->work_thread->localData.popBox = 0;
|
emit sendParam(PARAM_PAGE_CLOSE_BOX);
|
break;
|
case SetTKQState:
|
emit sendParam(PARAM_PAGE_CMD_START_PSW);
|
break;
|
case SetFanState:
|
emit sendParam(PARAM_PAGE_CMD_START_FAN);
|
break;
|
case GetBattName:
|
case GetFileName:
|
case GetSelectFile:
|
case GetCellData:
|
case GetDischargeParam:
|
case GetChargeParam:
|
case GetDischargeData:
|
case GetChargeData:
|
case GetCycleParam:
|
case GetAdjustData:
|
case GetFileInfo:
|
case GetFile:
|
|
default:
|
break;
|
}
|
}
|
|
void SlavePC::SlaveSentFrame(FRAME_DATA &recv, FRAME_DATA &Sent)
|
{
|
static quint8 cnt = 0;
|
static quint8 bak_state = 0;
|
Sent.SYNCode = SYSCODE;
|
Sent.CMD = recv.CMD;
|
|
Sent.Len = 18;
|
Sent.type = work_page->work_thread->localData.Interface + 0x80;
|
|
if(work_page->work_thread->localData.SysWorkState == Discharging || work_page->work_thread->localData.SysWorkState == Paused_Dischg)
|
{
|
bak_state = work_page->work_thread->localData.SysWorkState;
|
cnt = 5;
|
}
|
else
|
cnt = 0;
|
|
if((cnt > 0) && (work_page->work_thread->localData.SysWorkState == WorkStopped))
|
{
|
cnt--;
|
Sent.workState = bak_state;
|
work_page->work_thread->fboData.SubCurrent[0] = 0;
|
work_page->work_thread->fboData.SumCurrent = 0;
|
}
|
else
|
{
|
Sent.workState = work_page->work_thread->localData.SysWorkState;
|
bak_state = work_page->work_thread->localData.SysWorkState;
|
}
|
if(work_page->work_thread->localData.TestType == TestTypeCharge)
|
Sent.Alarm = work_page->work_thread->localData.WPAlarmState + work_page->work_thread->localData.popBox + 0x40;
|
else
|
Sent.Alarm = work_page->work_thread->localData.WPAlarmState + work_page->work_thread->localData.popBox;
|
|
switch (recv.CMD) {
|
case Heartbea:
|
Sent.Db1 = 0;//work_page->work_thread->localData.rs485_pc.ID;
|
memcpy(Sent.info,work_page->batteryName.toUtf8().data(),work_page->batteryName.toUtf8().length());
|
Sent.Len += work_page->batteryName.toUtf8().length();
|
break;
|
case ExitSlave:
|
case StartDischarge:
|
case PausetDischarge:
|
case StartCharge:
|
case PauseCharge:
|
case SetAdjustParm:
|
case Adjust_StartDischarge:
|
case Adjust_StartCharge:
|
case Adjust_Stop:
|
case NewBatt:
|
case ChangedBatt:
|
case DelBatt:
|
case StopDischarge:
|
case StopCharge:
|
case ClearAlarm:
|
case StartCycle:
|
case PauseCycle:
|
case StopCycle:
|
case EnterHome:
|
break;
|
case EnterSlave:
|
Sent.Db1 = Version;
|
Sent.Db2 = 0;
|
Sent.Db3 = 0xF4;
|
break;
|
case GetDischargeParam:
|
case GetChargeParam:
|
case GetCycleParam:
|
// Sent.info = (quint8 *)&testParam;
|
// Sent.Len += sizeof(testParam);
|
getTestCommParam(work_page->test_param_xml,Sent.info);
|
Sent.Len += sizeof(COMM_TEST_PARAM);
|
break;
|
|
case GetCellData:
|
Sent.Db1 = work_page->test_param_xml.mon_number>>8;
|
Sent.Db2 = work_page->test_param_xml.mon_number & 0xFF;
|
|
Sent.Len += getMonData(Sent.info,work_page->work_thread->fboData.BattSum);
|
break;
|
case SetDischargeParam:
|
case SetChargeParam:
|
case SetCycleParam:
|
Sent.Db1 = recv.Db1;
|
break;
|
|
case GetDischargeData:
|
case GetChargeData:
|
if(work_page->work_thread->localData.waitTimeCount)
|
{
|
Sent.Db2 = 1;
|
quint16 timesec = work_page->work_thread->localData.waitTimeCount;
|
Sent.Db3 = timesec/256;
|
Sent.Db4 = timesec%256;
|
}
|
else if(((work_page->work_thread->localData.SysWorkState == Charging)&&(recv.CMD == GetDischargeData))
|
||((work_page->work_thread->localData.SysWorkState == Discharging)&&(recv.CMD == GetChargeData)))
|
{
|
Sent.Db2 = 2;
|
}
|
Sent.Len += getTestData(Sent.info);
|
break;
|
// case GetAdjustData:
|
// Sent.Len += getAdjData(Sent.info);
|
// break;
|
case GetFileInfo:
|
Sent.Len += getPageFileData(recv, Sent);
|
break;
|
case GetFile:
|
Sent.Len += getFileSmallBlock(recv,Sent);
|
break;
|
case GetBattName:
|
Sent.Len += getBattName(recv,Sent);
|
break;
|
case GetFileName:
|
Sent.Len += getfileName(recv,Sent);
|
break;
|
case GetSelectFile:
|
Sent.Len += getSelectFile(recv,Sent);
|
break;
|
case GetVersion:
|
Sent.Len += getVersion(recv,Sent);
|
default:
|
break;
|
}
|
|
Sent.CRC = CRC16::CalCRC16(&Sent,Sent.Len);
|
|
WriteFrameData(&Sent);
|
|
}
|
|
void SlavePC::SlaveResponse(FRAME_DATA &recv,FRAME_DATA &Sent)
|
{
|
if(Sent.RecState == SUCCEED)
|
{
|
SlaveClearHeart();//任何有效指令都当作心跳指令
|
SlaveDisposeCMD(recv,Sent);
|
}
|
SlaveSentFrame(recv,Sent);
|
}
|
|
//---------------------------------------------------------------------
|
void SlavePC::SlaveMode(FRAME_DATA &recv,FRAME_DATA &Sent)
|
{
|
if(ReadFrameData(recv,Sent) == true)
|
{
|
SlaveResponse(recv,Sent);
|
}
|
}
|
|
/******************************************************************************************/
|
void SlavePC::setTestCommParam(TEST_PARAM_XML &test_param,void *comm_param)
|
{
|
if(PageType == IDCE48CT)
|
test_param.test_mode = OFFline_working;
|
else if(PageType == FBI48CT)
|
test_param.test_mode = ONline_working;
|
else
|
test_param.test_mode = ((COMM_TEST_PARAM *)comm_param)->test_mode;
|
test_param.acstop_op = ((COMM_TEST_PARAM *)comm_param)->acstop_op;
|
test_param.nominal_cap = ((COMM_TEST_PARAM *)comm_param)->nominal_cap;
|
test_param.hourly_rate = ((COMM_TEST_PARAM *)comm_param)->hourly_rate;
|
test_param.preset_cur = ((COMM_TEST_PARAM *)comm_param)->preset_cur;
|
test_param.preset_cap = ((COMM_TEST_PARAM *)comm_param)->preset_cap;
|
test_param.preset_time = ((COMM_TEST_PARAM *)comm_param)->preset_time;
|
test_param.mon_lower = ((COMM_TEST_PARAM *)comm_param)->mon_lower;
|
test_param.group_lower = ((COMM_TEST_PARAM *)comm_param)->group_lower;
|
test_param.mon_number = ((COMM_TEST_PARAM *)comm_param)->mon_number;
|
test_param.group_number = ((COMM_TEST_PARAM *)comm_param)->group_number;
|
test_param.lower_number = ((COMM_TEST_PARAM *)comm_param)->lower_number;
|
test_param.mon_vol = ((COMM_TEST_PARAM *)comm_param)->mon_vol;
|
if(PageType == FBO48CT || TYPE_FBI_10480 || TYPE_FBI_4548 || TYPE_FBI_20240)
|
test_param.onlinevol_lowlimit = ((COMM_TEST_PARAM *)comm_param)->Reserved[0];
|
else
|
test_param.onlinevol_lowlimit = onlinevollow;
|
|
test_param.booster_ceiling = ((COMM_TEST_PARAM *)comm_param)->Reserved[1];
|
test_param.charge_limit = ((COMM_TEST_PARAM *)comm_param)->chrg_curr;
|
test_param.temp_High = ((COMM_TEST_PARAM *)comm_param)->chrg_temp;
|
test_param.discharge_mode = ((COMM_TEST_PARAM *)comm_param)->dischg_mode;
|
test_param.preset_power = ((COMM_TEST_PARAM *)comm_param)->pre_power;
|
|
if(test_param.group_number*test_param.mon_number > 300)
|
test_param.mon_number = 300/test_param.group_number;
|
if(test_param.group_number>4)
|
test_param.group_number = 4;
|
if(test_param.group_number*test_param.mon_number > 300)
|
test_param.mon_number = 300/test_param.group_number;
|
if(test_param.lower_number<=0)
|
test_param.lower_number = 1;
|
if(test_param.preset_time<=0)
|
test_param.preset_time = 1;
|
|
if(!(test_param.mon_vol == 20 || test_param.mon_vol == 40 ||
|
test_param.mon_vol == 60 || test_param.mon_vol == 120 ||
|
test_param.mon_vol == 12))
|
{
|
test_param.mon_vol = work_page->test_param_xml.mon_vol;
|
}
|
}
|
|
void SlavePC::getTestCommParam(TEST_PARAM_XML &test_param, void *comm_param)
|
{
|
memset(comm_param,0x00,sizeof(COMM_TEST_PARAM));
|
((COMM_TEST_PARAM *)comm_param)->test_mode = test_param.test_mode;
|
((COMM_TEST_PARAM *)comm_param)->acstop_op = test_param.acstop_op;
|
((COMM_TEST_PARAM *)comm_param)->nominal_cap = test_param.nominal_cap;
|
((COMM_TEST_PARAM *)comm_param)->hourly_rate = test_param.hourly_rate;
|
((COMM_TEST_PARAM *)comm_param)->preset_cur = test_param.preset_cur;
|
((COMM_TEST_PARAM *)comm_param)->preset_cap = test_param.preset_cap;
|
((COMM_TEST_PARAM *)comm_param)->preset_time = test_param.preset_time;
|
((COMM_TEST_PARAM *)comm_param)->mon_lower = test_param.mon_lower;
|
((COMM_TEST_PARAM *)comm_param)->group_lower = test_param.group_lower;
|
((COMM_TEST_PARAM *)comm_param)->mon_number = test_param.mon_number;
|
((COMM_TEST_PARAM *)comm_param)->group_number = test_param.group_number;
|
((COMM_TEST_PARAM *)comm_param)->lower_number = test_param.lower_number;
|
((COMM_TEST_PARAM *)comm_param)->mon_vol = test_param.mon_vol;
|
((COMM_TEST_PARAM *)comm_param)->Reserved[0] = test_param.onlinevol_lowlimit;//在线阈值
|
((COMM_TEST_PARAM *)comm_param)->Reserved[1] = test_param.booster_ceiling;//升压上限
|
((COMM_TEST_PARAM *)comm_param)->chrg_curr = test_param.charge_limit;
|
((COMM_TEST_PARAM *)comm_param)->chrg_temp = test_param.temp_High;
|
((COMM_TEST_PARAM *)comm_param)->dischg_mode = test_param.discharge_mode;
|
((COMM_TEST_PARAM *)comm_param)->pre_power = test_param.preset_power;
|
}
|
|
void SlavePC::run()
|
{
|
RUN_EN = true;
|
if(FD < 0)
|
RUN_EN = false;
|
|
FRAME_DATA frame_sent;
|
FRAME_DATA frame_recv;
|
|
while(RUN_EN)
|
{
|
memset(&frame_recv,0,sizeof(frame_recv));
|
memset(&frame_sent,0,sizeof(frame_sent));
|
SlaveMode(frame_recv,frame_sent);
|
msleep(50);
|
}
|
}
|
//***********************************************************************************
|
