hlp/VX5-DiaphragmPump
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1e48e6a47b7568043d15116ebeebab585532e544
VX5-DiaphragmPump/InkJetPrinter.cpp
T

3430 lines
154 KiB
C++
Raw Blame History

#include "InkJetPrinter.h"
#include "ui_inkjetprinter.h"
#include "QDebug"
#include "LogInfo.h"
#include "mainwindow.h"
#include "DlgVolteParaNo73.h"
#include "DlgVoltePara25Dots.h"
#include "./Network/NetworkManager.h"
#include "ZkEdit.h"
#include "myinclude.h"
#include <QFile>
#include <QPushButton>
#include <iostream>
#include <string>
#include <cmath>
#define MAX_VOL 300
#define MIN_VOL 0
void PID_init();
#define ONLYCNTCLEAR
extern MyInputMethod *myInputMethod;
static bool firstTime = true;
static unsigned int PulseCnt = 0; //时间间隔内的脉冲累计数
InkJetPrinter::InkJetPrinter(QWidget *parent) :
QTabWidget(parent),
ui(new Ui::InkJetPrinter)
{
// 隐藏系统任务栏，隐藏后，如果需要激活任务栏，则需要呼出QtUI中的任意弹出式、非全屏窗口，然后使用鼠标将光标移动至屏幕最左侧或最顶部则可以呼出任务栏
int ret = system("xfconf-query -c xfce4-panel -p /panels/panel-1/autohide-behavior -s 2");
qInfo() << "Hide system panel ret:" << ret;
// system("ifconfig eth1 down");
ui->setupUi(this);
SysPara *para = new SysPara();
bindSysPara(para);
ui->tabMainWindow->bindSysPara(para);
sysPara->status.InkOrSOLVEmptyCnt=0;
t1.start();//calandar_and_dat_t
fileTransceiv = new FileTranseceiver(5001);
QObject::connect(fileTransceiv,SIGNAL(fileRecieved(QString)),this,SLOT(recievedFile2Save(QString)));
fileTransceiv->start();
//edit@12-30
tcpTransceiv = new FileTranseceiver(5002);
tcpTransceiv->start();
connect(ui->tabMainWindow,SIGNAL(closeSerial()),this,SLOT(closedSerial()));
qDebug()<<"main thread id:"<< QString("0x%1").arg(reinterpret_cast<quintptr>(QThread::currentThreadId()), 0, 16);
m_serialThreadFPGA = new QThread;
serialFPGA = new Serial("/dev/ttyAS5");
connect(m_serialThreadFPGA,&QThread::started,serialFPGA,&Serial::startInitSlot);
serialFPGA->moveToThread(m_serialThreadFPGA);
connect(serialFPGA,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendFPGADate(int,int,unsigned char*,int,int)));
connect(serialFPGA,SIGNAL(resendFPGAData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendFPGADate(int,int,unsigned char*,int,int)));
connect(sysPara->devOp,SIGNAL(sendSerialDataToFPGA(int,int,unsigned char*,int,int)),serialFPGA,SLOT(sendSerialData(int,int,unsigned char*,int,int)),Qt::QueuedConnection);
connect(serialFPGA,SIGNAL(getFPGAVersion(uint)),this,SLOT(saveFPGAVersionNum(uint)));
connect(serialFPGA,SIGNAL(stopSendData(bool)),this,SLOT(stopSendFPGAData(bool)));
connect(serialFPGA,SIGNAL(getFPGAPhaseDetectHighTm(unsigned char*)),this,SLOT(saveFPGAPhaseDetectHighTm(unsigned char*)));
connect(serialFPGA,SIGNAL(getFPGAStatus(unsigned char*)),this,SLOT(saveFPGAStatus(unsigned char*)));
connect(serialFPGA,SIGNAL(getFPGACalandarAndDat(unsigned char*)),this,SLOT(saveFPGACalandarAndDat(unsigned char*)));
connect(serialFPGA,SIGNAL(getFPGACnt3CurrValue(unsigned char*)),this,SLOT(saveFPGACnt3CurrValue(unsigned char*)));
connect(serialFPGA,SIGNAL(getFPGAXXXDay(unsigned char*)),this,SLOT(saveFPGAXXXDay(unsigned char*)));
connect(serialFPGA,SIGNAL(queueSizeFPGA(int)),ui->tabMainWindow,SLOT(showFPGAqueuesize(int)));
connect(serialFPGA,SIGNAL(queueFPGASizeSIG(int)),ui->tabMainWindow,SLOT(showqueueFPGAsize(int)));
connect(serialFPGA, &Serial::FPGABuildDat, this, [this](int buildTime){
sysPara->status.build_dat.builTime = quint16(buildTime);
qDebug() << "FPGA build time: " << buildTime;
});
m_serialThreadSTM32 = new QThread();
serialSTM32 = new Serial("/dev/ttyAS2");
connect(m_serialThreadSTM32,&QThread::started,serialSTM32,&Serial::startInitSlot);
serialSTM32->moveToThread(m_serialThreadSTM32);
connect(serialSTM32,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendSTM32Date(int,int,unsigned char*,int,int)));
connect(sysPara->devOp,SIGNAL(sendSerialDataToSTM32(int,int,unsigned char*,int,int)),serialSTM32,SLOT(sendSerialData(int,int,unsigned char*,int,int)));
connect(serialSTM32,SIGNAL(getSTM32Status(unsigned char*)),this,SLOT(saveSTM32Status(unsigned char*)));
connect(serialSTM32,SIGNAL(getGearPumpVal(unsigned char*)),this,SLOT(saveGearPumpVal(unsigned char*)));
connect(serialSTM32,SIGNAL(getPulseCnt(unsigned char*)),this,SLOT(savePulseCntVal(unsigned char*)));
connect(serialSTM32,SIGNAL(getSTM32Version(unsigned char*)),this,SLOT(saveSTM32Version(unsigned char*)));
connect(serialSTM32,SIGNAL(getSTM32Time(unsigned char*)),this,SLOT(saveSTM32Time(unsigned char*)));
connect(serialSTM32,SIGNAL(stopSendData(bool)),this,SLOT(stopSendSTM32Data(bool)));
connect(serialSTM32,SIGNAL(powerOffReady()),ui->tabMainWindow,SLOT(powerOffConfirmed()));
connect(serialSTM32,SIGNAL(queueSizeSTM32(int)),ui->tabMainWindow,SLOT(showSTM32queuesize(int)));
connect(ui->tabSystemManage,SIGNAL(upgradeSTM32(QString)),serialSTM32,SLOT(upgradeSTM32File(QString)));
connect(ui->tabSystemManage,SIGNAL(enableClick(bool)),this,SLOT(enableInkJetTabClick(bool)));
connect(serialSTM32,SIGNAL(progress(int,int)),ui->tabSystemManage,SLOT(progressBarControl(int,int)));
connect(serialSTM32, &Serial::STM32Connected, this, [this](bool ok, QString errStr){
if(!ok || !sysPara || !sysPara->devOp) {
return;
}
QTimer::singleShot(1000, this, [this](){
sysPara->devOp->highVoltageCtrl(0);
LogInfo::setRunStatusText("High voltage forced off at app boot");
});
}, Qt::QueuedConnection);
connect(ui->tabSystemManage,SIGNAL(sigToCloseSerialFPGA()),this,SLOT(closeSerialFPGA()));
connect(ui->tabSystemManage,SIGNAL(sigToCloseSerialSTM32()),this,SLOT(closeSerialSTM32()));
connect(ui->tabSystemManage,SIGNAL(restartSerial()),this,SLOT(restartSerialPort()));
flagOfSerialThreadStratEn = true;
connect(this,SIGNAL(showReclaimTankstatus(unsigned char)),ui->tabPrintSetting,SLOT(showReclaimTankstatusslot(unsigned char)));
connect(this,SIGNAL(showMotorIsen(int,int)),ui->tabPrintSetting,SLOT(showMotorIsenVal(int,int)));
connect(ui->tabPrintSetting,SIGNAL(HiddenFunction(bool)),ui->tabMainWindow->getTexteditOption(),SLOT(SetHiddenValue(bool)));
ui->tabMainWindow->SetEditMode(sysPara->para.EditMode);
ui->tabOtherInfo->bindSysPara(para);
ui->tabPrintSetting->bindSysPara(para);
ui->tabSystemSetting->bindSysPara(para);
ui->tabOtherInfo->bindSysPara(para);
ui->tabTriggerMode->bindSysPara(para);
ui->tabSystemManage->bindSysPara(para);
ui->tabPicEdit->bindSysPara(para);
ui->tabNetworkManager->bindSysPara(para);
//---------------------------------------------------------------------------
// byons电压调整部分
voltePara25DotsDlg = nullptr;
no73VolteParaDlg = nullptr;
if (sysPara && sysPara->devOp) {
#ifdef ENB_VOLTAGE_ADJUST_NO72
voltePara25DotsDlg = new DlgVoltePara25Dots(sysPara->devOp, this);
voltePara25DotsDlg->setWindowFlags(Qt::Widget);
voltePara25DotsDlg->setAttribute(Qt::WA_DeleteOnClose, false);
voltePara25DotsDlg->bindSysPara(sysPara);
voltePara25DotsDlg->onBtnLoadClicked();
insertTab(1, voltePara25DotsDlg, tr("电压调整No72"));
#endif
#ifdef ENB_VOLTAGE_ADJUST_NO73
no73VolteParaDlg = new DlgVolteParaNo73(sysPara->devOp, this);
no73VolteParaDlg->setWindowFlags(Qt::Widget);
no73VolteParaDlg->setAttribute(Qt::WA_DeleteOnClose, false);
no73VolteParaDlg->bindSysPara(sysPara);
no73VolteParaDlg->onBtnLoadClicked();
insertTab(1, no73VolteParaDlg, tr("电压调整No73"));
#endif
}
//end voltage---------------------------------------------------------------------------
ui->tabSystemManage->loadKeyBoardType();
//以下两个信号要在(ui->tabMainWindow->updateSysParaToUI();)之前绑定,否则获取不到文本框的更新值
connect (ui->tabTriggerMode,SIGNAL(autoUpdateFontWidthByTriggerCtrl(const unsigned int)),ui->tabPrintSetting,SLOT(autoUpdateFontWidth(const unsigned int)));
connect (ui->tabMainWindow,SIGNAL(autoUpdateFontWidthByMainWindow(const unsigned int)),ui->tabPrintSetting,SLOT(autoUpdateFontWidth(const unsigned int)));
connect(ui->tabMainWindow,SIGNAL(readFPGAVersionReady()),ui->tabPrintSetting,SLOT(getFpgaVersionSetDisable()));
ui->tabMainWindow->updateSysParaToUI();
ui->tabPrintSetting->updateSysParaToUI();
ui->tabSystemSetting->updateSysParaToUI();
ui->tabOtherInfo->updateSysParaToUI();
ui->tabTriggerMode->updateSysParaToUI();
dlgShowMsg =new DlgShowMsg;
dlgShowMsg->hide();
#ifdef __RFID_CARD
initRFIDManager();
#endif
timer = new QTimer();
connect(timer, SIGNAL(timeout()), this, SLOT(timerHandler()));
timer->start(10);
qDebug()<<"timer status:"<<timer->isActive();
viscosity_timer = new QTimer();
connect(viscosity_timer, SIGNAL(timeout()), this, SLOT(viscosity_timerHandler()));
if(sysPara->para.gearPumpEnable)
{
pushButtonStartFlag = true;
}
connect(this,SIGNAL(currentChanged(int)),this,SLOT(onInkJetPrinterCurrentChanged(int)));
connect(this,SIGNAL(setReclaimTankCurrentPos(int)),ui->tabMainWindow,SLOT(onReclainTankPositionChanged(int)));
connect(this,SIGNAL(reclaimTankCloseDone()),ui->tabMainWindow,SLOT(checkForPowerOff()));
connect(this,SIGNAL(reclaimTankBlock()),this,SLOT(onReclaimTankBlock()));
connect(ui->tabPrintSetting,SIGNAL(authChanged(int)),this,SLOT(onAuthChanged(int)));
connect (this,SIGNAL(sendPicScene(PicScene*)),ui->tabPrintSetting,SLOT(updateUIForSpecialCondition(PicScene*)));
connect(ui->tabPrintSetting,SIGNAL(authChanged(int)),ui->tabOtherInfo,SLOT(onAuthChanged(int)));
//test
connect(ui->tabMainWindow,SIGNAL(InkjetCleanUP()),ui->tabSystemSetting,SLOT(on_pushButtonCleanUP_pressed()));
connect(ui->tabMainWindow,SIGNAL(clearPressureFault()),this,SLOT(resetPressureCnt()));
connect(ui->tabSystemSetting,SIGNAL(pressureAdjust()),this,SLOT(pressureAdjustForsystemseeting()));
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
connect(this,SIGNAL(updateCnt1GroupDisp(bool)),
ui->tabPrintSetting,SLOT(onUpdateCnt1GroupDisp(bool)));
#endif
initCntGroup();
msgtest = new QMessageBox(this);
connect(msgtest, SIGNAL(finished(int)), this, SLOT(OnFinished(int)));
msgBox1 = new QMessageBox(this);
connect(msgBox1, SIGNAL(finished(int)), this, SLOT(OnBoxFinished(int)));
connect(ui->tabPrintSetting->dlgInputAddr,SIGNAL(printErrorStatus(QString,unsigned int)),this,SLOT(onPrintErrorStatus(QString,unsigned int)));//
connect(ui->tabSystemSetting,SIGNAL(changeEditMode(int)),this,SLOT(onchangeEditMode(int)));
connect(ui->tabSystemSetting,SIGNAL(setRunStatus(QString )),ui->tabMainWindow,SLOT(setRunStatus(QString)));
connect(ui->tabPrintSetting->dlgInputAddr,SIGNAL(changeMac(QString)),ui->tabMainWindow,SLOT(UpdateUIVersion()));
connect(ui->tabSystemManage,SIGNAL(enableReclaimButton(bool)),ui->tabMainWindow,SLOT(onEnableReclaimCtrlButton(bool)));
connect(ui->tabSystemManage,SIGNAL(configChanged(void)),this,SLOT(onConfigChanged(void)));
connect(ui->tabPrintSetting, SIGNAL(change_OutputPulse()), ui->tabTriggerMode, SLOT(OutputPulse()));
connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabPrintSetting,SLOT( PrintupdateSysParaToUI() ));
connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabSystemSetting,SLOT( SystemupdateSysParaToUI() ));
connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabOtherInfo,SLOT( OtherupdateSysParaToUI() ));
connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabTriggerMode,SLOT( TriggerupdateSysParaToUI() ));
connect (ui->tabMainWindow,SIGNAL(openFileChange()),ui->tabMainWindow->getTexteditOption(),SLOT( updateSysParaToZero() ));
connect (ui->tabMainWindow,SIGNAL(setMainTabNow(int)),this,SLOT(setCurrentIndex(int)));
//if(sysPara->para.EditMode==PICFILE){
connect(ui->tabPrintSetting,SIGNAL(authChanged(int)),ui->tabPicEdit,SLOT(updateAuthorization(int)));// 字库编辑使能
connect (ui->tabPicEdit,SIGNAL(setMainTabNow(int)),this,SLOT(setCurrentIndex(int)));
connect (ui->tabPicEdit ,SIGNAL(openCurrentFile (QString ,bool )),ui->tabMainWindow,SLOT(openPicFIleOpen(QString ,bool )));
connect (ui->tabMainWindow,SIGNAL(openCurrFile(QString)),ui->tabPicEdit,SLOT( EditCurrFile(QString)));
connect (ui->tabPicEdit ,SIGNAL(setMainTabEdit (int)),ui->tabMainWindow,SLOT(SetMainTabEdit(int)));
//}
//connect (ui->tabPrintSetting,SIGNAL(setMainTabNow(int)),this,SLOT(setCurrentIndex(int)));
connect (ui->tabMainWindow,SIGNAL(openCurrFile(QString)),this,SLOT(onChangeTab(QString)));
connect(ui->tabPrintSetting,SIGNAL(checkPrintIntervalSignal()),ui->tabMainWindow,SLOT(checkPrintingInterval()));
connect(ui->tabTriggerMode,SIGNAL(checkPrintIntervalSignal()),ui->tabMainWindow,SLOT(checkPrintingInterval()));
connect (ui->tabMainWindow,SIGNAL(CloseJd()),this,SLOT(close_jd_timer()));
connect (ui->tabMainWindow,SIGNAL(pushButtonStartPressed(bool)),this,SLOT(handlePushButtonStartPressed(bool)));
connect (ui->tabMainWindow,SIGNAL(repeatInitedPid()),this,SLOT(handleInitedPID()));
connect (ui->tabMainWindow,SIGNAL(setCNT1Select(bool)),ui->tabPrintSetting,SLOT(setCNT1BackColor(bool)));
connect (ui->tabMainWindow,SIGNAL(setCNT2Select(bool)),ui->tabPrintSetting,SLOT(setCNT2BackColor(bool)));
connect (ui->tabMainWindow,SIGNAL(setCNT3Select(bool)),ui->tabPrintSetting,SLOT(setCNT3BackColor(bool)));
connect(ui->tabMainWindow,SIGNAL(setDisableAll()),this,SLOT(disableTabClick()));
connect(ui->tabPrintSetting,SIGNAL(engineerMode(bool)),ui->tabSystemManage,SLOT(engieerModeAcceptSystemManage(bool)));
connect(ui->tabPrintSetting, SIGNAL(engineerMode(bool)), ui->tabSystemSetting, SLOT(setFreqFixVisible(bool)));
sysPara->status.rWarnViscoReady=0;
// hlp: 260608: 以授权为标准，不过度开放权限
onAuthChanged(AUTH_NONE);
// onAuthChanged(AUTH_NONE | AUTH_SUPER_USER2 |AUTH_DISPLAY_SYSTEM_SETTING| 0xffff);
sysPara->status.WorkTimeOut=0;
ui->tabMainWindow->changeEditMode(0);
emit onchangeEditMode(0); // 20140912
sysPara->devOp->printCtrl( PRINT_CTRL_STOP);
#ifdef MYTEST
onAuthChanged(AUTH_NONE | AUTH_SUPER_USER2 |AUTH_DISPLAY_SYSTEM_SETTING| 0xffff);
#else
ui->tabMainWindow->on_pushButtonReclaimTankClose_pressed();
#endif
sysPara->status.viscosityFaultCnt=0;
setCurrentIndex(0);
sysPara->status.updateSoftEN=0;
sysPara->status.adjHightVolInitEN=0;
sysPara->status.FileChangeRestCntFlag=0;
sysPara->status.HVFaultCloseEn=0;
sysPara->devOp->printCtrl( PRINT_CTRL_STOP);
sysPara->devOp->writeFpgaCalandar(1);
//qDebug()<<sysPara->para.calandar_and_dat.year;
sysPara->status.cnt1GroupRunningIndex=0;
//sysPara->status.cnt1RepeatCurrent=0;
sysPara->status.cnt1GroupCurrentLoop=0;
//JSON data
connect(ui->tabNetworkManager, SIGNAL(updateJSONData()), ui->tabMainWindow, SLOT(JSON_UpdateDATA()), Qt::QueuedConnection);
connect(ui->tabNetworkManager,SIGNAL(net_stopPrint()),ui->tabMainWindow,SLOT(on_pushButtonStopPrint_pressed()), Qt::QueuedConnection);
connect(ui->tabMainWindow,SIGNAL(getJSONData()),ui->tabNetworkManager,SLOT(on_GetJsonpushButton_clicked()), Qt::QueuedConnection);
connect(ui->tabNetworkManager,SIGNAL(OpenNewFile()),ui->tabMainWindow->getTexteditOption(),SLOT(onOpenNewFile()), Qt::QueuedConnection);
//JSON data
#ifdef MODBUS
modbus = NULL;
memset((uint8_t *)&sysPara->modbusParas, 0, sizeof(sysPara->modbusParas));
sysPara->modbusStatus.receiveEnbleFlag = 1;
snprintf((char *)sysPara->modbusParas.selectFileName, sizeof(sysPara->modbusParas.selectFileName), "%s",QFileInfo(sysPara->para.lastOpenedFileName).fileName().toLatin1().constData());
modbus = new ModbusTcp(&sysPara->modbusParas, &sysPara->modbusStatus);
m_thread = new QThread();
modbus->moveToThread(m_thread);
connect(m_thread, SIGNAL(started()),modbus,SLOT(pvPollingThread()));
connect(modbus, SIGNAL(updateQRcode()), ui->tabMainWindow, SLOT(modbusUpdateQRCode()), Qt::QueuedConnection);
connect(modbus, SIGNAL(openFile(QString,bool)), ui->tabMainWindow->getTexteditOption(), SLOT(onFileOpen(QString,bool)), Qt::QueuedConnection);
connect(modbus, SIGNAL(startPrint()), ui->tabMainWindow, SLOT(on_pushButtonStartPrint_pressed()), Qt::QueuedConnection);
connect(modbus, SIGNAL(pausePrint()), ui->tabMainWindow, SLOT(on_pushButtonPausePrint_pressed()), Qt::QueuedConnection);//暂时屏蔽排除问题
connect(modbus,SIGNAL(stopPrint()),ui->tabMainWindow,SLOT(on_pushButtonStopPrint_pressed()), Qt::QueuedConnection);
connect(modbus,SIGNAL(writeCalendar()),this,SLOT(onModbusWriteCalendar()), Qt::QueuedConnection);
connect(modbus,SIGNAL(writeCalendar1()),this,SLOT(onModbusWriteCalendar1CurrValue()), Qt::QueuedConnection);
connect(modbus,SIGNAL(writeCalendar1EndValue()),this,SLOT(onModbusWriteCalendar1EndValue()), Qt::QueuedConnection);
connect(modbus,SIGNAL(writeCalendar2EndValue()),this,SLOT(onModbusWriteCalendar2EndValue()), Qt::QueuedConnection);
connect(modbus,SIGNAL(writeCalendar2RepeatValue()),this,SLOT(onModbusWriteCalendar2RepeatValue()), Qt::QueuedConnection);
connect(modbus,SIGNAL(writeCalendar2InitValue()),this,SLOT(onModbusWriteCalendar2InitValue()), Qt::QueuedConnection);
connect(modbus,SIGNAL(CNTResetNow()),ui->tabMainWindow,SLOT(onModbusCNTResetNowPressed()), Qt::QueuedConnection);
connect(modbus,SIGNAL(faultResume()),ui->tabMainWindow,SLOT(onLabelFaultRusumePressed()), Qt::QueuedConnection);
connect(modbus,SIGNAL(mbLineAndCharSpace(int, int)),ui->tabMainWindow->getTexteditOption(),SLOT(onMbSetLineAndChar(int, int)), Qt::QueuedConnection);
connect(this,SIGNAL(updataPara2UI()),ui->tabPrintSetting,SLOT( PrintupdateSysParaToUI() ), Qt::QueuedConnection);
connect(this, SIGNAL(openFile(QString,bool)), ui->tabMainWindow->getTexteditOption(), SLOT(onFileOpen(QString,bool)), Qt::QueuedConnection);
connect(this, SIGNAL(startPrint()), ui->tabMainWindow, SLOT(on_pushButtonStartPrint_pressed()), Qt::QueuedConnection);
#endif
ui->tabMainWindow->enableReclaimCtrlButton(false);
//edit@12-14
connect(this,SIGNAL(currentChanged(int)),ui->tabMainWindow,SLOT(onInkJetPrinterCurrentChanged(int)), Qt::QueuedConnection);
//pidControllerInit();
PID_init();
removeTab(indexOf(ui->tabDacAdjust));
removeTab(indexOf(ui->tabFpgaDebug));
ui->tabWidget->removeTab(ui->tabWidget->indexOf(ui->tab_3));
ui->vol0SpinBox->setMinimum(0);
ui->vol1SpinBox->setMinimum(0);
ui->vol2SpinBox->setMinimum(0);
ui->vol3SpinBox->setMinimum(0);
ui->vol4SpinBox->setMinimum(0);
ui->vol5SpinBox->setMinimum(0);
ui->vol6SpinBox->setMinimum(0);
ui->vol7SpinBox->setMinimum(0);
ui->vol8SpinBox->setMinimum(0);
ui->vol9SpinBox->setMinimum(0);
ui->vol10SpinBox->setMinimum(0);
ui->vol11SpinBox->setMinimum(0);
ui->vol12SpinBox->setMinimum(0);
ui->vol13SpinBox->setMinimum(0);
ui->vol14SpinBox->setMinimum(0);
ui->vol15SpinBox->setMinimum(0);
ui->vol16SpinBox->setMinimum(0);
ui->vol17SpinBox->setMinimum(0);
ui->vol18SpinBox->setMinimum(0);
ui->vol19SpinBox->setMinimum(0);
ui->vol20SpinBox->setMinimum(0);
ui->vol21SpinBox->setMinimum(0);
ui->vol22SpinBox->setMinimum(0);
ui->vol23SpinBox->setMinimum(0);
ui->vol24SpinBox->setMinimum(0);
ui->vol25SpinBox->setMinimum(0);
ui->vol26SpinBox->setMinimum(0);
ui->vol27SpinBox->setMinimum(0);
ui->vol28SpinBox->setMinimum(0);
ui->vol29SpinBox->setMinimum(0);
ui->vol30SpinBox->setMinimum(0);
ui->vol31SpinBox->setMinimum(0);
ui->vol32SpinBox->setMinimum(0);
ui->vol33SpinBox->setMinimum(0);
ui->vol34SpinBox->setMinimum(0);
ui->vol35SpinBox->setMinimum(0);
ui->vol36SpinBox->setMinimum(0);
ui->vol37SpinBox->setMinimum(0);
ui->vol38SpinBox->setMinimum(0);
ui->vol39SpinBox->setMinimum(0);
ui->vol0SpinBox->setMaximum(MAX_VOL);
ui->vol1SpinBox->setMaximum(MAX_VOL);
ui->vol2SpinBox->setMaximum(MAX_VOL);
ui->vol3SpinBox->setMaximum(MAX_VOL);
ui->vol4SpinBox->setMaximum(MAX_VOL);
ui->vol5SpinBox->setMaximum(MAX_VOL);
ui->vol6SpinBox->setMaximum(MAX_VOL);
ui->vol7SpinBox->setMaximum(MAX_VOL);
ui->vol8SpinBox->setMaximum(MAX_VOL);
ui->vol9SpinBox->setMaximum(MAX_VOL);
ui->vol10SpinBox->setMaximum(MAX_VOL);
ui->vol11SpinBox->setMaximum(MAX_VOL);
ui->vol12SpinBox->setMaximum(MAX_VOL);
ui->vol13SpinBox->setMaximum(MAX_VOL);
ui->vol14SpinBox->setMaximum(MAX_VOL);
ui->vol15SpinBox->setMaximum(MAX_VOL);
ui->vol16SpinBox->setMaximum(MAX_VOL);
ui->vol17SpinBox->setMaximum(MAX_VOL);
ui->vol18SpinBox->setMaximum(MAX_VOL);
ui->vol19SpinBox->setMaximum(MAX_VOL);
ui->vol20SpinBox->setMaximum(MAX_VOL);
ui->vol21SpinBox->setMaximum(MAX_VOL);
ui->vol22SpinBox->setMaximum(MAX_VOL);
ui->vol23SpinBox->setMaximum(MAX_VOL);
ui->vol24SpinBox->setMaximum(MAX_VOL);
ui->vol25SpinBox->setMaximum(MAX_VOL);
ui->vol26SpinBox->setMaximum(MAX_VOL);
ui->vol27SpinBox->setMaximum(MAX_VOL);
ui->vol28SpinBox->setMaximum(MAX_VOL);
ui->vol29SpinBox->setMaximum(MAX_VOL);
ui->vol30SpinBox->setMaximum(MAX_VOL);
ui->vol31SpinBox->setMaximum(MAX_VOL);
ui->vol32SpinBox->setMaximum(MAX_VOL);
ui->vol33SpinBox->setMaximum(MAX_VOL);
ui->vol34SpinBox->setMaximum(MAX_VOL);
ui->vol35SpinBox->setMaximum(MAX_VOL);
ui->vol36SpinBox->setMaximum(MAX_VOL);
ui->vol37SpinBox->setMaximum(MAX_VOL);
ui->vol38SpinBox->setMaximum(MAX_VOL);
ui->vol39SpinBox->setMaximum(MAX_VOL);
ui->fvol0SpinBox->setMinimum(0);
ui->fvol1SpinBox->setMinimum(0);
ui->fvol2SpinBox->setMinimum(0);
ui->fvol3SpinBox->setMinimum(0);
ui->fvol4SpinBox->setMinimum(0);
ui->fvol5SpinBox->setMinimum(0);
ui->fvol6SpinBox->setMinimum(0);
ui->fvol7SpinBox->setMinimum(0);
ui->fvol8SpinBox->setMinimum(0);
ui->fvol9SpinBox->setMinimum(0);
ui->fvol10SpinBox->setMinimum(0);
ui->fvol11SpinBox->setMinimum(0);
ui->fvol12SpinBox->setMinimum(0);
ui->fvol13SpinBox->setMinimum(0);
ui->fvol14SpinBox->setMinimum(0);
ui->fvol15SpinBox->setMinimum(0);
ui->fvol16SpinBox->setMinimum(0);
ui->fvol17SpinBox->setMinimum(0);
ui->fvol18SpinBox->setMinimum(0);
ui->fvol19SpinBox->setMinimum(0);
ui->fvol20SpinBox->setMinimum(0);
ui->fvol21SpinBox->setMinimum(0);
ui->fvol22SpinBox->setMinimum(0);
ui->fvol23SpinBox->setMinimum(0);
ui->fvol24SpinBox->setMinimum(0);
ui->fvol25SpinBox->setMinimum(0);
ui->fvol26SpinBox->setMinimum(0);
ui->fvol27SpinBox->setMinimum(0);
ui->fvol28SpinBox->setMinimum(0);
ui->fvol29SpinBox->setMinimum(0);
ui->fvol30SpinBox->setMinimum(0);
ui->fvol31SpinBox->setMinimum(0);
ui->fvol32SpinBox->setMinimum(0);
ui->fvol33SpinBox->setMinimum(0);
ui->fvol34SpinBox->setMinimum(0);
ui->fvol35SpinBox->setMinimum(0);
ui->fvol36SpinBox->setMinimum(0);
ui->fvol37SpinBox->setMinimum(0);
ui->fvol38SpinBox->setMinimum(0);
ui->fvol39SpinBox->setMinimum(0);
ui->fvol0SpinBox->setMaximum(MAX_VOL);
ui->fvol1SpinBox->setMaximum(MAX_VOL);
ui->fvol2SpinBox->setMaximum(MAX_VOL);
ui->fvol3SpinBox->setMaximum(MAX_VOL);
ui->fvol4SpinBox->setMaximum(MAX_VOL);
ui->fvol5SpinBox->setMaximum(MAX_VOL);
ui->fvol6SpinBox->setMaximum(MAX_VOL);
ui->fvol7SpinBox->setMaximum(MAX_VOL);
ui->fvol8SpinBox->setMaximum(MAX_VOL);
ui->fvol9SpinBox->setMaximum(MAX_VOL);
ui->fvol10SpinBox->setMaximum(MAX_VOL);
ui->fvol11SpinBox->setMaximum(MAX_VOL);
ui->fvol12SpinBox->setMaximum(MAX_VOL);
ui->fvol13SpinBox->setMaximum(MAX_VOL);
ui->fvol14SpinBox->setMaximum(MAX_VOL);
ui->fvol15SpinBox->setMaximum(MAX_VOL);
ui->fvol16SpinBox->setMaximum(MAX_VOL);
ui->fvol17SpinBox->setMaximum(MAX_VOL);
ui->fvol18SpinBox->setMaximum(MAX_VOL);
ui->fvol19SpinBox->setMaximum(MAX_VOL);
ui->fvol20SpinBox->setMaximum(MAX_VOL);
ui->fvol21SpinBox->setMaximum(MAX_VOL);
ui->fvol22SpinBox->setMaximum(MAX_VOL);
ui->fvol23SpinBox->setMaximum(MAX_VOL);
ui->fvol24SpinBox->setMaximum(MAX_VOL);
ui->fvol25SpinBox->setMaximum(MAX_VOL);
ui->fvol26SpinBox->setMaximum(MAX_VOL);
ui->fvol27SpinBox->setMaximum(MAX_VOL);
ui->fvol28SpinBox->setMaximum(MAX_VOL);
ui->fvol29SpinBox->setMaximum(MAX_VOL);
ui->fvol30SpinBox->setMaximum(MAX_VOL);
ui->fvol31SpinBox->setMaximum(MAX_VOL);
ui->fvol32SpinBox->setMaximum(MAX_VOL);
ui->fvol33SpinBox->setMaximum(MAX_VOL);
ui->fvol34SpinBox->setMaximum(MAX_VOL);
ui->fvol35SpinBox->setMaximum(MAX_VOL);
ui->fvol36SpinBox->setMaximum(MAX_VOL);
ui->fvol37SpinBox->setMaximum(MAX_VOL);
ui->fvol38SpinBox->setMaximum(MAX_VOL);
ui->fvol39SpinBox->setMaximum(MAX_VOL);
ui->cVol0SpinBox->setMinimum(0);
ui->cVol1SpinBox->setMinimum(0);
ui->cVol2SpinBox->setMinimum(0);
ui->cVol3SpinBox->setMinimum(0);
ui->cVol4SpinBox->setMinimum(0);
ui->cVol5SpinBox->setMinimum(0);
ui->cVol6SpinBox->setMinimum(0);
ui->cVol7SpinBox->setMinimum(0);
ui->cVol8SpinBox->setMinimum(0);
ui->cVol9SpinBox->setMinimum(0);
ui->cVol10SpinBox->setMinimum(0);
ui->cVol11SpinBox->setMinimum(0);
ui->cVol12SpinBox->setMinimum(0);
ui->cVol13SpinBox->setMinimum(0);
ui->cVol14SpinBox->setMinimum(0);
ui->cVol15SpinBox->setMinimum(0);
ui->cVol16SpinBox->setMinimum(0);
ui->cVol17SpinBox->setMinimum(0);
ui->cVol18SpinBox->setMinimum(0);
ui->cVol19SpinBox->setMinimum(0);
ui->cVol20SpinBox->setMinimum(0);
ui->cVol21SpinBox->setMinimum(0);
ui->cVol22SpinBox->setMinimum(0);
ui->cVol23SpinBox->setMinimum(0);
ui->cVol24SpinBox->setMinimum(0);
ui->cVol25SpinBox->setMinimum(0);
ui->cVol26SpinBox->setMinimum(0);
ui->cVol27SpinBox->setMinimum(0);
ui->cVol28SpinBox->setMinimum(0);
ui->cVol29SpinBox->setMinimum(0);
ui->cVol30SpinBox->setMinimum(0);
ui->cVol31SpinBox->setMinimum(0);
ui->cVol32SpinBox->setMinimum(0);
ui->cVol33SpinBox->setMinimum(0);
ui->cVol34SpinBox->setMinimum(0);
ui->cVol35SpinBox->setMinimum(0);
ui->cVol36SpinBox->setMinimum(0);
ui->cVol37SpinBox->setMinimum(0);
ui->cVol38SpinBox->setMinimum(0);
ui->cVol39SpinBox->setMinimum(0);
ui->cVol0SpinBox->setMaximum(MAX_VOL);
ui->cVol1SpinBox->setMaximum(MAX_VOL);
ui->cVol2SpinBox->setMaximum(MAX_VOL);
ui->cVol3SpinBox->setMaximum(MAX_VOL);
ui->cVol4SpinBox->setMaximum(MAX_VOL);
ui->cVol5SpinBox->setMaximum(MAX_VOL);
ui->cVol6SpinBox->setMaximum(MAX_VOL);
ui->cVol7SpinBox->setMaximum(MAX_VOL);
ui->cVol8SpinBox->setMaximum(MAX_VOL);
ui->cVol9SpinBox->setMaximum(MAX_VOL);
ui->cVol10SpinBox->setMaximum(MAX_VOL);
ui->cVol11SpinBox->setMaximum(MAX_VOL);
ui->cVol12SpinBox->setMaximum(MAX_VOL);
ui->cVol13SpinBox->setMaximum(MAX_VOL);
ui->cVol14SpinBox->setMaximum(MAX_VOL);
ui->cVol15SpinBox->setMaximum(MAX_VOL);
ui->cVol16SpinBox->setMaximum(MAX_VOL);
ui->cVol17SpinBox->setMaximum(MAX_VOL);
ui->cVol18SpinBox->setMaximum(MAX_VOL);
ui->cVol19SpinBox->setMaximum(MAX_VOL);
ui->cVol20SpinBox->setMaximum(MAX_VOL);
ui->cVol21SpinBox->setMaximum(MAX_VOL);
ui->cVol22SpinBox->setMaximum(MAX_VOL);
ui->cVol23SpinBox->setMaximum(MAX_VOL);
ui->cVol24SpinBox->setMaximum(MAX_VOL);
ui->cVol25SpinBox->setMaximum(MAX_VOL);
ui->cVol26SpinBox->setMaximum(MAX_VOL);
ui->cVol27SpinBox->setMaximum(MAX_VOL);
ui->cVol28SpinBox->setMaximum(MAX_VOL);
ui->cVol29SpinBox->setMaximum(MAX_VOL);
ui->cVol30SpinBox->setMaximum(MAX_VOL);
ui->cVol31SpinBox->setMaximum(MAX_VOL);
ui->cVol32SpinBox->setMaximum(MAX_VOL);
ui->cVol33SpinBox->setMaximum(MAX_VOL);
ui->cVol34SpinBox->setMaximum(MAX_VOL);
ui->cVol35SpinBox->setMaximum(MAX_VOL);
ui->cVol36SpinBox->setMaximum(MAX_VOL);
ui->cVol37SpinBox->setMaximum(MAX_VOL);
ui->cVol38SpinBox->setMaximum(MAX_VOL);
ui->cVol39SpinBox->setMaximum(MAX_VOL);
loadVoltageValue();
connect(ui->savePushButton,SIGNAL(clicked()), this,SLOT( DacAdjustStore()));
sysPara->status.statWarn = sysPara->status.statWarn | WARN_STATUS_INK_WARN; //先置墨水标示为1
sleep(3);
qApp->installEventFilter(this);
}
void InkJetPrinter::loadVoltageValue()
{
ui->vol0SpinBox->setValue(sysPara->para.printed_adj_dac[0]);
ui->vol1SpinBox->setValue(sysPara->para.printed_adj_dac[1]);
ui->vol2SpinBox->setValue(sysPara->para.printed_adj_dac[2]);
ui->vol3SpinBox->setValue(sysPara->para.printed_adj_dac[3]);
ui->vol4SpinBox->setValue(sysPara->para.printed_adj_dac[4]);
ui->vol5SpinBox->setValue(sysPara->para.printed_adj_dac[5]);
ui->vol6SpinBox->setValue(sysPara->para.printed_adj_dac[6]);
ui->vol7SpinBox->setValue(sysPara->para.printed_adj_dac[7]);
ui->vol8SpinBox->setValue(sysPara->para.printed_adj_dac[8]);
ui->vol9SpinBox->setValue(sysPara->para.printed_adj_dac[9]);
ui->vol10SpinBox->setValue(sysPara->para.printed_adj_dac[10]);
ui->vol11SpinBox->setValue(sysPara->para.printed_adj_dac[11]);
ui->vol12SpinBox->setValue(sysPara->para.printed_adj_dac[12]);
ui->vol13SpinBox->setValue(sysPara->para.printed_adj_dac[13]);
ui->vol14SpinBox->setValue(sysPara->para.printed_adj_dac[14]);
ui->vol15SpinBox->setValue(sysPara->para.printed_adj_dac[15]);
ui->vol16SpinBox->setValue(sysPara->para.printed_adj_dac[16]);
ui->vol17SpinBox->setValue(sysPara->para.printed_adj_dac[17]);
ui->vol18SpinBox->setValue(sysPara->para.printed_adj_dac[18]);
ui->vol19SpinBox->setValue(sysPara->para.printed_adj_dac[19]);
ui->vol20SpinBox->setValue(sysPara->para.printed_adj_dac[20]);
ui->vol21SpinBox->setValue(sysPara->para.printed_adj_dac[21]);
ui->vol22SpinBox->setValue(sysPara->para.printed_adj_dac[22]);
ui->vol23SpinBox->setValue(sysPara->para.printed_adj_dac[23]);
ui->vol24SpinBox->setValue(sysPara->para.printed_adj_dac[24]);
ui->vol25SpinBox->setValue(sysPara->para.printed_adj_dac[25]);
ui->vol26SpinBox->setValue(sysPara->para.printed_adj_dac[26]);
ui->vol27SpinBox->setValue(sysPara->para.printed_adj_dac[27]);
ui->vol28SpinBox->setValue(sysPara->para.printed_adj_dac[28]);
ui->vol29SpinBox->setValue(sysPara->para.printed_adj_dac[29]);
ui->vol30SpinBox->setValue(sysPara->para.printed_adj_dac[30]);
ui->vol31SpinBox->setValue(sysPara->para.printed_adj_dac[31]);
ui->vol32SpinBox->setValue(sysPara->para.printed_adj_dac[32]);
ui->vol33SpinBox->setValue(sysPara->para.printed_adj_dac[33]);
ui->vol34SpinBox->setValue(sysPara->para.printed_adj_dac[34]);
ui->vol35SpinBox->setValue(sysPara->para.printed_adj_dac[35]);
ui->vol36SpinBox->setValue(sysPara->para.printed_adj_dac[36]);
ui->vol37SpinBox->setValue(sysPara->para.printed_adj_dac[37]);
ui->vol38SpinBox->setValue(sysPara->para.printed_adj_dac[38]);
ui->vol39SpinBox->setValue(sysPara->para.printed_adj_dac[39]);
ui->cVol0SpinBox->setValue(sysPara->para.printed_continue_col_dac[0]);
ui->cVol1SpinBox->setValue(sysPara->para.printed_continue_col_dac[1]);
ui->cVol2SpinBox->setValue(sysPara->para.printed_continue_col_dac[2]);
ui->cVol3SpinBox->setValue(sysPara->para.printed_continue_col_dac[3]);
ui->cVol4SpinBox->setValue(sysPara->para.printed_continue_col_dac[4]);
ui->cVol5SpinBox->setValue(sysPara->para.printed_continue_col_dac[5]);
ui->cVol6SpinBox->setValue(sysPara->para.printed_continue_col_dac[6]);
ui->cVol7SpinBox->setValue(sysPara->para.printed_continue_col_dac[7]);
ui->cVol8SpinBox->setValue(sysPara->para.printed_continue_col_dac[8]);
ui->cVol9SpinBox->setValue(sysPara->para.printed_continue_col_dac[9]);
ui->cVol10SpinBox->setValue(sysPara->para.printed_continue_col_dac[10]);
ui->cVol11SpinBox->setValue(sysPara->para.printed_continue_col_dac[11]);
ui->cVol12SpinBox->setValue(sysPara->para.printed_continue_col_dac[12]);
ui->cVol13SpinBox->setValue(sysPara->para.printed_continue_col_dac[13]);
ui->cVol14SpinBox->setValue(sysPara->para.printed_continue_col_dac[14]);
ui->cVol15SpinBox->setValue(sysPara->para.printed_continue_col_dac[15]);
ui->cVol16SpinBox->setValue(sysPara->para.printed_continue_col_dac[16]);
ui->cVol17SpinBox->setValue(sysPara->para.printed_continue_col_dac[17]);
ui->cVol18SpinBox->setValue(sysPara->para.printed_continue_col_dac[18]);
ui->cVol19SpinBox->setValue(sysPara->para.printed_continue_col_dac[19]);
ui->cVol20SpinBox->setValue(sysPara->para.printed_continue_col_dac[20]);
ui->cVol21SpinBox->setValue(sysPara->para.printed_continue_col_dac[21]);
ui->cVol22SpinBox->setValue(sysPara->para.printed_continue_col_dac[22]);
ui->cVol23SpinBox->setValue(sysPara->para.printed_continue_col_dac[23]);
ui->cVol24SpinBox->setValue(sysPara->para.printed_continue_col_dac[24]);
ui->cVol25SpinBox->setValue(sysPara->para.printed_continue_col_dac[25]);
ui->cVol26SpinBox->setValue(sysPara->para.printed_continue_col_dac[26]);
ui->cVol27SpinBox->setValue(sysPara->para.printed_continue_col_dac[27]);
ui->cVol28SpinBox->setValue(sysPara->para.printed_continue_col_dac[28]);
ui->cVol29SpinBox->setValue(sysPara->para.printed_continue_col_dac[29]);
ui->cVol30SpinBox->setValue(sysPara->para.printed_continue_col_dac[30]);
ui->cVol31SpinBox->setValue(sysPara->para.printed_continue_col_dac[31]);
ui->cVol32SpinBox->setValue(sysPara->para.printed_continue_col_dac[32]);
ui->cVol33SpinBox->setValue(sysPara->para.printed_continue_col_dac[33]);
ui->cVol34SpinBox->setValue(sysPara->para.printed_continue_col_dac[34]);
ui->cVol35SpinBox->setValue(sysPara->para.printed_continue_col_dac[35]);
ui->cVol36SpinBox->setValue(sysPara->para.printed_continue_col_dac[36]);
ui->cVol37SpinBox->setValue(sysPara->para.printed_continue_col_dac[37]);
ui->cVol38SpinBox->setValue(sysPara->para.printed_continue_col_dac[38]);
ui->cVol39SpinBox->setValue(sysPara->para.printed_continue_col_dac[39]);
ui->fvol0SpinBox->setValue(sysPara->para.printed_full_col_dac[0]);
ui->fvol1SpinBox->setValue(sysPara->para.printed_full_col_dac[1]);
ui->fvol2SpinBox->setValue(sysPara->para.printed_full_col_dac[2]);
ui->fvol3SpinBox->setValue(sysPara->para.printed_full_col_dac[3]);
ui->fvol4SpinBox->setValue(sysPara->para.printed_full_col_dac[4]);
ui->fvol5SpinBox->setValue(sysPara->para.printed_full_col_dac[5]);
ui->fvol6SpinBox->setValue(sysPara->para.printed_full_col_dac[6]);
ui->fvol7SpinBox->setValue(sysPara->para.printed_full_col_dac[7]);
ui->fvol8SpinBox->setValue(sysPara->para.printed_full_col_dac[8]);
ui->fvol9SpinBox->setValue(sysPara->para.printed_full_col_dac[9]);
ui->fvol10SpinBox->setValue(sysPara->para.printed_full_col_dac[10]);
ui->fvol11SpinBox->setValue(sysPara->para.printed_full_col_dac[11]);
ui->fvol12SpinBox->setValue(sysPara->para.printed_full_col_dac[12]);
ui->fvol13SpinBox->setValue(sysPara->para.printed_full_col_dac[13]);
ui->fvol14SpinBox->setValue(sysPara->para.printed_full_col_dac[14]);
ui->fvol15SpinBox->setValue(sysPara->para.printed_full_col_dac[15]);
ui->fvol16SpinBox->setValue(sysPara->para.printed_full_col_dac[16]);
ui->fvol17SpinBox->setValue(sysPara->para.printed_full_col_dac[17]);
ui->fvol18SpinBox->setValue(sysPara->para.printed_full_col_dac[18]);
ui->fvol19SpinBox->setValue(sysPara->para.printed_full_col_dac[19]);
ui->fvol20SpinBox->setValue(sysPara->para.printed_full_col_dac[20]);
ui->fvol21SpinBox->setValue(sysPara->para.printed_full_col_dac[21]);
ui->fvol22SpinBox->setValue(sysPara->para.printed_full_col_dac[22]);
ui->fvol23SpinBox->setValue(sysPara->para.printed_full_col_dac[23]);
ui->fvol24SpinBox->setValue(sysPara->para.printed_full_col_dac[24]);
ui->fvol25SpinBox->setValue(sysPara->para.printed_full_col_dac[25]);
ui->fvol26SpinBox->setValue(sysPara->para.printed_full_col_dac[26]);
ui->fvol27SpinBox->setValue(sysPara->para.printed_full_col_dac[27]);
ui->fvol28SpinBox->setValue(sysPara->para.printed_full_col_dac[28]);
ui->fvol29SpinBox->setValue(sysPara->para.printed_full_col_dac[29]);
ui->fvol30SpinBox->setValue(sysPara->para.printed_full_col_dac[30]);
ui->fvol31SpinBox->setValue(sysPara->para.printed_full_col_dac[31]);
ui->fvol32SpinBox->setValue(sysPara->para.printed_full_col_dac[32]);
ui->fvol33SpinBox->setValue(sysPara->para.printed_full_col_dac[33]);
ui->fvol34SpinBox->setValue(sysPara->para.printed_full_col_dac[34]);
ui->fvol35SpinBox->setValue(sysPara->para.printed_full_col_dac[35]);
ui->fvol36SpinBox->setValue(sysPara->para.printed_full_col_dac[36]);
ui->fvol37SpinBox->setValue(sysPara->para.printed_full_col_dac[37]);
ui->fvol38SpinBox->setValue(sysPara->para.printed_full_col_dac[38]);
ui->fvol39SpinBox->setValue(sysPara->para.printed_full_col_dac[39]);
if(sysPara->para.dacScale < 40 || sysPara->para.dacScale>150)
sysPara->para.dacScale = 100;
}
void InkJetPrinter::initCntGroup()
{
connect(this, &InkJetPrinter::sig_updateDisp,
SectionalManager::instance(), &SectionalManager::sig_updateCntGroupDisp);
}
float PID_realize(float speed);
struct _pid{
float SetSpeed;//定义设定值
float ActualSpeed;//定义实际值
float err;//定义偏差值
float err_last;//定义上一个偏差值
float Kp,Ki,Kd;//定义比例、积分、微分系数
float voltage;//定义电压值(控制执行器的变量)
float integral;//定义积分值
float integral_max; //积分限幅（根据实际调整）
}pid;
void PID_init(){
pid.SetSpeed=0.0;
pid.ActualSpeed=0.0;
pid.err=0.0;
pid.err_last=0.0;
pid.voltage=0.0;
pid.integral=0.0;
pid.Kp=0.21; //0.25
pid.Ki=0.006; //0.015
pid.Kd=0.0;
}
static float u = 1.0;
float PID_realize(float speed, float act){
unsigned char index = 1;
pid.SetSpeed=speed;
pid.ActualSpeed = act;
pid.err=pid.SetSpeed-pid.ActualSpeed;
if(u < 900)
{
pid.integral+=pid.err;
}
pid.voltage=pid.Kp*pid.err + index*pid.Ki*pid.integral + pid.Kd*(pid.err-pid.err_last);
pid.err_last=pid.err;
pid.ActualSpeed =pid.voltage*1.0;
return pid.ActualSpeed;
}
float PID_realize2(float speed, float act){
// 增量式 PID：Δu = Kp*(e[k]-e[k-1]) + Ki*e[k]
pid.Kp = 0.15f;
pid.Ki = 0.02f;
pid.Kd = 0.0f;
pid.SetSpeed = speed;
pid.ActualSpeed = act;
pid.err = pid.SetSpeed - pid.ActualSpeed;
float delta_u = pid.Kp * (pid.err - pid.err_last)
+ pid.Ki * pid.err;
// 自适应非对称限幅：
// 压力严重偏高（err < -30）：允许快速减速，限制慢速加速
// 压力严重偏低（err > 50）：允许正常加速，限制减速（避免过度降速）
// 接近目标：小步长，平稳调节
if(pid.err < -30.0f) {
if(delta_u > 1.0f) delta_u = 1.0f;
if(delta_u < -6.0f) delta_u = -6.0f;
} else if(pid.err > 50.0f) {
if(delta_u > 3.0f) delta_u = 3.0f;
if(delta_u < -2.0f) delta_u = -2.0f;
} else {
if(delta_u > 3.0f) delta_u = 3.0f;
if(delta_u < -3.0f) delta_u = -3.0f;
}
pid.err_last = pid.err;
return delta_u;
}
void InkJetPrinter::pressureAdj()
{
// 故障停机处理
if(sysPara->status.gearPumpRunStopFlag || sysPara->status.flagOfSpeedAlarm)
{
sysPara->para.gearPumpValue = 0;
u = 0.0f;
m_pumpState = DPUMP_STOPPED;
m_stateChangeCount = 0;
m_adjSkip = 0;
m_lastActualPressure = 0;
m_bufValidCount = 0;
for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
m_bufIdx = 0;
sysPara->devOp->WriteMoterPump();
return;
}
// 泵未使能时的PID控制（保持原有逻辑）
if(!sysPara->para.gearPumpEnable)
{
if(u > 0 || ((sysPara->para.pressure - sysPara->status.PRESSURE) > 0))
u = PID_realize((float)sysPara->para.pressure, (float)sysPara->status.PRESSURE);
sysPara->para.gearPumpValue = (u > 0) ? (unsigned short)u : 0;
if(sysPara->para.gearPumpValue > 800)
sysPara->para.gearPumpValue = 800;
sysPara->devOp->WriteMoterPump();
return;
}
// 隔膜泵控制参数
const int STOP_TO_START_THRESHOLD = 5; // 停止→启动：压力低于目标15（扩大滞环）
const int RUN_TO_STOP_THRESHOLD = 5; // 运行→停止：压力高于目标10（扩大滞环）
const int MIN_STATE_INTERVAL = 8; // 最小状态切换间隔：8个100ms = 800ms
int actual = sysPara->status.PRESSURE;
int target = (int)sysPara->para.pressure;
int err = target - actual; // 正值=压力偏低，负值=压力偏高
// 更新滑动平均缓冲
m_pressureBuf[m_bufIdx] = actual;
m_bufIdx = (m_bufIdx + 1) % 10;
int avgPressure = 0;
for(int i = 0; i < 10; i++) avgPressure += m_pressureBuf[i];
avgPressure /= 10;
// 状态切换计数器递增
m_stateChangeCount++;
// 检查是否允许状态切换（距上次切换>=800ms）
bool canSwitch = (m_stateChangeCount >= MIN_STATE_INTERVAL);
// 硬保护：压力严重超标，立即强制停泵（不受800ms限制）
if(actual > target + 80)
{
if(m_pumpState != DPUMP_STOPPED) {
u = 0.0f;
sysPara->para.gearPumpValue = 0;
sysPara->devOp->WriteMoterPump();
m_pumpState = DPUMP_STOPPED;
m_stateChangeCount = 0;
m_adjSkip = 0;
}
return;
}
// 状态机处理
switch(m_pumpState) {
case DPUMP_STOPPED:
handleStoppedState(err, canSwitch);
break;
case DPUMP_STARTING:
handleStartingState(err, actual, target);
break;
case DPUMP_RUNNING:
handleRunningState(err, canSwitch);
break;
}
}
// 停止状态处理：压力低于目标较多时启动泵
void InkJetPrinter::handleStoppedState(int err, bool canSwitch)
{
const int STOP_TO_START_THRESHOLD = 5; // 压力低于目标15启动（扩大滞环）
const float START_INIT_SPEED = 80.0f; // 启动初始转速
// 压力低于目标较多，且允许切换（距上次停止>=800ms），启动泵
if(err > STOP_TO_START_THRESHOLD && canSwitch) {
u = START_INIT_SPEED;
m_startingStepCount = 0;
m_adjSkip = 0;
sysPara->para.gearPumpValue = (unsigned short)(int)u;
sysPara->devOp->WriteMoterPump();
m_pumpState = DPUMP_STARTING;
m_stateChangeCount = 0; // 重置计数器
}
}
// 启动爬升状态处理：从低转速逐步提升到工作转速
void InkJetPrinter::handleStartingState(int err, int actual, int target)
{
const int STARTING_TO_RUNNING_RANGE = 30; // 进入目标±50范围转到运行状态
const float MAX_WORKING_SPEED = 350.0f; // 最大工作转速
const float START_SPEED_STEP_LARGE = 40.0f;
const float START_SPEED_STEP_MED = 30.0f;
const float START_SPEED_STEP_SMALL = 20.0f;
m_adjSkip++;
// 每800ms调整一次（8个100ms周期）
if(m_adjSkip < 8) {
sysPara->para.gearPumpValue = (unsigned short)(int)u;
sysPara->devOp->WriteMoterPump();
return;
}
m_adjSkip = 0;
// 判断是否进入运行状态
int absErr = (err >= 0) ? err : -err;
bool nearTarget = (absErr <= STARTING_TO_RUNNING_RANGE);
bool reachedMaxSpeed = (u >= MAX_WORKING_SPEED - 10);
if(nearTarget || reachedMaxSpeed) {
// 转到运行微调状态
m_pumpState = DPUMP_RUNNING;
m_lastActualPressure = actual;
m_stateChangeCount = 0; // 重置计数器
return;
}
// 继续爬升：根据误差自适应增速
float step;
if(err > 100) step = START_SPEED_STEP_LARGE;
else if(err > 50) step = START_SPEED_STEP_MED;
else step = START_SPEED_STEP_SMALL;
u += step;
if(u > MAX_WORKING_SPEED) u = MAX_WORKING_SPEED;
sysPara->para.gearPumpValue = (unsigned short)(int)u;
sysPara->devOp->WriteMoterPump();
m_startingStepCount++;
}
// 运行微调状态处理：使用增量式控制算法
void InkJetPrinter::handleRunningState(int err, bool canSwitch)
{
const int RUN_TO_STOP_THRESHOLD = 5; // 压力高于目标10准备停泵（扩大滞环）
const int EMERGENCY_STOP_THRESHOLD = 10; // 压力高于目标20立即停泵（不受800ms限制）
// 紧急停泵：压力严重超标，立即停泵（不受800ms限制）
if(err < -EMERGENCY_STOP_THRESHOLD) {
u = 0.0f;
sysPara->para.gearPumpValue = 0;
sysPara->devOp->WriteMoterPump();
m_pumpState = DPUMP_STOPPED;
m_stateChangeCount = 0;
m_adjSkip = 0;
return;
}
// 常规停泵：压力略高于目标，等待800ms后停泵
if(err < -RUN_TO_STOP_THRESHOLD && canSwitch) {
u = 0.0f;
sysPara->para.gearPumpValue = 0;
sysPara->devOp->WriteMoterPump();
m_pumpState = DPUMP_STOPPED;
m_stateChangeCount = 0;
m_adjSkip = 0;
return;
}
// === 增量式微调控制（每200ms调整一次）===
m_adjSkip++;
if(m_adjSkip < 2) {
sysPara->para.gearPumpValue = (unsigned short)(int)u;
sysPara->devOp->WriteMoterPump();
return;
}
m_adjSkip = 0;
int actual = sysPara->status.PRESSURE;
float error = (float)err;
float absErr = (error >= 0) ? error : -error;
// 死区：误差≤0.5不调整
if(absErr < 0.5f) {
m_lastActualPressure = actual;
sysPara->para.gearPumpValue = (unsigned short)(int)u;
sysPara->devOp->WriteMoterPump();
return;
}
// 计算压力变化率（微分项）
int pressureChange = actual - m_lastActualPressure;
m_lastActualPressure = actual;
// 增量式控制公式
float delta_u;
// 近目标刹车策略：误差≤5且正在接近目标，只刹车不加速
if(absErr <= 5.0f &&
((error > 0.0f && pressureChange > 0) || // 压力低且在上升
(error < 0.0f && pressureChange < 0))) // 压力高且在下降
{
delta_u = -0.20f * (float)pressureChange; // 只刹车
}
else {
// 标准增量式控制：比例项 + 微分项
delta_u = 0.05f * error - 0.20f * (float)pressureChange;
}
// 分级限幅（根据误差大小限制调节幅度）
float maxDelta;
if(absErr > 30.0f) maxDelta = 1.0f;
else if(absErr > 10.0f) maxDelta = 0.6f;
else maxDelta = 0.3f;
if(delta_u > maxDelta) delta_u = maxDelta;
if(delta_u < -maxDelta) delta_u = -maxDelta;
// 更新控制量
u += delta_u;
// 限制范围
const float MIN_RUNNING_SPEED = 30.0f; // 最低运行转速（低于此值泵不转）
const float MAX_WORKING_SPEED = 350.0f;
if(u < MIN_RUNNING_SPEED) u = MIN_RUNNING_SPEED;
if(u > MAX_WORKING_SPEED) u = MAX_WORKING_SPEED;
sysPara->para.gearPumpValue = (unsigned short)(int)u;
sysPara->devOp->WriteMoterPump();
}
void InkJetPrinter::DacAdjustStore()
{
sysPara->para.printed_adj_dac[0] = ui->vol0SpinBox->value();
sysPara->para.printed_adj_dac[1] = ui->vol1SpinBox->value();
sysPara->para.printed_adj_dac[2] = ui->vol2SpinBox->value();
sysPara->para.printed_adj_dac[3] = ui->vol3SpinBox->value();
sysPara->para.printed_adj_dac[4] = ui->vol4SpinBox->value();
sysPara->para.printed_adj_dac[5] = ui->vol5SpinBox->value();
sysPara->para.printed_adj_dac[6] = ui->vol6SpinBox->value();
sysPara->para.printed_adj_dac[7] = ui->vol7SpinBox->value();
sysPara->para.printed_adj_dac[8] = ui->vol8SpinBox->value();
sysPara->para.printed_adj_dac[9] = ui->vol9SpinBox->value();
sysPara->para.printed_adj_dac[10] = ui->vol10SpinBox->value();
sysPara->para.printed_adj_dac[11] = ui->vol11SpinBox->value();
sysPara->para.printed_adj_dac[12] = ui->vol12SpinBox->value();
sysPara->para.printed_adj_dac[13] = ui->vol13SpinBox->value();
sysPara->para.printed_adj_dac[14] = ui->vol14SpinBox->value();
sysPara->para.printed_adj_dac[15] = ui->vol15SpinBox->value();
sysPara->para.printed_adj_dac[16] = ui->vol16SpinBox->value();
sysPara->para.printed_adj_dac[17] = ui->vol17SpinBox->value();
sysPara->para.printed_adj_dac[18] = ui->vol18SpinBox->value();
sysPara->para.printed_adj_dac[19] = ui->vol19SpinBox->value();
sysPara->para.printed_adj_dac[20] = ui->vol20SpinBox->value();
sysPara->para.printed_adj_dac[21] = ui->vol21SpinBox->value();
sysPara->para.printed_adj_dac[22] = ui->vol22SpinBox->value();
sysPara->para.printed_adj_dac[23] = ui->vol23SpinBox->value();
sysPara->para.printed_adj_dac[24] = ui->vol24SpinBox->value();
sysPara->para.printed_adj_dac[25] = ui->vol25SpinBox->value();
sysPara->para.printed_adj_dac[26] = ui->vol26SpinBox->value();
sysPara->para.printed_adj_dac[27] = ui->vol27SpinBox->value();
sysPara->para.printed_adj_dac[28] = ui->vol28SpinBox->value();
sysPara->para.printed_adj_dac[29] = ui->vol29SpinBox->value();
sysPara->para.printed_adj_dac[30] = ui->vol30SpinBox->value();
sysPara->para.printed_adj_dac[31] = ui->vol31SpinBox->value();
sysPara->para.printed_adj_dac[32] = ui->vol32SpinBox->value();
sysPara->para.printed_adj_dac[33] = ui->vol33SpinBox->value();
sysPara->para.printed_adj_dac[34] = ui->vol34SpinBox->value();
sysPara->para.printed_adj_dac[35] = ui->vol35SpinBox->value();
sysPara->para.printed_adj_dac[36] = ui->vol36SpinBox->value();
sysPara->para.printed_adj_dac[37] = ui->vol37SpinBox->value();
sysPara->para.printed_adj_dac[38] = ui->vol38SpinBox->value();
sysPara->para.printed_adj_dac[39] = ui->vol39SpinBox->value();
sysPara->para.printed_continue_col_dac[0] = ui->cVol0SpinBox->value();
sysPara->para.printed_continue_col_dac[1] = ui->cVol1SpinBox->value();
sysPara->para.printed_continue_col_dac[2] = ui->cVol2SpinBox->value();
sysPara->para.printed_continue_col_dac[3] = ui->cVol3SpinBox->value();
sysPara->para.printed_continue_col_dac[4] = ui->cVol4SpinBox->value();
sysPara->para.printed_continue_col_dac[5] = ui->cVol5SpinBox->value();
sysPara->para.printed_continue_col_dac[6] = ui->cVol6SpinBox->value();
sysPara->para.printed_continue_col_dac[7] = ui->cVol7SpinBox->value();
sysPara->para.printed_continue_col_dac[8] = ui->cVol8SpinBox->value();
sysPara->para.printed_continue_col_dac[9] = ui->cVol9SpinBox->value();
sysPara->para.printed_continue_col_dac[10] = ui->cVol10SpinBox->value();
sysPara->para.printed_continue_col_dac[11] = ui->cVol11SpinBox->value();
sysPara->para.printed_continue_col_dac[12] = ui->cVol12SpinBox->value();
sysPara->para.printed_continue_col_dac[13] = ui->cVol13SpinBox->value();
sysPara->para.printed_continue_col_dac[14] = ui->cVol14SpinBox->value();
sysPara->para.printed_continue_col_dac[15] = ui->cVol15SpinBox->value();
sysPara->para.printed_continue_col_dac[16] = ui->cVol16SpinBox->value();
sysPara->para.printed_continue_col_dac[17] = ui->cVol17SpinBox->value();
sysPara->para.printed_continue_col_dac[18] = ui->cVol18SpinBox->value();
sysPara->para.printed_continue_col_dac[19] = ui->cVol19SpinBox->value();
sysPara->para.printed_continue_col_dac[20] = ui->cVol20SpinBox->value();
sysPara->para.printed_continue_col_dac[21] = ui->cVol21SpinBox->value();
sysPara->para.printed_continue_col_dac[22] = ui->cVol22SpinBox->value();
sysPara->para.printed_continue_col_dac[23] = ui->cVol23SpinBox->value();
sysPara->para.printed_continue_col_dac[24] = ui->cVol24SpinBox->value();
sysPara->para.printed_continue_col_dac[25] = ui->cVol25SpinBox->value();
sysPara->para.printed_continue_col_dac[26] = ui->cVol26SpinBox->value();
sysPara->para.printed_continue_col_dac[27] = ui->cVol27SpinBox->value();
sysPara->para.printed_continue_col_dac[28] = ui->cVol28SpinBox->value();
sysPara->para.printed_continue_col_dac[29] = ui->cVol29SpinBox->value();
sysPara->para.printed_continue_col_dac[30] = ui->cVol30SpinBox->value();
sysPara->para.printed_continue_col_dac[31] = ui->cVol31SpinBox->value();
sysPara->para.printed_continue_col_dac[32] = ui->cVol32SpinBox->value();
sysPara->para.printed_continue_col_dac[33] = ui->cVol33SpinBox->value();
sysPara->para.printed_continue_col_dac[34] = ui->cVol34SpinBox->value();
sysPara->para.printed_continue_col_dac[35] = ui->cVol35SpinBox->value();
sysPara->para.printed_continue_col_dac[36] = ui->cVol36SpinBox->value();
sysPara->para.printed_continue_col_dac[37] = ui->cVol37SpinBox->value();
sysPara->para.printed_continue_col_dac[38] = ui->cVol38SpinBox->value();
sysPara->para.printed_continue_col_dac[39] = ui->cVol39SpinBox->value();
sysPara->para.printed_full_col_dac[0] = ui->fvol0SpinBox->value();
sysPara->para.printed_full_col_dac[1] = ui->fvol1SpinBox->value();
sysPara->para.printed_full_col_dac[2] = ui->fvol2SpinBox->value();
sysPara->para.printed_full_col_dac[3] = ui->fvol3SpinBox->value();
sysPara->para.printed_full_col_dac[4] = ui->fvol4SpinBox->value();
sysPara->para.printed_full_col_dac[5] = ui->fvol5SpinBox->value();
sysPara->para.printed_full_col_dac[6] = ui->fvol6SpinBox->value();
sysPara->para.printed_full_col_dac[7] = ui->fvol7SpinBox->value();
sysPara->para.printed_full_col_dac[8] = ui->fvol8SpinBox->value();
sysPara->para.printed_full_col_dac[9] = ui->fvol9SpinBox->value();
sysPara->para.printed_full_col_dac[10] = ui->fvol10SpinBox->value();
sysPara->para.printed_full_col_dac[11] = ui->fvol11SpinBox->value();
sysPara->para.printed_full_col_dac[12] = ui->fvol12SpinBox->value();
sysPara->para.printed_full_col_dac[13] = ui->fvol13SpinBox->value();
sysPara->para.printed_full_col_dac[14] = ui->fvol14SpinBox->value();
sysPara->para.printed_full_col_dac[15] = ui->fvol15SpinBox->value();
sysPara->para.printed_full_col_dac[16] = ui->fvol16SpinBox->value();
sysPara->para.printed_full_col_dac[17] = ui->fvol17SpinBox->value();
sysPara->para.printed_full_col_dac[18] = ui->fvol18SpinBox->value();
sysPara->para.printed_full_col_dac[19] = ui->fvol19SpinBox->value();
sysPara->para.printed_full_col_dac[20] = ui->fvol20SpinBox->value();
sysPara->para.printed_full_col_dac[21] = ui->fvol21SpinBox->value();
sysPara->para.printed_full_col_dac[22] = ui->fvol22SpinBox->value();
sysPara->para.printed_full_col_dac[23] = ui->fvol23SpinBox->value();
sysPara->para.printed_full_col_dac[24] = ui->fvol24SpinBox->value();
sysPara->para.printed_full_col_dac[25] = ui->fvol25SpinBox->value();
sysPara->para.printed_full_col_dac[26] = ui->fvol26SpinBox->value();
sysPara->para.printed_full_col_dac[27] = ui->fvol27SpinBox->value();
sysPara->para.printed_full_col_dac[28] = ui->fvol28SpinBox->value();
sysPara->para.printed_full_col_dac[29] = ui->fvol29SpinBox->value();
sysPara->para.printed_full_col_dac[30] = ui->fvol30SpinBox->value();
sysPara->para.printed_full_col_dac[31] = ui->fvol31SpinBox->value();
sysPara->para.printed_full_col_dac[32] = ui->fvol32SpinBox->value();
sysPara->para.printed_full_col_dac[33] = ui->fvol33SpinBox->value();
sysPara->para.printed_full_col_dac[34] = ui->fvol34SpinBox->value();
sysPara->para.printed_full_col_dac[35] = ui->fvol35SpinBox->value();
sysPara->para.printed_full_col_dac[36] = ui->fvol36SpinBox->value();
sysPara->para.printed_full_col_dac[37] = ui->fvol37SpinBox->value();
sysPara->para.printed_full_col_dac[38] = ui->fvol38SpinBox->value();
sysPara->para.printed_full_col_dac[39] = ui->fvol39SpinBox->value();
sysPara->devOp->writeFpgaPrintPara();
}
InkJetPrinter::~InkJetPrinter()
{
if(m_serialThreadFPGA->isRunning()){
m_serialThreadFPGA->quit();
m_serialThreadFPGA->wait();
}
if(m_serialThreadSTM32->isRunning()){
m_serialThreadSTM32->quit();
m_serialThreadSTM32->wait();
}
if(m_thread->isRunning()){
m_thread->quit();
m_thread->wait();
}
if(serialFPGA)
delete serialFPGA;
if(serialSTM32)
delete serialSTM32;
delete ui;
delete timer;
#ifdef MODBUS
if (modbus) {
delete modbus;
}
#endif
if (fileTransceiv) {
fileTransceiv->deleteLater();
}
//edit@01-03
if (tcpTransceiv) {
tcpTransceiv->deleteLater();
}
}
extern void MySleep(unsigned int msec);
extern unsigned char test_flag;
bool gearPumpRunNormalFlag = false;
unsigned char isPrintingFlag[1]={0};
void InkJetPrinter::timerHandler(void){
static bool flag1 = 1;
if(flag1){
flag1 = 0;
qDebug()<<"timer had started";
}
int pulse_100ms = 0;
int pulse_200ms = 0;
int pulse_50ms = 0;
int pulse_20ms = 0;
int pulse_1s = 0;
int pulse_10s = 0;
int pulse_100s = 0;
int pulse_300ms = 0;
int timer_3s = 0;
static int pulse_3s = 0;
static int pulse_4s = 0;
static int pulse_5s = 0;
static int reciclar_30s = 0;
static int pulse_30s = 0;
static int xxxm=0;
static int tempFlag=0;
static int save_weeknum = 0;
static bool gearPumpRunFlag = false;
static bool ControledSwitchFlag = false;
static bool gearPumpStartFlag = false;
static bool delay3s;
bool InkSwintFlag = false,lastInkSwintFlag = false;
static float gearPumpRunNormalValue = 0.0;
if(sysPara){
xxxm=1;
sysPara->para.ReadFileErrorCnt=0; // 正常打开文件
// /opt/FriendlyARM/mini2440/rootfs_qtopia_qt4/usr/local/Trolltech/QtEmbedded-4.6.3-arm/lib
if(sysPara->para.gearPumpEnable)
{
ui->tabMainWindow->enablePushButtonStart(true);
if(!pushButtonStartFlag)
{
gearPumpRunNormalFlag = false;
}
if(!gearPumpRunFlag)
{
ui->tabMainWindow->enableReclaimCtrlButton(false);
}
}
else
{
ui->tabMainWindow->enablePushButtonStart(false);
}
/*-----------------------形成脉冲-----------------------------*/
sysPara->status.delay10ms ++;
if(sysPara->status.delay10ms == 2){
pulse_20ms = 1;
}
if(sysPara->status.delay10ms == 5){
pulse_50ms = 1;
}
if(sysPara->status.delay10ms == 10){
pulse_100ms = 1;
sysPara->status.delay10ms = 0;
}
if(pulse_100ms){
sysPara->status.delay100ms ++;
if(sysPara->status.delay100ms == 10){
pulse_1s = 1;
sysPara->status.delay100ms = 0;
}
pulse_300ms = (sysPara->status.delay100ms%3) == 0; //1秒3次，并非精确的300ms
pulse_200ms = (sysPara->status.delay100ms%2) == 0;
}
if(pulse_300ms) tempFlag=1;
if((sysPara->status.delay10ms%3) == 0) //读取状态后再检測
{
if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN) && !gearPumpRunFlag && !sysPara->status.isPumpValveControledByHand)//刚启动前3秒
{
if(sysPara->para.gearPumpEnable) {
// 隔膜泵初始化：确保从停止状态开始
if(sysPara->para.gearPumpValue != 0) {
sysPara->para.gearPumpValue = 0;
u = 0.0f;
sysPara->devOp->WriteMoterPump();
}
// 初始化隔膜泵状态机
m_pumpState = DPUMP_STOPPED;
m_stateChangeCount = 0;
m_adjSkip = 0;
m_lastActualPressure = 0;
m_bufValidCount = 0;
m_startingStepCount = 0;
gearPumpStartFlag = true;
}
}
}
if(pushButtonStartFlag && sysPara->status.selfCheckDone)
{
if((sysPara->status.PRESSURE > (sysPara->para.pressure -10)) && (sysPara->status.PRESSURE < (sysPara->para.pressure +10)))
{
if(pulse_1s)
{
pulse_5s++;
}
if( pulse_5s == 5)
{
pulse_5s = 0;
gearPumpRunNormalFlag = true;
gearPumpRunNormalValue = u;
}
}
}
if(sysPara->status.isPumpValveControledByHand)
{
gearPumpRunNormalFlag = false;
ControledSwitchFlag = false;
pulse_3s = 0;
}
// 检测手动→自动边沿，直接恢复压力控制，不走 gearPumpStartFlag 的 3s 等待
if(m_lastByHand && !sysPara->status.isPumpValveControledByHand)
{
ControledSwitchFlag = true;
u = (float)sysPara->para.gearPumpValue; // 同步当前转速，避免突变
// 重置隔膜泵状态机，从当前转速状态开始
if(u > 40.0f) {
m_pumpState = DPUMP_RUNNING; // 如果当前有转速，进入运行状态
} else {
m_pumpState = DPUMP_STOPPED; // 否则从停止状态开始
}
m_stateChangeCount = 0;
m_adjSkip = 0;
m_lastActualPressure = 0;
m_bufValidCount = 0;
for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
m_bufIdx = 0;
}
m_lastByHand = sysPara->status.isPumpValveControledByHand;
if(!(sysPara->status.statWarn & WARN_STATUS_INK_SWINT)){//墨线开关,压力抖动
InkSwintFlag = true;
}
else
{
InkSwintFlag = false;
}
if(lastInkSwintFlag != InkSwintFlag)
{
lastInkSwintFlag = InkSwintFlag;
gearPumpRunNormalFlag = false;
}
if(gearPumpRunNormalFlag && !sysPara->status.isPumpValveControledByHand && sysPara->para.gearPumpEnable)
{
// 隔膜泵泄漏检测：运行状态下，压力持续不上升或下降
static int leakCheckCount = 0;
static int lastPressureForLeak = 0;
if(m_pumpState == DPUMP_RUNNING && pulse_1s)
{
int pressureChange = sysPara->status.PRESSURE - lastPressureForLeak;
// 泵运行中（转速>40），压力不升反降，或上升太慢（<5/秒）
if(u > 40.0f && pressureChange < 5) {
leakCheckCount++;
if(leakCheckCount >= 5) { // 连续5秒
leakCheckCount = 0;
ui->tabMainWindow->setRunStatus(tr("压力异常，可能泄漏!"));
sysPara->status.gearPumpRunStopFlag = true;
gearPumpRunNormalFlag = false;
LogInfo::setRunStatusText(tr("运行中压力泄漏，停泵!"));
}
} else {
leakCheckCount = 0;
}
lastPressureForLeak = sysPara->status.PRESSURE;
}
}
if(sysPara->para.gearPumpEnable && (sysPara->status.gearPumpRunSpeed < 100) && test_flag){
if(test_flag % 2)
ui->tabMainWindow->on_pushButtonReclaimTankClose_pressed();
test_flag = 0;
}
if(pulse_1s) {
if(sysPara->status.selfCheckDone && sysPara->para.gearPumpEnable && sysPara->para.flagOfReclaimPumEnable)
checkPressureControl();
if((QTime::currentTime()>=QTime(00,00,00))&&(QTime::currentTime()<=QTime(00,00,02))&&sysPara->para.Reciclar){
if(ui->tabMainWindow->getCurrPrintStatus() != 1){
ui->tabMainWindow->_on_pushButtonPowerOff_pressed(false);
LogInfo::setRunStatusText(tr("测试时间结束，准备关机"));
ui->tabMainWindow->setRunStatus(tr("测试时间结束，准备关机"));
}
}
if(sysPara->status.selfCheckDone && sysPara->para.Reciclar && test_flag){
reciclar_30s++;
if(reciclar_30s > 30){
reciclar_30s = 0;
test_flag++;
}
}
else if(reciclar_30s){
reciclar_30s = 0;
}
QDate d = QDate::currentDate();
if(save_weeknum == 0)
{
save_weeknum = d.weekNumber();
}
if(save_weeknum != d.weekNumber())
{
sysPara->devOp->writeFpgaCalandar(1);
save_weeknum = d.weekNumber();
}
sysPara->status.delay1s ++;
if(sysPara->status.delay1s == 3 && !delay3s){
delay3s = true;
}
if(sysPara->status.delay1s % 3 == 0 && sysPara->status.delay1s != 0)
timer_3s = 1;
if(sysPara->status.delay1s == 10){
pulse_10s = 1;
sysPara->status.delay1s = 0;
}
pulse_4s++;
if(gearPumpStartFlag)
{
pulse_3s ++;
if(pulse_3s == 3)
{
pulse_3s = 0;
gearPumpRunFlag = true;
ControledSwitchFlag = true;
}
}
if( sysPara->status.reclainTankReachEnd) sysPara->para.openInkLineTime++;
}
if(pulse_1s && flagOfSerialThreadStratEn){
if (!m_serialThreadFPGA->isRunning()) {
qDebug()<<"start FPGA tread";
m_serialThreadFPGA->start();
}
if (!m_serialThreadSTM32->isRunning()){
qDebug()<<"start STM32 tread";
m_serialThreadSTM32->start();
}
flagOfSerialThreadStratEn = false;
}
if(pulse_10s){
if(!m_thread->isRunning())
m_thread->start();
sysPara->status.delay10s ++;
if(sysPara->status.delay10s == 10){
pulse_100s = 1;
sysPara->status.delay10s = 0;
// if(sysPara->status.flagOfPowerOnMode && (ui->tabMainWindow->getCurrPrintStatus() != 1))
if(sysPara->status.flagOfPowerOnMode)
{
qDebug()<<"waitPowerOffTime: "<<sysPara->status.waitPowerOffTime;
LogInfo::setRunStatusText(tr("waitPowerOffTime: %1").arg(sysPara->status.waitPowerOffTime));
if(sysPara->status.waitPowerOffTime)
{
sysPara->status.waitPowerOffTime--;
if(!sysPara->status.waitPowerOffTime)
{
ui->tabMainWindow->_on_pushButtonPowerOff_pressed(false);
LogInfo::setRunStatusText(tr("定时开机循环完成，准备关机"));
ui->tabMainWindow->setRunStatus(tr("准备关机"));
}
}
}
}
}
/*------------------------------------------------------*/
if(pulse_100ms) {
sysPara->devOp->stm32Rd(0x07,(unsigned char *)&PulseCnt,2);//读取脉冲个数低字节
sysPara->devOp->readFgaStatus();
}
/**************桂澳增加超速提示*****************************/
static int logCtrl = 0;
if((sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER || sysPara->para.eleEyeTriggerSynPrintEn)
&& sysPara->status.lesslen_warn == 1){ //置1表示超速了
if(logCtrl++ % 500 == 0){
LogInfo::setRunStatusText(tr("速度过快,请检查是否漏喷!!!"));
qDebug()<<"速度过快,请检查是否漏喷!!!";
}
/*if(msgBox1->isHidden()){ //桂澳的超速提示先保留
msgBox1->setText(tr("速度过快,请检查是否漏喷!!!"));
msgBox1->show();
LogInfo::setRunStatusText(tr("速度过快,请检查是否漏喷!!!"));
qDebug()<<"速度过快,请检查是否漏喷!!!";
}*/
sysPara->devOp->controlRedLight(true);
sysPara->devOp->controlGreenLight(false);
}
else{
if(!msgBox1->isHidden())
sysPara->devOp->controlRedLight(false);
}
sysPara->status.gearPumpRunSpeed = (PulseCnt * 60 * 1000) / (500 * 2);
if(!sysPara->para.gearPumpEnable)
sysPara->status.PRESSURE *= 5; //响应群众号召，数值放大五倍
/*-------------------------------------------------------*/
bool lostCommuFlag = 1;
if(sysPara->status.fpgaVersionNum != 0)
lostCommuFlag = 0;
if(sysPara->status.delay10ms%5 == 0)
{//复位发送打印数据
if((ui->tabMainWindow->getCurrPrintStatus() == 1)&&sysPara->para.ResetSendData)
{
static bool oneTimeFlag = false;
if(sysPara->status.productCnt== 0 && (oneTimeFlag==false))//计米复位发送打印数据
{
oneTimeFlag = true;
ui->tabMainWindow->on_pushButtonStartPrint_pressed();
//复位重设起始值
if(sysPara->para.cnt1ResetToInitValue)
{
sysPara->para.cnt1CurrValue = sysPara->para.cnt1StartValue;
sysPara->status.cnt1CurrentValueInitDoneFlag = false;
sysPara->devOp->writeFpgaCalandar(0);
}
}
if(sysPara->status.productCnt != 0)
{
oneTimeFlag = false;
}
}
static unsigned int lastProductCount=0;
if(sysPara->status.productCnt != lastProductCount || sysPara->status.printDoneFlag)
{
sysPara->status.printDoneFlag = false;
lastProductCount = sysPara->status.productCnt;
sysPara->modbusStatus.printFinishFlag = 1;
memcpy((void*)(&sysPara->modbusStatus.orderCode), (void*)(&sysPara->modbusParas.QRcode_buf), 2);//写返回序列号
ui->tabMainWindow->UpdateDateTimeQRCode(QDateTime::currentDateTime().toString("hh:mm"));
}
if (modbus->getModbusStatus() == 1) {
refreshModbusStatus();
}
}
if(gearPumpRunFlag || sysPara->para.gearPumpEnable == 0)
{
if(!sysPara->status.selfCheckDone && sysPara->status.isPrinting){
sysPara->status.selfCheckDone = true;
ui->tabMainWindow->updatePrintDisplayLabel();
sysPara->status.flagOfAbnormalStatus = true;
static bool onceLog = true;
if(onceLog) {
LogInfo::setRunStatusText(tr("打印过程中死机了!!!"));
qDebug()<<"打印过程中死机了!!!";
onceLog = false;
ui->tabMainWindow->updatePrintDisplayLabel();
}
ui->tabMainWindow->on_pushButtonStopPrint_pressed();
}
if(!sysPara->status.selfCheckDone)
{
/*开机自检*/
autoControlValvePump();
if(pulse_100ms){
pressureAdj();
}
/*-----------------------------------------------------*/
if(!sysPara->status.selfCheckCnt) {
LogInfo::setRunStatusText(tr("开始自检,请等待60秒..............."));
ui->tabMainWindow->enableReclaimCtrlButton(false);
ui->tabMainWindow->enablePrintButton(false);
sysPara->devOp->mainInkCtrl();
sysPara->para.TrunOnPowerCnt++;// 20151218 开机次数加1
sysPara->saveParaToFile(); // 保存开机次数值
sysPara->status.lastProductCnt = sysPara->status.productCnt ; //这会让产品计数显示出来
ui->tabMainWindow->updateTotalCnt(0);
}
if((++sysPara->status.selfCheckCnt % 100) == 0){
ui->tabMainWindow->setRunStatus(tr("开始自检,请等待%1秒...............").arg((MAX_SELF_CHECK_CNT - sysPara->status.selfCheckCnt)/100));
}
if(sysPara->status.selfCheckCnt >= MAX_SELF_CHECK_CNT)
{
sysPara->status.selfCheckDone = 1;
u = (float)sysPara->para.gearPumpValue;
// 自检完成后管道恢复正常阻力，重置状态机让压力重新平稳收敛
// 不清零 u，从当前控制字开始，避免突变
if(u > 40.0f) {
m_pumpState = DPUMP_RUNNING; // 如果当前有转速，进入运行状态
} else {
m_pumpState = DPUMP_STOPPED; // 否则从停止状态开始
}
m_stateChangeCount = 0;
m_adjSkip = 0;
m_lastActualPressure = 0;
m_bufValidCount = 0;
for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
m_bufIdx = 0;
LogInfo::setRunStatusText(tr("自检完成!!!"));
ui->tabMainWindow->setRunStatus(tr("自检完成!!!"));
qDebug()<<"自检完成!!!";
ui->tabPrintSetting->PrintSettingLog();
ui->tabMainWindow->enableReclaimCtrlButton(true);
sysPara->devOp->mainInkCtrl();
sysPara->status.canRunAirPushing = true;
if(sysPara->para.Reciclar)
test_flag = 1;
}
else {
if((sysPara->status.selfCheckCnt % 200) == 0)
// sysPara->devOp->controlReclaimTankOpen(false);
ui->tabMainWindow->enableReclaimCtrlButton(false);
}
}
else{
// 开机自检完成的前提下
if (!sysPara->status.airPushing || ui->tabMainWindow->m_2sFlag) {
autoControlValvePump();
}
// 检测回收泵模式切换，切换时重置泄漏保护学习状态和软启动状态
if(m_lastReclaimMode != sysPara->para.flagOfReclaimPumEnable)
{
m_lastReclaimMode = sysPara->para.flagOfReclaimPumEnable;
gearPumpRunNormalFlag = false; // 泄漏保护重新学习
gearPumpRunNormalValue = 0.0f;
// 重置隔膜泵状态机，适应新模式
m_pumpState = DPUMP_STOPPED;
m_stateChangeCount = 0;
m_adjSkip = 0;
m_lastActualPressure = 0;
m_bufValidCount = 0;
for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
m_bufIdx = 0;
}
if(pulse_100ms && sysPara->para.gearPumpEnable && !sysPara->status.isPumpValveControledByHand && ControledSwitchFlag ) {
pressureAdj();
}
}
}
else{
static bool flag = 1;
if(delay3s){
if(flag){
flag = 0;
LogInfo::setRunStatusText(tr("缺少墨水,喷码机不能正常工作!"));
qDebug()<<"缺少墨水,喷码机不能正常工作!";
}
ui->tabMainWindow->setRunStatus(tr("缺少墨水,喷码机不能正常工作!"));
}
}
/*----------------------------控制温度--------------------------------------*/
if(pulse_300ms){
autoControlHeater();
sysPara->devOp->readSyncCounterAtZero();
}
sysPara->status.lostCommuFlag = lostCommuFlag; //务必放在后面
static unsigned int lastProductCnt =0;
static int lastalterMode=-1;
if(sysPara->para.alterPrint.enable)
{
sysPara->para.AlterMode=sysPara->status.AlterMode; // 电眼触发交替功能：新增这一行
if( (sysPara->para.AlterMode!=lastalterMode)
|| (lastProductCnt != sysPara->status.productCnt)
)
{
ui->tabMainWindow->alterDataPrint (sysPara->para.AlterMode);
}
}
else sysPara->para.AlterMode=0;
lastalterMode = sysPara->para.AlterMode;
lastProductCnt = sysPara->status.productCnt;
ui->tabMainWindow->CheckStatus(pulse_300ms); //
/*----------------------------------界面更新状态---------------------------------------*/
#ifdef __RFID_CARD
static bool flag6 = true;
unsigned int addr = ui->tabPrintSetting->dlgInputAddr->jd.addr;
if(pulse_10s && flag6){ //初始化刷卡模块
qDebug()<<"初始化刷卡模块";
LogInfo::setRunStatusText(QString("jd.addr:%1").arg(addr));
flag6 = false;
if (manager_rfid)
manager_rfid->initRFIDMoudle(addr, sysPara);
}
if(pulse_300ms){
if (manager_rfid)
manager_rfid->handleCheck(addr);
}
#endif
if(pulse_300ms){
sysPara->devOp->readCalandarDat(); //务必读一下此数据
if(sysPara->status.RandomNum>0)
sysPara->devOp->Read_RanddomFromFpga();
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
cnt1GroupCheck();//分段计米
#endif
cntGroupCheck();//分段计米
QWidget *widget = this->currentWidget();
static bool read_flag = false;
if(widget == ui->tabMainWindow && pulse_100ms) {
ui->tabMainWindow->updateSysStatusToUI();
}
else if(widget == ui->tabTriggerMode){
ui->tabTriggerMode->updateSysStatusToUI();
if(sysPara->status.fpgaVersionNum != 0){
QString FpgaVersion;
if((sysPara->status.fpgaVersionNum>>12) == 8 || (sysPara->status.fpgaVersionNum>>12) == 6)
FpgaVersion = "72";
else if((sysPara->status.fpgaVersionNum>>12) == 2 || (sysPara->status.fpgaVersionNum>>12) == 1){
if(sysPara->para.flagOfFastMode)
FpgaVersion = "66";
else
FpgaVersion = "67";
}
FpgaVersion += QString("_F%1.%2.%3").arg(sysPara->status.fpgaVersionNum >> 12)
.arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff);
ui->tabTriggerMode->setBuildTime(QString(" No%1").arg(FpgaVersion));
}
}
else if(widget == ui->tabPrintSetting)
{
ui->tabPrintSetting->updateSysStatusToUI();
if(!read_flag)
{
emit sendPicScene(ui->tabMainWindow->getPicScene());
}
read_flag = true;
}
else if(widget == ui->tabSystemSetting){
ui->tabSystemSetting->updateSysStatusToUI();
}
else if(widget == ui->tabSystemManage){
ui->tabSystemManage->updateSysStatusToUI();
}
else if(widget == ui->tabOtherInfo){
ui->tabOtherInfo->updateSysStatusToUI();
}
else if(widget == ui->tabNetworkManager){
if(!sysPara->status.bLanConfigManual)
{
ui->tabNetworkManager->updateSysStatusToUI();
}
}
if(widget != ui->tabPrintSetting)
{
read_flag = false;
}
// 20140306
static int last_lesslen_warn=0,lesslen_cnt=0;
if(sysPara->status.lesslen_warn && (sysPara->para.printTriggerMode != PRINT_TRIGGER_TIME))
{
if(last_lesslen_warn==0)
{
last_lesslen_warn =lesslen_cnt;
if(lesslen_cnt<60)lesslen_cnt +=6;
if(lesslen_cnt>40) sysPara->devOp->resumeFault();
if(sysPara->para.speedoverPaushPrint) {
ui->tabMainWindow->on_pushButtonPausePrint_pressed();// 2014-03-19
// emit OnSpeedOver(2);//QMessageBox::warning(NULL,tr("警告"),tr("喷印速度过快！无法喷印完全，自动暂停喷印!!!"));
ui->tabMainWindow->setRunStatus(tr("喷印速度过快！无法喷印完全，自动暂停喷印!!!"));
}
else {
// emit OnSpeedOver(1);//QMessageBox::warning(NULL,tr("警告"),tr("喷印速度过快！无法喷印完全!!!"));
ui->tabMainWindow->setRunStatus(tr("喷印速度过快！无法喷印完全!!!"));
}
}
}
else { last_lesslen_warn=0;lesslen_cnt=30;}
if(last_lesslen_warn) last_lesslen_warn--;
}
if(pulse_100ms && sysPara->status.selfCheckDone){
detectAndcontrolReclaimTank(); //控制回收槽
}
/*---------------------------------处理警告--------------------------------------------*/
if(pulse_1s){
if(sysPara->para.gearPumpEnable && sysPara->status.selfCheckDone && gearPumpRunNormalFlag)
{
if((sysPara->status.PRESSURE < (sysPara->para.pressure -8)) || (sysPara->status.PRESSURE > (sysPara->para.pressure +8)))
{
LogInfo::setRunStatusText(tr("压力波动超过设定的5个值."));
}
}
static bool logFlag1 = true;
if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN && logFlag1){
logFlag1 = false;
LogInfo::setRunStatusText(tr("溶剂液位报警! %1").arg(sysPara->RFIDPara.solventNumber));
qDebug()<<"溶剂液位报警! "<<sysPara->RFIDPara.solventNumber;
}
#ifdef __RFID_CARD
/*****************墨水刷卡控制start**********************************************/
/*墨水刷卡新的控制逻辑*/
/* 1.任何时候,打印墨点数达到2.3billion之后,提示24小时内刷卡,否则禁止使用机器*/
/*2.当墨水液位后,持续提示刷卡,24小时后如果还没有刷卡,禁止使用机器*/
static bool logFlag4 = 1;
static int warnNum1 = 0;
if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN))
warnNum1 = 0;
if((sysPara->status.statWarn & WARN_STATUS_INK_WARN) || sysPara->para.RFIDInkWarn){
if(!sysPara->para.RFIDInkWarn){
if(++warnNum1 >6){
sysPara->para.RFIDInkWarn = true;
QDateTime curDateTime = QDateTime::currentDateTime();
QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
if(sysPara->para.inkWarnDate == 0){
sysPara->para.inkWarnDate = strCurDateTime.mid(0,6).toInt();
sysPara->para.inkWarnTime = strCurDateTime.mid(6,6).toInt();
}
sysPara->saveParaToFile();
}
else{
LogInfo::setRunStatusText(tr("detect Ink warning cnt: %1").arg(warnNum1));
qDebug()<<"检测到墨水液位次数:"<<warnNum1;
}
}
else{
sysPara->status.flagOfNeedInkCard = true;
if(logFlag4){
logFlag4 = 0;
QString strDate = QString::number(sysPara->para.inkWarnDate);
QString strTime = QString::number(sysPara->para.inkWarnTime);
QString str1 = QString::number(strDate.mid(0,2).toInt()).rightJustified(2,'0');
QString str2 = QString::number(strDate.mid(2,2).toInt()).rightJustified(2,'0');
QString str3 = QString::number(strDate.mid(4,2).toInt()).rightJustified(2,'0');
QString str4 = QString::number(strTime.mid(0,2).toInt()).rightJustified(2,'0');
QString str5 = QString::number(strTime.mid(2,2).toInt()).rightJustified(2,'0');
QString str6 = QString::number(strTime.mid(4,2).toInt()).rightJustified(2,'0');
QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
LogInfo::setRunStatusText(tr("ink Warning at: %1").arg(strDateTime));
qDebug()<<"ink Warning at:"<<strDateTime;
}
}
}
if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS || sysPara->para.RFIDInkWarn){
sysPara->status.flagOfNeedInkCard = true;
if(sysPara->RFIDPara.InkRFIDCnt == 0){
msgtest->setText(tr("请使用原厂墨水,然后刷墨水卡,否则机器将在24小时后禁止使用!"));
msgtest->show();
ui->tabMainWindow->setRunStatus(tr("请使用原厂墨水,然后刷墨水卡,否则机器将在24小时后禁止使用!"));
LogInfo::setRunStatusText(tr("请使用原厂墨水,然后刷墨水卡,否则机器将在24小时后禁止使用!"));
}
int timeRemain = (MAX_INK_RFIDTIME - sysPara->RFIDPara.InkRFIDCnt)/60;
if(timeRemain > 60){
if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS)
ui->tabMainWindow->setRunStatus(tr("1.请使用原厂墨水,然后刷墨水卡,否则机器将在%1小时后禁止使用!").arg(timeRemain/60));
else
ui->tabMainWindow->setRunStatus(tr("2.请使用原厂墨水,然后刷墨水卡,否则机器将在%1小时后禁止使用!").arg(timeRemain/60));
}
else if(timeRemain > 0){
if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS)
ui->tabMainWindow->setRunStatus(tr("1.请使用原厂墨水,然后刷墨水卡,否则机器将在%1分钟后禁止使用!").arg(timeRemain));
else
ui->tabMainWindow->setRunStatus(tr("2.请使用原厂墨水,然后刷墨水卡,否则机器将在%1分钟后禁止使用!").arg(timeRemain));
}
if(sysPara->RFIDPara.InkRFIDCnt % 300 == 0)
sysPara->saveRFIDPara();
if(++sysPara->RFIDPara.InkRFIDCnt >= MAX_INK_RFIDTIME)
sysPara->status.flagOfInkMaxDot = true;
}
if(sysPara->status.flagOfInkMaxDot){
if(sysPara->status.isPrinting)
ui->tabMainWindow->on_pushButtonStopPrint_pressed();
static bool logFlag2= true;
if(sysPara->RFIDPara.PrintInkDots >= MAX_INK_DOTS){
ui->tabMainWindow->setRunStatus(tr("1.请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
if(logFlag2){
logFlag2 = false;
msgtest->setText(tr("请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
msgtest->show();
LogInfo::setRunStatusText(tr("请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
qDebug()<<"打印墨点已达到2.3billion,请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!";
}
}
else{
ui->tabMainWindow->setRunStatus(tr("2.请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
if(logFlag2){
logFlag2 = false;
msgtest->setText(tr("请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
msgtest->show();
LogInfo::setRunStatusText(tr("请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!"));
qDebug()<<"请使用原厂墨水,然后刷墨水卡以恢复机器的正常功能!";
}
}
}
/*****************墨水刷卡控制end**********************************************/
/*****************溶剂刷卡控制start**********************************************/
/*溶剂刷卡新的控制逻辑*/
/* 1.任何时候，混合阀打开次数达到360次，提示2小时关机，必须刷卡才能恢复*/
/*2.溶剂液位报警后，提示刷卡，允许有10次的混合阀打开次数，必须刷卡才能恢复*/
if(sysPara->RFIDPara.solventNumber >= MAX_SOLV_OPENNUM){ //混合阀打开次数达到360次
sysPara->status.flagOfNeedSolventCard = true;
if(sysPara->RFIDPara.SOLVRFIDCnt == 0){
msgtest->setText(tr("请使用原厂溶剂,然后刷溶剂卡,否则机器将在2小时后禁止使用!"));
msgtest->show();
LogInfo::setRunStatusText(tr("请使用原厂溶剂,然后刷溶剂卡,否则机器将在2小时后禁止使用!"));
}
int timeRemain = (MAX_SOLV_RFIDTIME - sysPara->RFIDPara.SOLVRFIDCnt)/60;
if(timeRemain > 0)
ui->tabMainWindow->setRunStatus(tr("请使用原厂溶剂,然后刷溶剂卡,否则机器将在%1分钟后禁止使用!").arg(timeRemain));
if(sysPara->RFIDPara.SOLVRFIDCnt % 300 == 0)
sysPara->saveRFIDPara();
if(++sysPara->RFIDPara.SOLVRFIDCnt >= MAX_SOLV_RFIDTIME)
sysPara->status.flagOfSolventMaxNum = true;
}
static bool logFlag5 = 1;
static int warnNum2 = 0;
if(!(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN))
warnNum2 = 0;
if((sysPara->status.statWarn & WARN_STATUS_SOLV_WARN) || sysPara->para.RFIDSolventWarn){
if(!sysPara->para.RFIDSolventWarn){
if(++warnNum2 > 6){
sysPara->para.RFIDSolventWarn = true;
sysPara->para.RFIDSolventWarnMixCnt = 0;
LogInfo::setRunStatusText(tr("请添加原厂溶剂,然后刷溶剂卡!"));
qDebug()<<"请添加原厂溶剂,然后刷溶剂卡,否则将会在打开10次混合阀之后禁用喷码机!";
QDateTime curDateTime = QDateTime::currentDateTime();
QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
if(sysPara->para.solventWarnDate == 0){
sysPara->para.solventWarnDate = strCurDateTime.mid(0,6).toInt();
sysPara->para.solventWarnTime = strCurDateTime.mid(6,6).toInt();
}
sysPara->saveParaToFile();
}
else{
LogInfo::setRunStatusText(tr("detect solvent warning cnt: %1").arg(warnNum2));
qDebug()<<"检测到溶剂液位次数:"<<warnNum2;
}
}
else{
sysPara->status.flagOfNeedSolventCard = true;
ui->tabMainWindow->setRunStatus(tr("请添加原厂溶剂,然后刷溶剂卡!"));
if(logFlag5){
logFlag5 = 0;
QString strDate = QString::number(sysPara->para.solventWarnDate);
QString strTime = QString::number(sysPara->para.solventWarnTime);
QString str1 = QString::number(strDate.mid(0,2).toInt()).rightJustified(2,'0');
QString str2 = QString::number(strDate.mid(2,2).toInt()).rightJustified(2,'0');
QString str3 = QString::number(strDate.mid(4,2).toInt()).rightJustified(2,'0');
QString str4 = QString::number(strTime.mid(0,2).toInt()).rightJustified(2,'0');
QString str5 = QString::number(strTime.mid(2,2).toInt()).rightJustified(2,'0');
QString str6 = QString::number(strTime.mid(4,2).toInt()).rightJustified(2,'0');
QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
LogInfo::setRunStatusText(tr("solvent Warning at: %1").arg(strDateTime));
qDebug()<<"solvent Warning at:"<<strDateTime;
}
}
}
if(sysPara->para.RFIDSolventWarnMixCnt >= 10)
sysPara->status.flagOfSolventMaxNum = true;
if(sysPara->status.flagOfSolventMaxNum){
if(sysPara->status.isPrinting)
ui->tabMainWindow->on_pushButtonStopPrint_pressed();
static bool logFlag3 = true;
if(sysPara->para.RFIDSolventWarnMixCnt>=10){
ui->tabMainWindow->setRunStatus(tr("请刷溶剂卡以恢复机器的正常功能"));
if(logFlag3){
logFlag3 = false;
msgtest->setText(tr("请刷溶剂卡以恢复机器的正常功能!"));
msgtest->show();
LogInfo::setRunStatusText(tr("请刷溶剂卡以恢复机器的正常功能"));
qDebug()<<"溶剂液位报警后已经打开混合阀10次,请刷卡以恢复机器的正常功能";
}
}
else{
ui->tabMainWindow->setRunStatus(tr("请刷溶剂卡以恢复机器的正常功能"));
if(logFlag3){
logFlag3 = false;
msgtest->setText(tr("请刷溶剂卡以恢复机器的正常功能!"));
msgtest->show();
LogInfo::setRunStatusText(tr("请刷溶剂卡以恢复机器的正常功能"));
qDebug()<<"已经打开混合阀360次,请刷卡以恢复机器的正常功能";
}
}
}
/*****************溶剂刷卡控制end**********************************************/
#endif
static bool resumeFlag = false;
if(lostCommuFlag || ui->tabMainWindow->updatePhaseIndicatorLight() || (sysPara->status.statWarn & (WARN_STATUS_POWER_MON|WARN_STATUS_INK_WARN|WARN_STATUS_SUMP_WARN
|WARN_STATUS_SOLV_WARN|WARN_STATUS_POWER_MON)) || (sysPara->status.gearPumpRunStopFlag && pushButtonStartFlag) ||sysPara->status.lastHighVoltageFault)
{ //updatePhaseIndicatorLight（）务必放前面
sysPara->status.beeperOnFlag = true;
if(sysPara->status.gearPumpRunStopFlag && pushButtonStartFlag)
{
ui->tabMainWindow->setRunStatus(tr("压力泄漏或压力传感器故障!"));
}
if(!resumeFlag)
{
resumeFlag = true;
pulse_4s = 0;
if(!sysPara->status.lastHighVoltageFault)
{
ui->tabMainWindow->onLabelFaultRusumePressed();
}
}
}
else {
sysPara->status.beeperOnFlag = false;
sysPara->devOp->controlBeeper(false);
if(pulse_4s >= 20)
{
pulse_4s = 0;
resumeFlag = false;
}
}
if(sysPara->status.beeperOnFlag){ //报警会时有时无
sysPara->devOp->controlBeeper(!sysPara->devOp->isBeeperEnable());
}
if((sysPara->status.statWarn & (WARN_STATUS_POWER_MON))
||sysPara->status.lastwarmInkPump||sysPara->status.lastwarmInkPump||sysPara->status.mainInkPumpError
||sysPara->status.compressPumpError||sysPara->status.lastPhaseFault||sysPara->status.lastRecycleWarn||sysPara->status.lastHighVoltageFault)
{ //2013-12-12故障报警灯 杨
sysPara->status.RedLightOnFlag = true;
}
else {
sysPara->status.RedLightOnFlag = false;
sysPara->devOp->controlRedLight(false);
//sysPara->devOp->controlRedLight(true);
}
if(sysPara->status.RedLightOnFlag){ //报警会时有时无
sysPara->devOp->controlRedLight(!sysPara->devOp->isRedLightEnable());
}
if((sysPara->status.statWarn & (WARN_STATUS_INK_WARN|WARN_STATUS_SOLV_WARN |WARN_STATUS_RECYCLE_FAULT|WARN_STATUS_SUMP_WARN))
&& !sysPara->status.RedLightOnFlag){
//if(!sysPara->status.RedLightOnFlag){
sysPara->status.YellowLightOnFlag = true;
}
else {
sysPara->status.YellowLightOnFlag = false;
sysPara->devOp->controlYellowLight(false);
//sysPara->devOp->controlYellowLight(true);
}
if(sysPara->status.YellowLightOnFlag){ //报警会时有时无
sysPara->devOp->controlYellowLight(!sysPara->devOp->isYellowLightEnable());
}
if(sysPara->status.waitHightVolOff>0){
sysPara->status.waitHightVolOff--;
if(sysPara->status.waitHightVolOff==0){
sysPara->devOp->highVoltageCtrl(0);
ui->tabMainWindow->setRunStatus(tr("停止打印，自动关闭高压."));
}
}
}// 1s
#ifdef WARNING
static int pre_pressed=0,pre_hvcurrent=0,press_err_cnt=0;
if(pulse_1s)
{
if((pre_pressed > sysPara->status.PRESSURE+70))
{
if(++press_err_cnt>3)
{
LogInfo::setRunStatusText(tr("压力异常:上次压力值%1,当前压力值%2").arg(pre_pressed).arg(sysPara->status.PRESSURE));
}
}
else
{
press_err_cnt = 0;
}
pre_pressed = sysPara->status.PRESSURE;
}
if(pulse_100ms)
{
if(pre_hvcurrent>150 && ( sysPara->status.HV_DETOUT> pre_hvcurrent+20) && (sysPara->status.waitHightVolOn==8 || sysPara->status.waitHightVolOff==1) && sysPara->status.isPrinting )
pre_hvcurrent = sysPara->status.HV_DETOUT;
if(sysPara->status.waitHightVolOn<8)sysPara->status.waitHightVolOn++;
if(sysPara->status.isPrinting==0) sysPara->status.waitHightVolOn=0;
}
#endif
if(sysPara->devOp->color_flag ==3){
sysPara->devOp->color_flag = 0;
pulse_30s = 0;
}
else if(pulse_1s && sysPara->para.gearPumpEnable && sysPara->status.selfCheckDone
&& (!sysPara->status.statWarn) && !sysPara->status.powerOffAppending){
// 隔膜泵速度告警逻辑：检测转速是否异常超过最大工作转速
// 最大工作转速对应的RPM约为：300 * 60 * 1000 / (500 * 2) = 1800 RPM
// 给予余量，告警阈值设为2200 RPM
const int MAX_SPEED_ALARM = 2200;
if(sysPara->status.gearPumpRunSpeed <= MAX_SPEED_ALARM)
{
pulse_30s = 0;
}
else{
pulse_30s++;
if(pulse_30s >= 30){
sysPara->status.flagOfSpeedAlarm = true;
sysPara->devOp->color_flag = 2;
if(pulse_30s % 500 == 0){
LogInfo::setRunStatusText(tr("泵转速异常过高，请立即停机并联系供应商!"));
qDebug()<<"泵转速异常过高，请立即停机并联系供应商!";
}
ui->tabMainWindow->setRunStatus(tr("泵转速异常过高，请立即停机并联系供应商!"));
sysPara->devOp->controlRedLight(true);
if(sysPara->status.isPrinting)
ui->tabMainWindow->on_pushButtonStopPrint_pressed();
}
if(pulse_30s % 10 == 0)
qDebug()<<"粘度: "<<QString::number(sysPara->status.viscosity);
}
}
else if(sysPara->status.statWarn & 0xFE){
sysPara->devOp->color_flag = 3;
pulse_30s = 0;
}
}
//测试代码,发布模式自动忽略
}
void InkJetPrinter::autoControlHeater(){
//100ms
static int tempDly=1830;
if(sysPara->para.heatTime == 0)
sysPara->para.heatTime = 5;
int maxHeatTime = sysPara->para.heatTime * 600;
if(sysPara->para.flagOfContinueHeat)
maxHeatTime = 60* 600;
if(tempDly) tempDly--;
if(tempDly>=1800)
{
if(tempDly==1800)
{
sysPara->status.indoorTemperature = sysPara->status.TEMP_ADIN/4;
sysPara->devOp->pumpValveCtrl(1);
if(sysPara->status.indoorTemperature-35>0)
ui->tabSystemSetting->updateViscosityAdjust((sysPara->status.indoorTemperature-35));
else
ui->tabSystemSetting->updateViscosityAdjust(0);
}
return;
}
if(sysPara->status.TEMP_ADIN/4 < sysPara->para.temperature && sysPara->status.heaterONTimeCnt < MAX_HEATER_TIME){
if(tempDly==0) sysPara->status.heaterONTimeCnt ++;
// if(!sysPara->devOp->isHearterEnable())
sysPara->devOp->controlHeater(true);
if(sysPara->status.heaterONTimeCnt == maxHeatTime)
{
if(sysPara->status.TEMP_ADIN/4 < (sysPara->para.temperature - 2)){
LogInfo::setRunStatusText(tr("警告:加热器长时间无法达到预期温度，故障或设置错误！"));
ui->tabMainWindow->setRunStatus("加热器长时间无法达到预期温度，故障或设置错误！");//20150105 no check
sysPara->devOp->controlHeater(false);
}
else
sysPara->status.heaterONTimeCnt = 0;
}
}
else if(sysPara->status.TEMP_ADIN/4 >= (sysPara->para.temperature + 2)){
if(sysPara->status.heaterONTimeCnt < maxHeatTime)
{
sysPara->status.heaterONTimeCnt = 0;
}
// if(sysPara->devOp->isHearterEnable())
sysPara->devOp->controlHeater(false);
}
}
void InkJetPrinter::cnt1GroupCheck(void)
{
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
static unsigned char lastGroupRunningIndex = 0;
if(sysPara->para.cnt1ByGroupEnalbe)
{
sysPara->devOp->ReadCnt1GroupStatus();
if(lastGroupRunningIndex == sysPara->status.cnt1GroupRunningIndex)
return;
lastGroupRunningIndex = sysPara->status.cnt1GroupRunningIndex;
emit updateCnt1GroupDisp(1);
}
#endif
}
void InkJetPrinter::cntGroupCheck()
{
#ifdef COUNTER1_BY_GROUP /* 分段计米 */
static unsigned char mlastGroupRunningIndex = 0;
if(sysPara->para.cnt1ByGroupEnalbe)
{
sysPara->devOp->ReadCnt1GroupStatus();
if(mlastGroupRunningIndex != sysPara->status.cnt1GroupRunningIndex) {
mlastGroupRunningIndex = sysPara->status.cnt1GroupRunningIndex;
LogInfo::setRunStatusText("Next cnt1 group index: " + QString::number(sysPara->status.cnt1GroupRunningIndex));
}
}
#endif
#ifdef COUNTER2_BY_GROUP /* 分段计米2 */
if(sysPara->para.cnt2ByGroupEnalbe)
{
sysPara->devOp->ReadCnt2GroupStatus();
if(mlastGroupRunningIndex != sysPara->status.cnt2GroupRunningIndex) {
mlastGroupRunningIndex = sysPara->status.cnt2GroupRunningIndex;
LogInfo::setRunStatusText("Next cnt2 group index: " + QString::number(sysPara->status.cnt2GroupRunningIndex));
}
}
#endif
emit sig_updateDisp(1);
}
void InkJetPrinter::autoControlCycleValve()
{
if(!sysPara->status.selfCheckDone || (sysPara->status.flagOfPowerOnMode && sysPara->para.gearPumpEnable)){
// if(!sysPara->devOp->isCycleValveOpen()){ //循环阀 //定时开机循环时隔膜泵不开关循环阀
// sysPara->devOp->controlCycleValve(true);
// }
cycleValveRunForSelfCheck();
if(sysPara->status.flagOfPowerOnMode)
{
if(sysPara->devOp->isMixValveOpen()) { //
sysPara->devOp->controlMixValve(false);
}
}
}
else {
if(sysPara->status.cycleValveOpenCntAfterSWintOff){ // 开循环阀
if(!sysPara->devOp->isCycleValveOpen()){
sysPara->devOp->controlCycleValve(true);
}
sysPara->status.cycleValveOpenCntAfterSWintOff --;
}
else if(sysPara->devOp->isCycleValveOpen()){ // 关循环阀
sysPara->devOp->controlCycleValve(false);
}
}
}
void InkJetPrinter::autoControlValvePump(void)
{
if(sysPara){
if(!sysPara->status.isPumpValveControledByHand){
/*---------------------------------供墨阀--------------------------------------------*/
bool enableFlag = ((sysPara->status.statWarn & WARN_STATUS_INK_SWINT)
|| (sysPara->status.lastRecycleWarn && sysPara->para.RecycleWarnAction) // 2017.8.15版本回收故障关供墨阀问题
|| ( sysPara->status.HVFaultCloseEn ) //高压故障关闭墨线
)?false:true; //墨线开关
if(enableFlag != sysPara->devOp->isInkValveOpen()){
if(enableFlag == false) { //关闭供墨阀的顺序 先开循环阀后关闭供墨阀间
if (sysPara->status.cycleValveOpenCntAfterSWintOff == 0) {
sysPara->status.cycleValveOpenCntAfterSWintOff = MAX_CYCLEVALVE_OPEN_TIME_AFTER_SWITN_OFF;
}
if (sysPara->status.cycleValveOpenCntAfterSWintOff < 60) { //在准备关闭循环阀的时候关闭供墨阀
sysPara->devOp->controlInkValve(enableFlag); //关供墨
sysPara->devOp->controlInkValvePWM(enableFlag); //关供墨
}
}
else { //开供墨阀
if(!sysPara->devOp->isReclaimPumpOpen()) //开供墨阀之前要判断回收泵有没有开，没开就提前打开
{
sysPara->devOp->controlReclaimPump(true, false); // 回收泵开
}
if(!ui->tabMainWindow->m_2sFlag)
{
sysPara->devOp->controlInkValve(enableFlag);
sysPara->devOp->controlInkValvePWM(enableFlag);
}
}
}
if(!sysPara->status.selfCheckDone) {
if(!sysPara->devOp->isCycleValveOpen()) {
sysPara->devOp->controlCycleValve(false);
}
}
else {
autoControlCycleValve();
}
/*----------------------------------泄压阀-------------------------------------------*/
//=====================================================================================================
if(sysPara->status.PRESSURE - sysPara->para.pressure > MAX_PRESSURE_RELEASE_DIFF)
sysPara->status.pressureOverFlowCnt ++;
else
sysPara->status.pressureOverFlowCnt = 0;
if((
sysPara->status.releaseValveOpenApending ||
sysPara->status.pressureOverFlowCnt > 2
) //防止干扰和误动作
&& !sysPara->status.releaseValveDelayCnt)
{
if(!sysPara->devOp->isReleaseValveOpen())
{ //泄压阀
sysPara->devOp->controlReleaseValve(true);
}
sysPara->status.releaseValveDelayCnt = MAX_RELEASE_VALVE_DELAY_CNT;
sysPara->status.releaseValveOpenApending = true;
}
else
{
if(sysPara->devOp->isReleaseValveOpen())
{ //
//sysPara->devOp->controlReleaseValve(false);
}
if(sysPara->status.releaseValveDelayCnt)
sysPara->status.releaseValveDelayCnt --;
if(sysPara->status.PRESSURE < sysPara->para.pressure)
{
sysPara->status.releaseValveOpenApending = false;
if(sysPara->devOp->isReleaseValveOpen()){ sysPara->devOp->controlReleaseValve(false);
}
}
}
/*-----------------------------------主墨泵------------------------------------------*/
if(sysPara->status.SEPTAL_POSITION < (sysPara->para.septalPostion - DIFF_SEPTAL_POSITION))
sysPara->status.septalPositionOverFlowCnt ++;
else
sysPara->status.septalPositionOverFlowCnt = 0;
if(sysPara->status.septalPositionOverFlowCnt > 2 && !sysPara->status.mainInkPumpError){ //主墨泵
if(!sysPara->devOp->isMainInkPumpOpen()){
sysPara->devOp->controlMainInkPump(true);
sysPara->status.mainInkPumpRunTmCnt = 0;
}
else if(sysPara->status.selfCheckDone){
if(sysPara->status.mainInkPumpRunTmCnt < MAX_MAIN_INK_PUMP_RUN_TIME){ //
sysPara->status.mainInkPumpRunTmCnt ++;
}
else {
if(!sysPara->para.gearPumpEnable)
{
sysPara->status.mainInkPumpError = true;
sysPara->devOp->controlMainInkPump(false);
LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!主墨泵故障"));
ui->tabMainWindow->setRunStatus(tr("主墨泵故障!!!"));
}
}
}
}
else if(sysPara->status.SEPTAL_POSITION > sysPara->para.septalPostion){
if(sysPara->devOp->isMainInkPumpOpen())
sysPara->devOp->controlMainInkPump(false);
}
/*-----------------------------------压缩机------------------------------------------*/
if((sysPara->para.pressure - sysPara->status.PRESSURE > MAX_PRESSURE_DIFF) && !sysPara->status.compressPumpError){ //压缩机
if(!sysPara->devOp->isCompressPumpOpen()){
sysPara->devOp->controlCompressPump(true);
sysPara->status.compressPumpRunTmCnt = 0;
}
else if(sysPara->status.selfCheckDone){
if(sysPara->status.compressPumpRunTmCnt < MAX_COMPRESS_PUMP_RUN_TIME){ //如果长时间开压缩机，考虑设备故障
sysPara->status.compressPumpRunTmCnt ++;
}
else {
sysPara->status.compressPumpError = true;
sysPara->devOp->controlCompressPump(false);
if(!sysPara->para.gearPumpEnable)
{
LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!压缩机故障"));
ui->tabMainWindow->setRunStatus(tr("压缩机故障!!!"));
}
}
}
}
else if(sysPara->para.pressure <= sysPara->status.PRESSURE){ //压力到达预期的压力
if(sysPara->devOp->isCompressPumpOpen())
sysPara->devOp->controlCompressPump(false);
}
/*------------------------------------粘度泵,混合阀-----------------------------------------*/
/*-----------------------------每30s打开一次粘度泵以及相关处理--------------------------------------*/
static bool hasDetectedBellow = false; // 检测到下位灯
static bool hasDetectedTop = false; // 检测到上位灯
static int viscosity_low = 0; //统计粘度连续偏低10%次数
static unsigned char Mixing_valve_open = 0; //统计粘度连续偏高5%次数
static unsigned char viscosity_faulty_num = 0; //统计粘度连续偏高13%次数
static bool flag = 0;
if(sysPara->status.cycleValveOpenCntAfterSWintOff) { //关闭墨线的时候要提前开粘度泵
sysPara->status.viscosityDelayCnt = sysPara->para.viscosityPumpInterval*100 + 100;
}
++sysPara->status.viscosityDelayCnt;
int mixer_open_threshold = (105*sysPara->para.viscosity)/100;
int viscosity_faulty_threshold =(113*sysPara->para.viscosity)/100;
if(sysPara->status.viscosityDelayCnt >= sysPara->para.viscosityPumpInterval*100 && flag == 0)
{
flag=1;
if (!sysPara->devOp->isViscosityPumpOpen())
{
sysPara->devOp->controlViscosityPump(true);
viscosity_timer->start(10000);
qDebug()<<"粘度: "<<QString::number(sysPara->status.viscosity);
}
if((sysPara->status.viscosity >= 90*sysPara->para.viscosity/100) && (sysPara->status.viscosity <= mixer_open_threshold))
{
sysPara->status.viscosityFault = 0;
viscosity_low=0;
Mixing_valve_open = 0;
viscosity_faulty_num = 0;
}
if(sysPara->status.viscosity < 90*sysPara->para.viscosity/100)
{
viscosity_low++;
viscosity_faulty_num = 0;
Mixing_valve_open = 0;
}
if(sysPara->status.viscosity > mixer_open_threshold && sysPara->status.viscosity <= viscosity_faulty_threshold)
{
Mixing_valve_open++;
viscosity_low = 0;
viscosity_faulty_num = 0;
}
if(sysPara->status.viscosity > viscosity_faulty_threshold){
Mixing_valve_open++;
viscosity_faulty_num++;
viscosity_low = 0;
}
if((!sysPara->devOp->isMixValveOpen()) && (((Mixing_valve_open > 1) && (!sysPara->para.gearPumpEnable)) || ((Mixing_valve_open > 4) && sysPara->para.gearPumpEnable))) { //
sysPara->devOp->controlMixValve(true);
Mixing_valve_open = 0;
LogInfo::setRunStatusText(tr("添加溶剂:")+QString::number(sysPara->status.viscosity));
qDebug()<<"添加溶剂";
}
if(viscosity_low >= 60)
{
LogInfo::setRunStatusText(tr("警告!!!!!!!!!!!粘度值偏低")+QString::number(sysPara->status.viscosity));
qDebug()<<"粘度值偏低";
sysPara->status.viscosityFault = 2;
if(sysPara->devOp->isMixValveOpen()) {
sysPara->devOp->controlMixValve(false);
}
}
if(viscosity_faulty_num >= 5)
{
LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!粘度偏大故障")+QString::number(sysPara->status.viscosity));
qDebug()<<"粘度偏大故障";
sysPara->status.viscosityFault = 1;
}
}
if((sysPara->status.viscosityDelayCnt >= (sysPara->para.viscosityPumpInterval*100+120)) && flag==1)
{
if(sysPara->devOp->isMixValveOpen()) {
sysPara->devOp->controlMixValve(false);
}
}
if((sysPara->status.viscosityDelayCnt >= (sysPara->para.viscosityPumpInterval*100+130)) && flag==1)
{
if (sysPara->devOp->isViscosityPumpOpen()) {
sysPara->devOp->controlViscosityPump(false);
}
sysPara->status.viscosityDelayCnt = 0;
flag=0;
}
if(sysPara->status.statWarn & WARN_STATUS_VISCOTITY_MEASURE_READY){ //上位灯检测标志位
viscosity_timer->stop();
}
if(sysPara->status.viscosityDelayCnt < sysPara->para.viscosityPumpInterval*100) {
static int detectBelow = 0;
if (++detectBelow%400 == 0) {
if(sysPara->status.statWarn & WARN_STATUS_VISCOTITY_MEASURE_READY)
{
if(sysPara->status.rWarnViscoReady>=15){
sysPara->status.viscosityFault = 1;
sysPara->status.viscosity=0;
if(!firstTime)
qDebug()<<"错误!粘度计下位灯故障."+QString::number(sysPara->status.viscosity);
// LogInfo::setRunStatusText(tr("错误!粘度计下位灯故障.")+QString::number(sysPara->status.viscosity));
hasDetectedBellow = true;
}
else sysPara->status.rWarnViscoReady++;
}
else {
sysPara->status.rWarnViscoReady = 0;
sysPara->status.viscosityFault = 0;
}
}
}
if(hasDetectedBellow && hasDetectedTop)
{
if(sysPara->devOp->isMixValveOpen()) { //
sysPara->devOp->controlMixValve(false); //如果检测不到上下位灯就关掉混合阀
}
}
if(sysPara->status.viscosityFault==0)
{
hasDetectedBellow = false;
hasDetectedTop = false;
}
// }
/*-----------------------------------回收泵------------------------------------------*/
if(!sysPara->status.autoCtlReclaimAfterSWintOff)
{
if(!sysPara->devOp->isReclaimPumpOpen() ){ //回收泵
// ui->tabMainWindow->setRunStatus(tr("全速回收泵!!!"));
sysPara->status.reclaimPumpFullSpeedCnt = 0;
sysPara->devOp->controlReclaimPump(true,true); //先全速，后降速
}
else if(sysPara->status.reclaimPumpFullSpeedCnt <= RECLAIM_PUMP_FULL_SPEED_CNT){
sysPara->status.reclaimPumpFullSpeedCnt ++;
if(sysPara->status.reclaimPumpFullSpeedCnt == RECLAIM_PUMP_FULL_SPEED_CNT){ //降速
// ui->tabMainWindow->setRunStatus(tr("降速回收泵!!!"));
sysPara->devOp->controlReclaimPump(true,false);
}
}
}
/*-----------------------------------------------------------------------------*/
}
}
}
//==========================
// 放在10ms的定时器运行,但和粘度泵工作周期一致
void InkJetPrinter::checkMixValveOpen(){
//混合阀
if(sysPara->status.viscosity>40000){
sysPara->status.viscosityMaxFaultCnt++;
if(sysPara->status.viscosityMaxFaultCnt>5)
{
sysPara->status.viscosityMaxFaultCnt=0;
if(sysPara->status.viscosityFault ==0 ) LogInfo::setRunStatusText(tr("粘度检测异常,粘度值太大!!!"));
sysPara->status.viscosityFault=1;
}
sysPara->status.viscosity=0;
}
int mixer_open_threshold = MAX_VISICOSITY_RATIO*sysPara->para.viscosity/100;
int mixer_open_threshold_high = (MAX_VISICOSITY_RATIO + 11)*sysPara->para.viscosity/100;
if(sysPara->status.viscosity > mixer_open_threshold)
{// 粘度值高报警： 条件＠高于设定值的1.05，时间：120个测量周期
sysPara->status.visocityValueOverflowNum ++;
if(sysPara->status.visocityValueOverflowNum >= (MAX_VISICOSITY_VALUE_OVERFLOW_NUM/3)){
if((sysPara->status.viscosity >= mixer_open_threshold_high)//超出太多加得快，否则隔三下，加一下
|| ((sysPara->status.visocityValueOverflowNum % 3) == 0)){
if(!sysPara->devOp->isMixValveOpen()){ //
sysPara->devOp->controlMixValve(true);
LogInfo::setRunStatusText(tr("混合阀打开2:")+QString::number(sysPara->status.viscosity));
}
}
}
if(sysPara->status.visocityValueOverflowNum > MAX_ALLOW_VISICOSITY_OVERFLOW_NUM){
if(sysPara->status.viscosityFault ==0 )
LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!粘度偏大故障"));
sysPara->status.viscosityFault = 1;
}
}
else if(sysPara->status.viscosity > 90*sysPara->para.viscosity/100){
// 粘度值正常
sysPara->status.visocityValueOverflowNum = 0;
sysPara->status.viscosityFault = 0; // 20160922 粘度低报警不能复位问题
}
else {// 粘度值低报警： 条件＠ 低于设定值的0.9，时间：60个测量周期
sysPara->status.visocityValueOverflowNum ++;
if(sysPara->status.visocityValueOverflowNum > (MAX_ALLOW_VISICOSITY_OVERFLOW_NUM/2)){
if(sysPara->status.viscosityFault ==0 ) LogInfo::setRunStatusText(tr("警告!!!!!!!!!!!粘度值偏低"));
sysPara->status.viscosityFault = 2;
sysPara->status.visocityValueOverflowNum=MAX_ALLOW_VISICOSITY_OVERFLOW_NUM-10;
}
}
}
void InkJetPrinter::checkMixValveClose(){
if(sysPara->devOp->isMixValveOpen()){ // 关闭混合阀
sysPara->devOp->controlMixValve(false);
}
}
//在开机自检过程中交替打开和关闭循环阀
void InkJetPrinter::cycleValveRunForSelfCheck(){
static int cycleValveOpenCnt = 0;
if (++cycleValveOpenCnt%300 > 150) {
if(!sysPara->devOp->isCycleValveOpen()){ //循环阀 开
sysPara->devOp->controlCycleValve(true);
}
}
else {
if(sysPara->devOp->isCycleValveOpen()){ //循环阀 关
sysPara->devOp->controlCycleValve(false);
}
}
}
void InkJetPrinter::onReclaimTankBlock(){
if(sysPara){
ui->tabMainWindow->enableReclaimCtrlButton(true);
sysPara->status.reclaimTankBlockedAppending = true;
if(sysPara->status.powerOffAppending && sysPara->status.powerOffAfterPhaseFaultAppending)
ui->tabMainWindow->checkForPowerOff();
sysPara->status.powerOffAppending = false; //如果有关机动作，终止
}
}
/*
*
* 控制回收槽
*
* */
void InkJetPrinter::detectAndcontrolReclaimTank(){
sysPara->status.currReclaimTankPos =10*sysPara->status.curr_reclaimTankTime;
sysPara->status.reclaimTankBlockedAppending =0;
//qDebug()<<sysPara->status.reclaimTankstatus;
// if(sysPara->status.currReclaimTankPos == 0)
// ui->tabMainWindow->setReBootQtUIEnable(false);
// else
// ui->tabMainWindow->setReBootQtUIEnable(true);
if(sysPara->status.reclaimTankstatus == 0x10) //7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
{
if(sysPara->devOp->isReclaimTankCloseEnable())
{
LogInfo::setRunStatusText(tr("电机故障"));
ui->tabMainWindow->setRunStatus(tr("电机故障"));
sysPara->devOp->controlReclaimTankClose(false);
ui->tabMainWindow->resetReclaimCtrlButtonText();
emit reclaimTankBlock();
}
else {
LogInfo::setRunStatusText(tr("电机故障"));
ui->tabMainWindow->setRunStatus(tr("电机故障!!!"));
if(sysPara->devOp->isReclaimTankOpenEnable())
sysPara->devOp->controlReclaimTankOpen(false);
ui->tabMainWindow->resetReclaimCtrlButtonText();
emit reclaimTankBlock();
}
}
else if(sysPara->status.reclaimTankstatus == 5 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
{
if(sysPara->devOp->isReclaimTankOpenEnable())
sysPara->devOp->controlReclaimTankOpen(false); //到头，关闭
sysPara->status.reclainTankReachEnd = true;
/*应要求去掉多余到信息 LogInfo::setRunStatusText(tr("回收槽到头"));*/
ui->tabMainWindow->setRunStatus(tr("回收槽到头"));
ui->tabMainWindow->enablePrintButton(true); //仅仅在此时能使能打印按钮
ui->tabMainWindow->resetReclaimCtrlButtonText();
// sysPara->devOp->highVoltageCtrl(1);
emit reclaimTankOpenDone();
/*回收槽开关时间校正*/
sysPara->para.reclaimTankTime =( sysPara->status.currReclaimTankPos>120 )? sysPara->status.currReclaimTankPos/10-1:12;
ui->tabSystemSetting->updateReclaimTime( sysPara->para.reclaimTankTime );
qDebug()<<"reclaimTankOpenDone currReclaimTankPos:"<<sysPara->status.currReclaimTankPos;
qDebug()<<"reclaimTankOpenDone curr_reclaimTankTime:"<<sysPara->status.curr_reclaimTankTime;
}
else if(sysPara->status.reclaimTankstatus == 0x11 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
{
sysPara->devOp->controlReclaimTankOpen(false); //卡住，关闭
ui->tabMainWindow->resetReclaimCtrlButtonText();
LogInfo::setRunStatusText(tr("回收槽卡住或者回收槽开关时间设置错误"));
ui->tabMainWindow->setRunStatus(tr("回收槽卡住或者回收槽开关时间设置错误"));
emit reclaimTankBlock();
}
else if(sysPara->status.reclaimTankstatus == 1 || sysPara->status.reclaimTankstatus == 2)//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
{
emit setReclaimTankCurrentPos(sysPara->status.currReclaimTankPos);
sysPara->status.reclaimBlockedCnt = 0;
}
else if(sysPara->status.reclaimTankstatus == 6 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
{
if(sysPara->devOp->isReclaimTankCloseEnable())
sysPara->devOp->controlReclaimTankClose(false); //到头，关闭
/*应要求去掉多余到信息 LogInfo::setRunStatusText(tr("回收槽到头"));*/
ui->tabMainWindow->setRunStatus(tr("回收槽到头"));
//sysPara->status.currReclaimTankPos = 0; //将回收槽的时间置为零
ui->tabMainWindow->resetReclaimCtrlButtonText();
emit reclaimTankCloseDone();
sysPara->status.lastRecycleWarn = 0;
sysPara->status.HVFaultCloseEn=0;
sysPara->status.reclainCloseAppending=false;
sysPara->status.canRunAirPushing = true; //下次开回收槽就执行排气程序
qDebug()<<"reclaimTankCloseDone currReclaimTankPos:"<<sysPara->status.currReclaimTankPos;
qDebug()<<"reclaimTankCloseDone curr_reclaimTankTime:"<<sysPara->status.curr_reclaimTankTime;
}
else if(sysPara->status.reclaimTankstatus == 0x12 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
{
sysPara->devOp->controlReclaimTankOpen(false); //到头，关闭
LogInfo::setRunStatusText(tr("回收槽卡住或者回收槽开关时间设置错误"));
ui->tabMainWindow->setRunStatus(tr("回收槽卡住或者回收槽开关时间设置错误"));
ui->tabMainWindow->resetReclaimCtrlButtonText();
emit reclaimTankBlock();
}
else // if(sysPara->status.reclaimTankstatus == 7 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
{
emit setReclaimTankCurrentPos(sysPara->status.currReclaimTankPos);
}
}
static void controlTabDisplay(QTabWidget *tab,QWidget *page,QString name,int enable){
if(enable){
if(tab->indexOf(page) == -1){
tab->addTab(page,name);
}
}
else {
int index = tab->indexOf(page);
if(index != -1)
tab->removeTab(index);
}
}
static void controlTabDisplay(QTabWidget *tab,QWidget *page,QString name,int enable,int Pos){
if(enable){
if(tab->indexOf(page) == -1){
tab->insertTab(Pos,page,name);
}
}
else {
int index = tab->indexOf(page);
if(index != -1)
tab->removeTab(index);
}
}
void InkJetPrinter::onAuthChanged(int auth){
controlTabDisplay(this,ui->tabSystemSetting,tr("系统设置"),auth&AUTH_DISPLAY_SYSTEM_SETTING);
controlTabDisplay(this,ui->tabSystemManage,tr("系统管理"),auth&AUTH_DISPLAY_SYSTEM_MANAGE);
controlTabDisplay(this,ui->tabOtherInfo,tr("其他信息"),auth& AUTH_DISPLAY_OTHER_INFO);
controlTabDisplay(this,ui->tabLogInfo,tr("日志信息"),auth&AUTH_DISPLAY_LOG_INFO);
controlTabDisplay(this,ui->tabNetworkManager,tr("网络管理"),auth&AUTH_SUPER_USER1);
// controlTabDisplay(this,ui->tabZkEdit,tr("图案编辑"),auth);
ui->tabPrintSetting->updateAuthorization(auth);
ui->tabSystemSetting->updateAuthorization(auth);
ui->tabNetworkManager->updateAuthorization(auth);
}
void InkJetPrinter::onConfigChanged(void){
sysPara->loadParaFromFile();
}
/*
* 这个方法的主要目的是在切换tab时不要弹出输入法
*
*/
void InkJetPrinter::onInkJetPrinterCurrentChanged(int index)
{
QWidget *w = widget(index);
if(w){
QWidget *subWidget = w->focusWidget();
if(subWidget)
subWidget->clearFocus();
}
//if(index == 3||index == 3) //刷新打印设置这个界面
{
ui->tabPrintSetting->update();
}
}
void InkJetPrinter::closeEvent(QCloseEvent *event)
{
event->ignore();
}
void InkJetPrinter::resizeEvent(QResizeEvent *event){
event->ignore();
}
void InkJetPrinter::onChangeTab(QString)
{
this->setCurrentIndex (indexOf( ui->tabPicEdit));
}
void InkJetPrinter::onchangeEditMode(int)
{
if(sysPara){
if(sysPara->para.EditMode == PICFILE) {
insertTab(1,ui->tabPicEdit,tr("信息编辑"));
// controlTabDisplay(this,ui->tabZkEdit,tr("图案编辑"),0);
}
else if(sysPara->para.EditMode == TXTFILE|| sysPara->para.EditMode == SCENE){
controlTabDisplay(this,ui->tabPicEdit,tr("信息编辑"),0);
// controlTabDisplay(this,ui->tabZkEdit,tr("图案编辑"),1,1);
}
ui->tabMainWindow->changeEditMode(sysPara->para.EditMode);
}
else{
}
}
void InkJetPrinter::OnSpeedOver(int mode)
{
if(mode==2){
//emit QMessageBox::warning(NULL,tr("警告"),tr("喷印速度过快或间隔太短！无法喷印完全，自动暂停喷印!!!"));
msgtest->setText(tr("喷印速度过快或间隔太短！无法喷印完全，自动暂停喷印!!!"));
msgtest->show();
}
else if(mode==1){
//emit QMessageBox::warning(NULL,tr("警告"),tr("喷印速度过快或间隔太短！无法喷印完全!!!"));
msgtest->setText(tr("喷印速度过快或间隔太短！无法喷印完全!!!"));
msgtest->show();
}
}
void InkJetPrinter::onPrintErrorStatus(QString s,unsigned int res)
{
if(res==1 || sysPara->status.WorkTimeOut ){
sysPara->status.WorkTimeOut =1;
sysPara->devOp->printCtrl( PRINT_CTRL_STOP);
//emit QMessageBox::warning(NULL,tr("警告"),s);
msgtest->setText(s);
msgtest->show();
}
else if(res==2) {
//emit QMessageBox::warning(NULL,tr("警告"),s);
msgtest->setText(s);
msgtest->show();
}
else if(res==3) { sysPara->status.WorkTimeOut =0; }
}
void InkJetPrinter::OnFinished(int event){
//msgtest->setText(" ");msgtest->show();
Q_UNUSED(event);
msgtest->hide();
}
void InkJetPrinter::OnBoxFinished(int event){
//msgtest->setText(" ");msgtest->show();
Q_UNUSED(event);
msgBox1->hide();
}
unsigned char BCDtoHEX(unsigned char BCD)
{
unsigned char tempData;
tempData = (BCD >> 4) * 10 + (BCD & 0x0F);
return (tempData);
}
void InkJetPrinter::refreshModbusStatus(void)
{
#ifdef MODBUS
if (modbus->getModbusStatus() != 1) {
qDebug()<<"refresh get modbus error";
return;
}
qint16 fileNameSize = QFileInfo(sysPara->para.lastOpenedFileName).fileName().size();
if (fileNameSize) {
if (fileNameSize > 100) {
fileNameSize = 100;
}
}
QString str = QFileInfo(sysPara->para.lastOpenedFileName).fileName();
snprintf((char *)sysPara->modbusStatus.usedFileName, sizeof(sysPara->modbusStatus.usedFileName), "%s",(char *)str.toLatin1().constData());
sysPara->modbusStatus.printStatus = ui->tabMainWindow->getCurrPrintStatus();
memcpy(&sysPara->modbusStatus.curCalendarAndDate, &sysPara->status.calandar_and_dat, sizeof(sysPara->status.calandar_and_dat));
unsigned char tmp[4];
memcpy(&tmp,&sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue,4);
tmp[0] = BCDtoHEX(tmp[0]);
tmp[1] = BCDtoHEX(tmp[1]);
tmp[2] = BCDtoHEX(tmp[2]);
tmp[3] = BCDtoHEX(tmp[3]);
//memcpy(&sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue,&tmp,4);
sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue = tmp[3]*1000000 + tmp[2]*10000+ tmp[1]*100 + tmp[0] ;
//sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue = QString::number(sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue).toUInt(0,16);
sysPara->modbusStatus.curCalendarAndDate.cnt1CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt();
sysPara->modbusStatus.curCalendarAndDate.cnt2CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt();
sysPara->modbusStatus.curCalendarAndDate.cnt1End = sysPara->para.cnt1EndValue;
sysPara->modbusStatus.curCalendarAndDate.cnt2End = sysPara->para.cnt2EndValue;
sysPara->modbusStatus.curCalendarAndDate.cnt2Repeat = sysPara->para.cnt2RepeateValue;
sysPara->modbusStatus.curCalendarAndDate.cnt2InitValue = sysPara->para.cnt2StartValue;
sysPara->modbusStatus.productCnt = sysPara->status.productCnt;
sysPara->modbusStatus.statWarn = sysPara->status.RedLightOnFlag ;
// 显示正在打印内容的行数和列数
int wmax = sysPara->status.currPrintRow;
if (sysPara->para.AlterMode) {
wmax = sysPara->status.currAlterPrintRow;
}
sysPara->modbusStatus.mbCurrPrintRow = wmax;
sysPara->modbusStatus.mbCurrPrintCol = sysPara->status.currPrintCol;
#endif
}
void InkJetPrinter::onModbusWriteCalendar()
{
#ifdef MODBUS
if (modbus->getModbusStatus() == -1) {
qDebug()<<"get modbus error";
return;
}
sysPara->para.cnt1StartValue = sysPara->modbusParas.setCalendar.cnt1CurrValue;
sysPara->para.cnt1EndValue = sysPara->modbusParas.setCalendar.cnt1End;
sysPara->para.cnt1CurrValue = sysPara->modbusParas.setCalendar.cnt1Repeat;
sysPara->para.cnt1StepValue = sysPara->modbusParas.setCalendar.cnt1Step;
sysPara->para.cnt2StartValue = sysPara->modbusParas.setCalendar.cnt2InitValue;
sysPara->para.cnt2EndValue = sysPara->modbusParas.setCalendar.cnt2End;
sysPara->para.cnt2StepValue = sysPara->modbusParas.setCalendar.cnt2Repeat;
sysPara->para.cnt2RepeateValue = sysPara->modbusParas.setCalendar.cnt2Step;
if (sysPara->modbusParas.setCalendar.cntCurrValueInitEnable & 0x02) {
sysPara->status.cnt2CurrentValueInitDoneFlag = 0;
}
if (sysPara->modbusParas.setCalendar.cntCurrValueInitEnable & 0x01) {
sysPara->status.cnt1CurrentValueInitDoneFlag = 0;
}
sysPara->para.cnt1CurrValue = sysPara->modbusParas.setCalendar.cnt1CurrValue;
sysPara->para.cnt2CurrValue = sysPara->modbusParas.setCalendar.cnt2CurrValue;
sysPara->devOp->writeFpgaCalandar(0);
emit updataPara2UI();
#endif
}
void InkJetPrinter::close_jd_timer()
{
timer->stop();
}
void InkJetPrinter::handlePushButtonStartPressed(bool flag)
{
pushButtonStartFlag = flag;
if(flag)
{
PID_init();
}
sysPara->status.gearPumpRunStopFlag = !flag;//齿轮泵开关
}
void InkJetPrinter::handleInitedPID()
{
PID_init();
}
void InkJetPrinter::recievedFile2Save(QString fileName)
{
//qDebug() << "recieveFile2Save:"<<fileName;
QMessageBox::StandardButton ret;
ret = QMessageBox::question(this, tr("提示"),
tr("是否接收新的信息!"),
QMessageBox::Ok | QMessageBox::Cancel);
if (ret == QMessageBox::Ok){
QString sourceName = "/tmp/" + fileName;
QString saveName = DOC_DIR;
saveName = saveName + "/";
saveName = saveName + fileName;
qDebug()<<"sourceName "<<sourceName<<"saveName "<<saveName;
QDir *createfile = new QDir;
bool exist = createfile->exists(saveName);
if (exist)
{
createfile->remove(saveName);
}//end if
QFile::copy ( sourceName,saveName );
emit openFile(saveName,false);
//emit startPrint();确认接收到消息立即打印
//ui->tabMainWindow->getTexteditOption()->onFileOpen(saveName,false);
//ui->tabMainWindow->on_pushButtonStartPrint_pressed();
}
else {
}
}
void InkJetPrinter::viscosity_timerHandler()
{
if(!firstTime)
qDebug()<<"错误!粘度计故障:检测不到上位灯";
// LogInfo::setRunStatusText(tr("错误!粘度计故障:检测不到上位灯"));
viscosity_timer->stop();
firstTime = 0;
}
void InkJetPrinter::disableTabClick(){
this->setDisabled(true);
this->setCurrentIndex(0);
}
void InkJetPrinter::enableInkJetTabClick(bool flag){
this->setEnabled(flag);
}
bool InkJetPrinter::eventFilter(QObject *watched, QEvent *event)
{
if(sysPara->status.flagOfKeyBoardType)
return QTabWidget::eventFilter(watched,event);
QSpinBox *qsb=dynamic_cast<QSpinBox*>(watched);
QLineEdit *qle=dynamic_cast<QLineEdit*>(watched);
QTextEdit *qte=dynamic_cast<QTextEdit*>(watched);
QMouseEvent *me = dynamic_cast<QMouseEvent *>(event);
switch (event->type()){
case QEvent::FocusIn:
if(qsb&&!qsb->isReadOnly()
||qle&&!qle->isReadOnly()
||qte&&!qte->isReadOnly())myInputMethod->updateHandler(1);
break;
case QEvent::FocusOut:
myInputMethod->updateHandler(2);
break;
}
return QTabWidget::eventFilter(watched,event);
}
void InkJetPrinter::sendDataManual(QString cmdstr,QString addrstr,QString datastr,QString lenstr,QString typestr){
qDebug()<<"sendDataManual!!!";
bool ok;
quint8 arr[8]={0xAA,0x02,0x03,0x01,0x11,0x00,0x00,0x55};
int cmd = cmdstr.toInt(&ok,16);
int addr = addrstr.toInt(&ok,16);
int len = lenstr.toInt(&ok,10);
int type = typestr.toInt(&ok,10);
QByteArray data;
data.resize(datastr.length() / 2);
for (int i = 0; i < datastr.length(); i += 2) {
// 提取每两个字符
QString byteString = datastr.mid(i, 2);
// 将16进制字符串转换为unsigned char
bool ok;
unsigned char byte = static_cast<unsigned char>(byteString.toUInt(&ok, 16));
data[i / 2] = byte;
}
// quint16 data1[] = {68, 90, 108, 125, 141, 156, 170, 170, 180, 193, 204, 214};
const char* charData = data.constData();
// 转换为 unsigned char 指针
const unsigned char* unsignedCharData = reinterpret_cast<const unsigned char*>(charData);
}
void InkJetPrinter::slt_showMsg(QString msg)
{
msgtest->setText(msg);
msgtest->show();
LogInfo::setRunStatusText(msg);
}
/*************************FPGA通过串口读取状态赋值给status-start******************************************/
void InkJetPrinter::saveFPGAVersionNum(unsigned int data){
sysPara->status.fpgaVersionNum=data;
}
unsigned char statWarnTempData=0;
void InkJetPrinter::saveFPGAStatus(unsigned char *data){
quint16 len=data[5];
len=len<<8;
len+=data[6];
unsigned char *target= ((unsigned char *)&sysPara->status);
for(int i=0;i<len;i++){
if(i == 17){
statWarnTempData =(data[7+i] & 0x82);
}
else target[i]=data[7+i];
}
if(sysPara->status.dummy != sysPara->status.isPrinting && sysPara->status.selfCheckDone){
sysPara->status.isPrinting = sysPara->status.dummy;
ui->tabMainWindow->updatePrintDisplayLabel();
}
}
void InkJetPrinter::saveFPGAPhaseDetectHighTm(unsigned char *data){
quint16 len=data[5];
len=len<<8;
len+=data[6];
unsigned char *target= ((unsigned char *)&sysPara->status.phaseDetectHighTm);
for(int i=0;i<len;i++){
target[i]=data[7+i];
}
}
static int curCNT1 = 0;
void InkJetPrinter::saveFPGACalandarAndDat(unsigned char *data){
quint16 len=data[5];
len=len<<8;
len+=data[6];
unsigned char *target= ((unsigned char *)&sysPara->status.calandar_and_dat);
for(int i=0;i<len;i++){
target[i]=data[7+i];
}
}
void InkJetPrinter::saveFPGACnt3CurrValue(unsigned char *data){
quint16 len=data[5];
len=len<<8;
len+=data[6];
unsigned char *target= ((unsigned char *)&sysPara->status.Status_Counter3.cnt3CurrValue);
for(int i=0;i<len;i++){
target[i]=data[7+i];
}
}
void InkJetPrinter::saveFPGAXXXDay(unsigned char *data){
quint16 len=data[5];
len=len<<8;
len+=data[6];
unsigned char *target= ((unsigned char *)&sysPara->status.XXXDay);
for(int i=0;i<len;i++){
target[i]=data[7+i];
}
}
void InkJetPrinter::stopSendFPGAData(bool flag){
if(flag)
sysPara->devOp->stopSendDataFPGA = true;
else
sysPara->devOp->stopSendDataFPGA = false;
}
void InkJetPrinter::stopSendSTM32Data(bool flag){
if(flag)
sysPara->devOp->stopSendDataSTM32 = true;
else
sysPara->devOp->stopSendDataSTM32 = false;
}
/*************************FPGA通过串口读取状态赋值给status-end******************************************/
//------------------------------------------------------------------------------------------------------------------------------------------
/*************************STM32通过串口读取状态赋值给status-start******************************************/
void InkJetPrinter::saveSTM32Status(unsigned char *data){
unsigned char *target= ((unsigned char *)&sysPara->status)+0x44;
for(int i=0;i<data[3];i++){
if(i==16){
target[i]=statWarnTempData | (data[4+i] & 0x7c);
}
else target[i]=data[4+i];
}
emit showReclaimTankstatus(sysPara->status.reclaimTankstatus);
emit showMotorIsen(sysPara->status.MOTOR_ISEN,sysPara->status.AD_FIXED);
}
void InkJetPrinter::saveGearPumpVal(unsigned char *data){
unsigned char *target= ((unsigned char *)&sysPara->para.gearPumpValue);
for(int i=0;i<data[3];i++){
target[i]=data[4+i];
}
}
void InkJetPrinter::savePulseCntVal(unsigned char *data){
qint16 speedTemp = 0 ;
speedTemp = data[4+1];
speedTemp = speedTemp << 8;
speedTemp = speedTemp + data[4];
if(speedTemp == 0 && sysPara->para.gearPumpValue > 0)
return;
unsigned char *target= ((unsigned char *)&PulseCnt);
for(int i=0;i<data[3];i++){
target[i]=data[4+i];
}
}
void InkJetPrinter::saveSTM32Version(unsigned char *data){
qDebug()<<"saveSTM32Version";
static unsigned char STM32Verion[3] = {0}; //时间间隔内的脉冲累计数
unsigned char *target= ((unsigned char *)&sysPara->status.stm32Verion);
for(int i=0;i<data[3];i++){
target[i]=data[4+i];
}
sysPara->status.flagOfPowerOnMode = (sysPara->status.stm32Verion>>23) & 0x01;
if(sysPara->status.flagOfPowerOnMode)
sysPara->status.waitPowerOffTime = 18;//半个小时
else
sysPara->status.waitPowerOffTime = 0;
LogInfo::setRunStatusText(tr("flagOfPowerOnMode: %1").arg(sysPara->status.flagOfPowerOnMode));
QString STM32Ver = QString("%1.%2.%3").arg((sysPara->status.stm32Verion>>16)&0x7F)
.arg((sysPara->status.stm32Verion>>8) & 0xFF).arg(sysPara->status.stm32Verion&0xFF);
qDebug()<<"STM32Ver:"<<STM32Ver;
}
void InkJetPrinter::saveSTM32Time(unsigned char *data){
qDebug()<<"saveSTM32Time";
LogInfo::setRunStatusText("saveSTM32Time");
static uint8_t datatime[8] = {0};
unsigned char *target= ((unsigned char *)&datatime);
for(int i=0;i<data[3];i++){
target[i]=data[4+i];
}
if(data[0] != 0){
sysPara->status.stm32Time = true;
}
QString Year = QString::number(datatime[0])+QString::number(datatime[1]);
QString Month = QString("%1").arg(datatime[2], 2, 10, QChar('0'));
QString Day = QString("%1").arg(datatime[3], 2, 10, QChar('0'));
QString Week = QString::number(datatime[4]);
QString Hour = QString("%1").arg(datatime[5], 2, 10, QChar('0'));
QString Minute = QString("%1").arg(datatime[6], 2, 10, QChar('0'));
QString Second = QString("%1").arg(datatime[7], 2, 10, QChar('0'));
QString date = Year+"-"+Month+"-"+Day+" "+Hour+":"+Minute+":"+Second;
qDebug()<<QString("readSTM32Date: %1").arg(date);
LogInfo::setRunStatusText(QString("readSTM32Date: %1").arg(date));
LogInfo::setRunStatusText(QString("readSTM32Week: %1").arg(Week));
ui->tabSystemManage->PowerOnSetTime(date);
}
/*************************STM32通过串口读取状态赋值给status-end******************************************/
void InkJetPrinter::closedSerial(){
if(m_serialThreadFPGA->isRunning()){
m_serialThreadFPGA->quit();
m_serialThreadFPGA->wait();
}
if(m_serialThreadSTM32->isRunning()){
m_serialThreadSTM32->quit();
m_serialThreadSTM32->wait();
}
if(serialFPGA)
delete serialFPGA;
if(serialSTM32)
delete serialSTM32;
}
static int highPressureCnt = 0;
static unsigned int logCnt = 0;
void InkJetPrinter::checkPressureControl(){ //1s
unsigned int alarmPressure = 0;
if(sysPara->para.pressure <= 700)
alarmPressure = 800;
else
alarmPressure = 950;
if(sysPara->status.PRESSURE > alarmPressure)
highPressureCnt++;
else
highPressureCnt = 0;
if(highPressureCnt >= 4 && sysPara->status.PRESSURE > 1000){
QString str = tr("压力过高,请检查管路是否堵塞,然后点击故障恢复按钮");
showMessage(str);
sysPara->para.gearPumpValue = 0;
sysPara->devOp->WriteMoterPump();
sysPara->status.isPumpValveControledByHand = true;
sysPara->devOp->mainInkCtrl();
sysPara->status.flagOfPressureFault = true;
}
}
void InkJetPrinter::showMessage(QString str){
if(logCnt++ % 30 == 0){
LogInfo::setRunStatusText(str);
qDebug()<<str;
}
sysPara->devOp->color_flag = 2;
ui->tabMainWindow->setRunStatus(str);
}
#ifdef __RFID_CARD
void InkJetPrinter::initRFIDManager()
{
if (manager_rfid == nullptr) {
manager_rfid = RFIDManager::instance();
connect(manager_rfid, &RFIDManager::sig_showMsg,
this, &InkJetPrinter::slt_showMsg);
}
}
#endif
void InkJetPrinter::resetPressureCnt(){
logCnt = 0;
highPressureCnt = 0;
}
void InkJetPrinter::pressureAdjustForsystemseeting(){
pressureAdj();
}
void InkJetPrinter::closeSerialFPGA(){
if(m_serialThreadFPGA->isRunning()){
m_serialThreadFPGA->quit();
m_serialThreadFPGA->wait();
}
if(serialFPGA)
delete serialFPGA;
}
void InkJetPrinter::closeSerialSTM32(){
if(m_serialThreadSTM32->isRunning()){
m_serialThreadSTM32->quit();
m_serialThreadSTM32->wait();
}
if(serialSTM32)
delete serialSTM32;
}
void InkJetPrinter::restartSerialPort(){
closeSerialFPGA();
closeSerialSTM32();
serialFPGA = new Serial("/dev/ttyAS5");
serialFPGA->moveToThread(m_serialThreadFPGA);
connect(serialFPGA,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendFPGADate(int,int,unsigned char*,int,int)));
connect(serialFPGA,SIGNAL(resendFPGAData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendFPGADate(int,int,unsigned char*,int,int)));
connect(sysPara->devOp,SIGNAL(sendSerialDataToFPGA(int,int,unsigned char*,int,int)),serialFPGA,SLOT(sendSerialData(int,int,unsigned char*,int,int)),Qt::QueuedConnection);
connect(serialFPGA,SIGNAL(getFPGAVersion(uint)),this,SLOT(saveFPGAVersionNum(uint)));
connect(m_serialThreadFPGA,&QThread::started,serialFPGA,&Serial::startInitSlot);
connect(serialFPGA,SIGNAL(stopSendData(bool)),this,SLOT(stopSendFPGAData(bool)));
connect(serialFPGA,SIGNAL(getFPGAPhaseDetectHighTm(unsigned char*)),this,SLOT(saveFPGAPhaseDetectHighTm(unsigned char*)));
connect(serialFPGA,SIGNAL(getFPGAStatus(unsigned char*)),this,SLOT(saveFPGAStatus(unsigned char*)));
connect(serialFPGA,SIGNAL(getFPGACalandarAndDat(unsigned char*)),this,SLOT(saveFPGACalandarAndDat(unsigned char*)));
connect(serialFPGA,SIGNAL(getFPGACnt3CurrValue(unsigned char*)),this,SLOT(saveFPGACnt3CurrValue(unsigned char*)));
connect(serialFPGA,SIGNAL(getFPGAXXXDay(unsigned char*)),this,SLOT(saveFPGAXXXDay(unsigned char*)));
connect(serialFPGA,SIGNAL(queueSizeFPGA(int)),ui->tabMainWindow,SLOT(showFPGAqueuesize(int)));
connect(serialFPGA,SIGNAL(queueFPGASizeSIG(int)),ui->tabMainWindow,SLOT(showqueueFPGAsize(int)));
connect(serialFPGA, &Serial::FPGABuildDat, this, [this](int buildTime){
sysPara->status.build_dat.builTime = quint16(buildTime);
qDebug() << "FPGA build time: " << buildTime;
});
serialSTM32 = new Serial("/dev/ttyAS2");
serialSTM32->moveToThread(m_serialThreadSTM32);
connect(serialSTM32,SIGNAL(sendQueueData(int,int,unsigned char*,int,int)),sysPara->devOp,SLOT(resendSTM32Date(int,int,unsigned char*,int,int)));
connect(sysPara->devOp,SIGNAL(sendSerialDataToSTM32(int,int,unsigned char*,int,int)),serialSTM32,SLOT(sendSerialData(int,int,unsigned char*,int,int)));
connect(serialSTM32,SIGNAL(getSTM32Status(unsigned char*)),this,SLOT(saveSTM32Status(unsigned char*)));
connect(serialSTM32,SIGNAL(getGearPumpVal(unsigned char*)),this,SLOT(saveGearPumpVal(unsigned char*)));
connect(serialSTM32,SIGNAL(getPulseCnt(unsigned char*)),this,SLOT(savePulseCntVal(unsigned char*)));
connect(serialSTM32,SIGNAL(getSTM32Version(unsigned char*)),this,SLOT(saveSTM32Version(unsigned char*)));
connect(serialSTM32,SIGNAL(getSTM32Time(unsigned char*)),this,SLOT(saveSTM32Time(unsigned char*)));
connect(serialSTM32,SIGNAL(stopSendData(bool)),this,SLOT(stopSendSTM32Data(bool)));
connect(serialSTM32,SIGNAL(powerOffReady()),ui->tabMainWindow,SLOT(powerOffConfirmed()));
connect(m_serialThreadSTM32,&QThread::started,serialSTM32,&Serial::startInitSlot);
connect(serialSTM32,SIGNAL(queueSizeSTM32(int)),ui->tabMainWindow,SLOT(showSTM32queuesize(int)));
connect(serialSTM32, &Serial::STM32Connected, this, [this](bool ok, QString errStr){
if(!ok || !sysPara || !sysPara->devOp) {
return;
}
QTimer::singleShot(1000, this, [this](){
sysPara->devOp->highVoltageCtrl(0);
LogInfo::setRunStatusText("High voltage forced off at app boot");
});
}, Qt::QueuedConnection);
flagOfSerialThreadStratEn = true;
}
Reference in New Issue View Git Blame Copy Permalink