hlp/VX5-DiaphragmPump
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
065b1469982bf6412da70df2ade5fddeb5a6f61e
VX5-DiaphragmPump/InkJetPrinter.cpp
T
kite_lucs 065b146998 hlp:荆州版本
2026-10-19 17:03:47 +08:00

3538 lines
158 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#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));
removeTab(indexOf(ui->tab_pressure));
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);
}
void InkJetPrinter::appendPressureRecord(int pressure, int targetPressure)
{
QTextBrowser *browser = ui->textBrowser; // tab_pressure 里的控件
if (!browser) return;
QString line = QString("[%1] 压力:%2 / 目标:%3 %4")
.arg(QDateTime::currentDateTime().toString("hh:mm:ss.zzz"))
.arg(pressure)
.arg(targetPressure)
.arg(getValvePumpStatusString());
appendLineToBrowser(line);
if (pressure > 700) {
if (!m_pressureAlarmActive) {
m_pressureAlarmActive = true;
QMessageBox::warning(this, tr("超压报警"),
tr("当前压力 %1 超过 700！").arg(pressure));
}
} else {
m_pressureAlarmActive = false;
}
}
void InkJetPrinter::appendLineToBrowser(const QString &line)
{
QTextBrowser *browser = ui->textBrowser;
if (!browser) return;
browser->append(line);
if (browser->document()->blockCount() > 500) {
QTextCursor cursor(browser->document());
cursor.movePosition(QTextCursor::Start);
cursor.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor,
browser->document()->blockCount() - 500);
cursor.removeSelectedText();
}
}
static int numLine = 0;
QString InkJetPrinter::getValvePumpStatusString()
{
if (!sysPara || !sysPara->devOp) return QString();
return QString("[供墨:%1 循环:%2 混合:%3 泄压:%4 回收:%5 粘度:%6 主墨:%7 压缩:%8]-%9")
.arg(sysPara->devOp->isInkValveOpen() ? 1 : 0)
.arg(sysPara->devOp->isCycleValveOpen() ? 1 : 0)
.arg(sysPara->devOp->isMixValveOpen() ? 1 : 0)
.arg(sysPara->devOp->isReleaseValveOpen() ? 1 : 0)
.arg(sysPara->devOp->isReclaimPumpOpen() ? 1 : 0)
.arg(sysPara->devOp->isViscosityPumpOpen() ? 1 : 0)
.arg(sysPara->devOp->isMainInkPumpOpen() ? 1 : 0)
.arg(sysPara->devOp->isCompressPumpOpen() ? 1 : 0)
.arg(numLine++);
}
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.powerOffAppending && !m_powerOffPressureControlActive)
{
u = 0.0f;
sysPara->para.gearPumpValue = 0;
m_pumpState = DPUMP_STOPPED;
m_stateChangeCount = 0;
m_adjSkip = 0;
m_lastActualPressure = 0;
m_startingStepCount = 0;
m_bufValidCount = 0;
for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
m_bufIdx = 0;
sysPara->devOp->WriteMoterPump();
m_powerOffPressureControlActive = true;
}
else if(!sysPara->status.powerOffAppending)
{
m_powerOffPressureControlActive = false;
}
// 故障停机处理
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;
if(sysPara->status.powerOffAppending && target > 650)
target = 650; // 关机压力目标不超过650，不修改用户设定值
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);
// 关机压力上限：超过关机目标10立即停泵，不受状态和800ms切换间隔限制
int hardStopThreshold = sysPara->status.powerOffAppending ? 10 : 80;
if(actual > target + hardStopThreshold)
{
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 = 30.0f;
const float START_SPEED_STEP_MED = 20.0f;
const float START_SPEED_STEP_SMALL = 15.0f;
m_adjSkip++;
// 每1500ms调整一次（15个100ms周期）
if(m_adjSkip < 15) {
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;
}
// === 增量式微调控制（每500ms调整一次）===
m_adjSkip++;
if(m_adjSkip < 5) {
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 = 0.8f;
else if(absErr > 10.0f) maxDelta = 0.4f;
else maxDelta = 0.2f;
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;
}
// 检测手动→自动边沿，恢复压力控制时从停止状态安全重启
if(m_lastByHand && !sysPara->status.isPumpValveControledByHand)
{
ControledSwitchFlag = true;
u = 0.0f;
sysPara->para.gearPumpValue = 0;
sysPara->devOp->WriteMoterPump();
m_pumpState = DPUMP_STOPPED;
m_stateChangeCount = 0;
m_adjSkip = 0;
m_lastActualPressure = 0;
m_startingStepCount = 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)
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 || sysPara->status.powerOffAppending)
{
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;
// 自检完成后管道恢复正常阻力，必须重新从STOPPED状态开始
// 清零 u 和状态机，让系统根据实际压力重新启动
u = 0.0f; // 关键：清零控制量，避免继承自检期间的大转速
sysPara->para.gearPumpValue = 0;
sysPara->devOp->WriteMoterPump(); // 立即停泵
m_pumpState = DPUMP_STOPPED; // 强制进入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 (check_flag) {
LogInfo::setRunStatusText(tr("自检完成!!!"));
ui->tabMainWindow->setRunStatus(tr("自检完成!!!"));
qDebug()<<"自检完成!!!";
check_flag = false;
}
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;
// 重置隔膜泵状态机，适应新模式
u = 0.0f;
pid.integral = 0.0f;
pid.err_last = 0.0f;
sysPara->para.gearPumpValue = 0;
sysPara->devOp->WriteMoterPump();
if(!sysPara->para.flagOfReclaimPumEnable)
sysPara->devOp->controlReclaimPump(false, false);
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.powerOffAppending ||
(!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();
}
// if (pulse_100ms &&
// (sysPara->status.PRESSURE > sysPara->para.pressure + 10
// ||sysPara->status.PRESSURE < sysPara->para.pressure - 10)) {
// //压力记录
// appendPressureRecord(sysPara->status.PRESSURE, sysPara->para.pressure);
// }
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;
if (sysPara->status.airPushingDone && sysPara->status.currReclaimTankPos != 0) {
// 排气结束并放下回收槽以后才允许显示该信息
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->status.airPushingDone) {
// 排气结束并放下回收槽以后才允许显示该信息
ui->tabMainWindow->setRunStatus(tr("回收槽到头"));
}
if(sysPara->devOp->isReclaimTankCloseEnable())
sysPara->devOp->controlReclaimTankClose(false); //到头，关闭
//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