3638 lines
134 KiB
C++
3638 lines
134 KiB
C++
#include "InkJetPrinter.h"
|
|
|
|
#include <QDebug>
|
|
//#include <QTextCursor>
|
|
#include <QElapsedTimer>
|
|
#include "VerBVersion.h"
|
|
#include <QEvent>
|
|
#include "DialogFileOperation.h"
|
|
|
|
#ifdef __RFID_CARD
|
|
#define DETECT_WARNING_TIME 10 //Seconds
|
|
#define RFID_WARNING_INTERVAL 5 //Minutes
|
|
#endif
|
|
|
|
#pragma execution_character_set("utf-8")
|
|
|
|
extern MyInputMethod *myInputMethod;
|
|
extern unsigned char vartypeR;
|
|
static unsigned int PulseCnt = 0; //时间间隔内的脉冲累计数
|
|
InkJetPrinter::InkJetPrinter(QWidget* parent)
|
|
: QWidget(parent)
|
|
{
|
|
system("sudo mv /usr/bin/xfce4-panel /usr/bin/xfce4-panel.bak && sudo tee /usr/bin/xfce4-panel << 'EOF'\n#!/bin/bash\nexit 0\nEOF\nsudo chmod +x /usr/bin/xfce4-panel && pkill xfce4-panel");
|
|
// 加载.ui文件生成的UI界面
|
|
ui.setupUi(this);
|
|
|
|
// 关联原有成员变量到UI控件（保持变量名和原代码一致）
|
|
m_LabelTimer = ui.m_LabelTimer;
|
|
m_StackedWidget = ui.m_StackedWidget;
|
|
|
|
// 初始化业务逻辑（仅保留原init中的非UI创建部分）
|
|
init();
|
|
initRunTimeCtrl();
|
|
#ifdef __RFID_CARD
|
|
initRFIDManager();
|
|
#endif
|
|
//初始化状态机
|
|
initStateManager();
|
|
|
|
QThread::sleep(3);
|
|
qApp->installEventFilter(this);
|
|
|
|
#ifdef ARCH_X86
|
|
setFixedSize(800, 600);
|
|
#endif
|
|
}
|
|
|
|
InkJetPrinter::~InkJetPrinter()
|
|
{
|
|
if(m_serialThreadFPGA->isRunning()){
|
|
m_serialThreadFPGA->requestInterruption();
|
|
m_serialThreadFPGA->quit();
|
|
m_serialThreadFPGA->wait();
|
|
}
|
|
if(m_serialThreadSTM32->isRunning()){
|
|
m_serialThreadSTM32->requestInterruption();
|
|
m_serialThreadSTM32->quit();
|
|
m_serialThreadSTM32->wait();
|
|
}
|
|
if(serialFPGA){
|
|
delete serialFPGA;
|
|
serialFPGA = nullptr;
|
|
}
|
|
if(serialSTM32){
|
|
delete serialSTM32;
|
|
serialSTM32 = nullptr;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::init()
|
|
{
|
|
// 创建自定义子控件（原逻辑不变）
|
|
m_MainWidget = new MainWidget(this);
|
|
m_TestPrintWidget = new TestPrintWidget(this);
|
|
// m_ErCodeSettingsWidget = new ErCodeSettingsWidget(this);
|
|
// m_MainInterfaceWidget = new MainInterfaceWidget(this);
|
|
|
|
m_FontSetWidget = new FontSetWidget(this);
|
|
m_PrintSetting = new PrintSetting(this);
|
|
|
|
m_BarCodeDlg = new QBarCode(this);
|
|
m_QRCodeDlg = new dlgQrCode(this);
|
|
|
|
m_MainInstruction = new MainInstruction(this);
|
|
m_SystemManage = new SystemManage(this);
|
|
m_SystemUpdate = new SystemUpdate(this);
|
|
m_SystemSetting = new SystemSetting(this);
|
|
m_OtherInfo = new OtherInfo(this);
|
|
m_LogInfo = new LogInfo(this);
|
|
m_scheduleShiftsEditor = new ScheduleShiftsEditor(this);
|
|
m_DateVarSet = new DateVarSet(this);
|
|
m_CounterVarSet = new CounterVarSet(this);
|
|
m_dlgFileOperation = new DialogFileOperation(this);
|
|
|
|
connect(m_dlgFileOperation, &DialogFileOperation::openFile, this, &InkJetPrinter::onDlgFileOpen);
|
|
|
|
viscosity_timer = new QTimer();
|
|
connect(viscosity_timer, SIGNAL(timeout()), this, SLOT(viscosity_timerHandler()));
|
|
|
|
msgtest = new QMessageBox(this);
|
|
msgtest->setWindowTitle(tr("提示"));
|
|
connect(msgtest, SIGNAL(finished(int)), this, SLOT(OnFinished(int)));
|
|
|
|
// 我真的不想拉，但是今天状态燃尽了，以后再改了
|
|
m_TestPrintWidget->setPrintSettingWidget(m_PrintSetting);
|
|
|
|
// 初始文件名为 空
|
|
ui.label_currWorkFile->setText("");
|
|
ui.label_currEditFile->setText("");
|
|
|
|
// 信号槽连接（原逻辑完全不变）
|
|
connect(m_MainWidget, &MainWidget::sendButtonClickedSignal, this, &InkJetPrinter::getMainWidgetButtonClickedSlot);
|
|
connect(m_MainWidget,SIGNAL(setDisableAll()),this,SLOT(disableTabClick()));
|
|
connect (m_MainWidget,SIGNAL(CloseJd()),this,SLOT(close_jd_timer()));
|
|
connect(m_MainWidget, &MainWidget::newFileAcquired, this, &InkJetPrinter::createNewJobFile);
|
|
connect(m_TestPrintWidget, &TestPrintWidget::sendButtonClickedSignal, this, &InkJetPrinter::getTestPrintWidgetButtonClickedSlot);
|
|
|
|
// TestPrintWidget::sendButtonClickedSignal(16) 转由 openDatetimeEditor 处理
|
|
connect(m_TestPrintWidget, &TestPrintWidget::sig_showEditDateTime, this, &InkJetPrinter::openDatetimeEditor);
|
|
connect(m_TestPrintWidget, &TestPrintWidget::sig_switchWorkFileRequested, this, &InkJetPrinter::slt_updatePrintContent);
|
|
|
|
// 班时元素与编辑 连接
|
|
connect(m_TestPrintWidget, &TestPrintWidget::sig_showScheduleShiftsEditor, this, &InkJetPrinter::showScheduleShiftsEditor);
|
|
connect(m_scheduleShiftsEditor, &ScheduleShiftsEditor::accepted, this, &InkJetPrinter::onScheduleShiftsEditDone);
|
|
connect(m_scheduleShiftsEditor, &ScheduleShiftsEditor::rejected, [this](){
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
});
|
|
|
|
// connect(m_ErCodeSettingsWidget, &ErCodeSettingsWidget::sendButtonClickedSignal, this, &InkJetPrinter::getErCodeSettingsWidgetButtonClickedSlot);
|
|
// connect(m_MainInterfaceWidget, &MainInterfaceWidget::sendButtonClickedSignal, this, &InkJetPrinter::getErCodeSettingsWidgetButtonClickedSlot);
|
|
connect(m_MainWidget,&MainWidget::showVserionInfo,this,&InkJetPrinter::setShowVserionInfo);
|
|
|
|
connect(m_FontSetWidget,&FontSetWidget::sendButtonClickedSignal,this,&InkJetPrinter::getFontSetWidgetButtonClickedSlot);
|
|
connect(m_PrintSetting,&PrintSetting::sendButtonClickedSignal,this,&InkJetPrinter::getPrintSettingButtonClickedSlot);
|
|
connect(m_MainInstruction,&MainInstruction::sendButtonClickedSignal,this,&InkJetPrinter::getMainInstructWidgetButtonClickedSlot);
|
|
connect(m_SystemManage,&SystemManage::sendButtonClickedSignal,this,&InkJetPrinter::getSystemManageWidgetButtonClickSlot);
|
|
connect(m_SystemSetting,&SystemSetting::sendButtonClickedSignal,this,&InkJetPrinter::getSystemSettingWidgetButtonClickSlot);
|
|
connect(m_OtherInfo,&OtherInfo::sendButtonClickedSignal,this,&InkJetPrinter::getOtherInfoWidgetButtonClickSlot);
|
|
connect(m_LogInfo,&LogInfo::sendButtonClickedSignal,this,&InkJetPrinter::getLogInfoWidgetButtonClickSlot);
|
|
|
|
connect(m_DateVarSet,&DateVarSet::sendButtonClickedSignal,this,&InkJetPrinter::getDateSetWidgetButtonClickSlot);
|
|
//添加计数器，修改计数器
|
|
connect(m_CounterVarSet,&CounterVarSet::sendButtonClickedSignal,this,&InkJetPrinter::getCounterVarSetWidgetButtonClickSlot);
|
|
connect(m_CounterVarSet,&CounterVarSet::sig_updateSelectedCounter,this,&InkJetPrinter::slt_counterVarUpdate);
|
|
|
|
connect(m_MainInstruction,&MainInstruction::newFileBtnClick,m_TestPrintWidget,&TestPrintWidget::on_newfileButton_pressed);
|
|
connect(m_MainInstruction, &MainInstruction::superJmAccepted, this, &InkJetPrinter::resetRFIDStatus);
|
|
// connect(myInputMethod,&MyInputMethod::sendEnterClickedSignal,&TestPrintWidget::onEditItemDone);
|
|
// connect(myInputMethod,SIGNAL(sendEnterClickedSignal()),m_TestPrintWidget,SLOT(onEditItemDone()));
|
|
connect(m_DateVarSet,SIGNAL(backSpaceBtn()),myInputMethod,SLOT(backSapceButtonDel()));
|
|
|
|
connect (m_MainWidget,SIGNAL(repeatInitedPid()),this,SLOT(handleInitedPID()));
|
|
connect(m_MainWidget,SIGNAL(clearPressureFault()),this,SLOT(resetPressureCnt()));
|
|
connect(m_LogInfo,SIGNAL(faultTesumePress()),m_MainWidget,SLOT(onLabelFaultRusumePressed()));
|
|
|
|
// 信号槽：用于修改计数器
|
|
connect(m_TestPrintWidget, &TestPrintWidget::sig_showEditCounter,
|
|
this, &InkJetPrinter::slt_editCounter);
|
|
|
|
// 状态界面
|
|
if (ctrl_loginfo == nullptr) ctrl_loginfo = LogInfoCtrl::instance();
|
|
connect(ctrl_loginfo, &LogInfoCtrl::sig_show, this, [=](){
|
|
getMainWidgetButtonClickedSlot(5);
|
|
m_LogInfo->checkState();
|
|
});
|
|
|
|
SysPara *para = new SysPara();
|
|
sysPara = para;
|
|
m_MainWidget->bindSysPara(para);
|
|
m_FontSetWidget->bindSysPara(para);
|
|
m_PrintSetting->bindSysPara(para);
|
|
m_SystemManage->bindSysPara(para);
|
|
m_SystemSetting->bindSysPara(para);
|
|
m_OtherInfo->bindSysPara(para);
|
|
m_TestPrintWidget->bindSysPara(para);
|
|
m_DateVarSet->bindSysPara(para);
|
|
m_MainInstruction->bindSysPara(para);
|
|
m_BarCodeDlg->bindSysPara(para);
|
|
m_QRCodeDlg->bindSysPara(para);
|
|
m_LogInfo->bindSysPara(para);
|
|
|
|
if(sysPara->para.gearPumpEnable)
|
|
pushButtonStartFlag = true;
|
|
|
|
m_PrintSetting->updateModelToUI();
|
|
m_SystemSetting->updateSysParaToUI();
|
|
m_OtherInfo->updateSysParaToUI();
|
|
m_CounterVarSet->updateSysParaToUI(false);
|
|
|
|
m_SystemManage->loadKeyBoardType();
|
|
|
|
m_FontSetWidget->bindTxTEdit(m_TestPrintWidget->getQTextEdit());
|
|
m_BarCodeDlg->bindTxTEdit(m_TestPrintWidget->getQTextEdit());
|
|
m_QRCodeDlg->bindTxTEdit(m_TestPrintWidget->getQTextEdit());
|
|
m_textEdit = m_TestPrintWidget->getQTextEdit();
|
|
|
|
// 添加子控件到StackedWidget（原逻辑不变）
|
|
m_StackedWidget->addWidget(m_MainWidget);
|
|
m_StackedWidget->addWidget(m_TestPrintWidget);
|
|
// m_StackedWidget->addWidget(m_ErCodeSettingsWidget);
|
|
// m_StackedWidget->addWidget(m_MainInterfaceWidget);
|
|
|
|
m_StackedWidget->addWidget(m_FontSetWidget);
|
|
m_StackedWidget->addWidget(m_BarCodeDlg);
|
|
m_StackedWidget->addWidget(m_QRCodeDlg);
|
|
|
|
m_StackedWidget->addWidget(m_PrintSetting);
|
|
m_StackedWidget->addWidget(m_MainInstruction);
|
|
m_StackedWidget->addWidget(m_SystemManage);
|
|
m_StackedWidget->addWidget(m_SystemUpdate);
|
|
m_StackedWidget->addWidget(m_SystemSetting);
|
|
m_StackedWidget->addWidget(m_OtherInfo);
|
|
m_StackedWidget->addWidget(m_LogInfo);
|
|
m_StackedWidget->addWidget(m_scheduleShiftsEditor);
|
|
m_StackedWidget->addWidget(m_DateVarSet);
|
|
m_StackedWidget->addWidget(m_CounterVarSet);
|
|
|
|
|
|
// 创建 32 线程和 FPGA 线程，并初始化串口
|
|
m_serialThreadFPGA = new QThread;
|
|
m_serialThreadSTM32 = new QThread();
|
|
initSerialPorts();
|
|
|
|
connect(m_SystemManage,SIGNAL(sigToCloseSerialFPGA()),this,SLOT(closeSerialFPGA()));
|
|
connect(m_SystemManage,SIGNAL(sigToCloseSerialSTM32()),this,SLOT(closeSerialSTM32()));
|
|
connect(m_SystemManage,SIGNAL(restartSerial()),this,SLOT(restartSerialPort()));
|
|
connect(m_SystemManage, &SystemManage::rebootAppAcquired, this, &InkJetPrinter::rebootApp);
|
|
|
|
connect(m_SystemManage,SIGNAL(enableClick(bool)),this,SLOT(enableInkJetTabClick(bool)));
|
|
connect(m_SystemManage,SIGNAL(upgradeSTM32(QString)),serialSTM32,SLOT(upgradeSTM32File(QString)));
|
|
connect(serialSTM32,SIGNAL(progress(int,int)),m_SystemManage,SLOT(progressBarControl(int,int)));
|
|
|
|
/*系统更新的信号和槽*/
|
|
connect(m_SystemUpdate,&SystemUpdate::sendProgramSTM32Signal,m_SystemManage,&SystemManage::on_pushButtonProgamSTM32_clicked);
|
|
connect(m_SystemUpdate,&SystemUpdate::sendProgramFPGASignal,m_SystemManage,&SystemManage::on_pushButtonProgamFPGA_clicked);
|
|
connect(m_SystemUpdate,&SystemUpdate::sendUpDateSOFTSignal,m_SystemManage,&SystemManage::on_pushButtonUpdateSoftware_pressed);
|
|
connect(m_SystemUpdate,&SystemUpdate::sendUpDateChARLIBSignal,m_SystemManage,&SystemManage::on_pushButtonUpdateCharLib_pressed);
|
|
connect(m_SystemUpdate,&SystemUpdate::sendButtonClickedSignal,this,&InkJetPrinter::getSystemManageWidgetButtonClickSlot);
|
|
connect(m_SystemUpdate,&SystemUpdate::sig_reboot,this,&InkJetPrinter::rebootApp);
|
|
|
|
// 原注释的默认页面设置（按需启用）
|
|
sysPara->status.machineMac = m_MainInstruction->dlgInputAddr->jd.addr;
|
|
sysPara->para.rfidCountDown = 5;
|
|
|
|
connect(this, &InkJetPrinter::pipingStatusChanged, this, &InkJetPrinter::checkStatusAndStartGearPump, Qt::QueuedConnection);
|
|
|
|
timer = new QTimer();
|
|
connect(timer, SIGNAL(timeout()), this, SLOT(timerHandler()));
|
|
timer->start(10);
|
|
|
|
m_Timer = new QTimer();
|
|
connect(m_Timer, SIGNAL(timeout()), this, SLOT(slt_mTimer()));
|
|
m_Timer->start(10000);
|
|
}
|
|
|
|
// type 1,2: 分别显示计数器1或2的界面
|
|
void InkJetPrinter::slt_editCounter(CounterViewModel vm, bool isChange)
|
|
{
|
|
if (m_CounterVarSet) {
|
|
// m_CounterVarSet->updateSysParaToUI(isChange);
|
|
m_CounterVarSet->setCounterConfig(vm,isChange);
|
|
m_StackedWidget->setCurrentWidget(m_CounterVarSet);
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::slt_warningMaintenance()
|
|
{
|
|
// 距离维护时间结束大于30天，判断运行时间的检测
|
|
if (timeoutDay >= 30) {
|
|
double runHours = sysPara->RFIDPara.runtimeMs / 1000.0 / 60.0 / 60.0;
|
|
double hours = sysPara->RFIDPara.maintenanceHours - runHours;
|
|
QString str;
|
|
if (hours >= 0) {
|
|
str = tr("保养期还有%1小时到期,请及时保养,否则喷码机容易损坏")
|
|
.arg(QString::number(hours, 'f', 2));
|
|
} else {
|
|
hours = hours * (-1);
|
|
str = tr("保养期已超过%1小时,请及时保养,否则喷码机容易损坏")
|
|
.arg(QString::number(hours, 'f', 2));
|
|
}
|
|
msgtest->setText(str);
|
|
msgtest->show();
|
|
LogInfo::setRunStatusText(str);
|
|
return;
|
|
} else {
|
|
warningHandler(CARD_TYPE::MAINTENANCE); // 距离维护时间结束大于30天，判断运行时间的检测
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
void InkJetPrinter::showEvent(QShowEvent *e)
|
|
{
|
|
static bool firstShow = true;
|
|
|
|
QWidget::showEvent(e);
|
|
|
|
if(firstShow) {
|
|
|
|
firstShow = false;
|
|
|
|
static QTimer* fpgaReadyTimer = new QTimer(this);
|
|
fpgaReadyTimer->setInterval(1000);
|
|
connect(fpgaReadyTimer, &QTimer::timeout, this, [this](){
|
|
if(sysPara->status.build_dat.builTime != 0) {
|
|
loadLastWorkAndPreparePrint();
|
|
fpgaReadyTimer->stop();
|
|
fpgaReadyTimer->deleteLater();
|
|
fpgaReadyTimer = nullptr;
|
|
}
|
|
else {
|
|
// qDebug() << "FPGA not connected yet.";
|
|
}
|
|
});
|
|
|
|
fpgaReadyTimer->start();
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::enableInkJetTabClick(bool flag)
|
|
{
|
|
this->setEnabled(flag);
|
|
}
|
|
|
|
void InkJetPrinter::close_jd_timer()
|
|
{
|
|
timer->stop();
|
|
}
|
|
|
|
float PID_realize(float speed);
|
|
|
|
struct _pid{
|
|
float SetSpeed;//定义设定值
|
|
float ActualSpeed;//定义实际值
|
|
float err;//定义偏差值
|
|
float err_last;//定义上一个偏差值
|
|
float Kp,Ki,Kd;//定义比例、积分、微分系数
|
|
float voltage;//定义电压值(控制执行器的变量)
|
|
float integral;//定义积分值
|
|
float integral_max; //积分限幅（根据实际调整）
|
|
}pid;
|
|
|
|
|
|
void PID_init(){
|
|
pid.SetSpeed=0.0;
|
|
pid.ActualSpeed=0.0;
|
|
pid.err=0.0;
|
|
pid.err_last=0.0;
|
|
pid.voltage=0.0;
|
|
pid.integral=0.0;
|
|
pid.Kp=0.21; //0.25
|
|
pid.Ki=0.006; //0.015
|
|
pid.Kd=0.0;
|
|
}
|
|
|
|
static float u = 1.0;
|
|
float PID_realize(float speed, float act){
|
|
unsigned char index = 1;
|
|
pid.SetSpeed=speed;
|
|
pid.ActualSpeed = act;
|
|
pid.err=pid.SetSpeed-pid.ActualSpeed;
|
|
if(u < 900)
|
|
{
|
|
pid.integral+=pid.err;
|
|
}
|
|
|
|
pid.voltage=pid.Kp*pid.err + index*pid.Ki*pid.integral + pid.Kd*(pid.err-pid.err_last);
|
|
pid.err_last=pid.err;
|
|
pid.ActualSpeed =pid.voltage*1.0;
|
|
return pid.ActualSpeed;
|
|
}
|
|
|
|
float PID_realize2(float speed, float act){
|
|
// 增量式 PID：Δu = Kp*(e[k]-e[k-1]) + Ki*e[k]
|
|
pid.Kp = 0.15f;
|
|
pid.Ki = 0.02f;
|
|
pid.Kd = 0.0f;
|
|
pid.SetSpeed = speed;
|
|
pid.ActualSpeed = act;
|
|
pid.err = pid.SetSpeed - pid.ActualSpeed;
|
|
|
|
float delta_u = pid.Kp * (pid.err - pid.err_last)
|
|
+ pid.Ki * pid.err;
|
|
|
|
// 自适应非对称限幅：
|
|
// 压力严重偏高（err < -30）：允许快速减速，限制慢速加速
|
|
// 压力严重偏低（err > 50）：允许正常加速，限制减速（避免过度降速）
|
|
// 接近目标：小步长，平稳调节
|
|
if(pid.err < -30.0f) {
|
|
if(delta_u > 1.0f) delta_u = 1.0f;
|
|
if(delta_u < -6.0f) delta_u = -6.0f;
|
|
} else if(pid.err > 50.0f) {
|
|
if(delta_u > 3.0f) delta_u = 3.0f;
|
|
if(delta_u < -2.0f) delta_u = -2.0f;
|
|
} else {
|
|
if(delta_u > 3.0f) delta_u = 3.0f;
|
|
if(delta_u < -3.0f) delta_u = -3.0f;
|
|
}
|
|
|
|
pid.err_last = pid.err;
|
|
return delta_u;
|
|
}
|
|
|
|
void InkJetPrinter::pressureAdj()
|
|
{
|
|
if(sysPara->status.gearPumpRunStopFlag || sysPara->status.flagOfSpeedAlarm)
|
|
{
|
|
sysPara->para.gearPumpValue = 0;
|
|
u = 0.0f;
|
|
m_rampDone = false;
|
|
m_adjSkip = 0;
|
|
m_lastPressure = 0;
|
|
m_stableCount = 0;
|
|
for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
|
|
m_bufIdx = 0;
|
|
sysPara->devOp->WriteMoterPump();
|
|
return;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
int maxValue = sysPara->para.flagOfReclaimPumEnable ? 420 : 800;
|
|
if(maxValue < 60) maxValue = 60;
|
|
|
|
int maxSpeed = (int)sysPara->para.gearPumpSpeedAlarm;
|
|
|
|
auto clampU = [&]() {
|
|
if(u < 60.0f) u = 60.0f;
|
|
if(u > (float)maxValue) u = (float)maxValue;
|
|
};
|
|
|
|
int actual = sysPara->status.PRESSURE;
|
|
int target = (int)sysPara->para.pressure;
|
|
int cur;
|
|
|
|
// 每次进入都更新滑动平均缓冲（软启动用瞬时值，闭环用平均值）
|
|
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;
|
|
|
|
// ---------------------------------------------------------------
|
|
// 硬保护：压力超过目标+50，立即强制减速，优先级最高
|
|
// 覆盖自检、软启动、闭环所有阶段
|
|
// ---------------------------------------------------------------
|
|
if(actual > target + 50)
|
|
{
|
|
float overErr = (float)(actual - (target + 50));
|
|
float delta = -0.1f * overErr;
|
|
if(delta < -15.0f) delta = -15.0f;
|
|
u += delta;
|
|
clampU();
|
|
m_lastPressure = actual;
|
|
sysPara->para.gearPumpValue = (unsigned short)(int)u;
|
|
sysPara->devOp->WriteMoterPump();
|
|
return;
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// 软启动：自适应步长，每 800ms 一次
|
|
// 自检期间也走此逻辑（硬保护兜底），自检完成后重置重新收敛
|
|
// 软启动阶段不做压力稳定检测，优先快速收敛
|
|
// ---------------------------------------------------------------
|
|
if(!m_rampDone)
|
|
{
|
|
if(++m_adjSkip < 8)
|
|
{
|
|
sysPara->para.gearPumpValue = (unsigned short)(int)u;
|
|
sysPara->devOp->WriteMoterPump();
|
|
return;
|
|
}
|
|
m_adjSkip = 0;
|
|
|
|
int err = target - actual;
|
|
|
|
if(err < 0)
|
|
{
|
|
// 超压：小步减速
|
|
u -= 1.0f;
|
|
}
|
|
else
|
|
{
|
|
// 自适应步长：差得远步子大，差得近步子小
|
|
float step;
|
|
if (err > 200) step = 5.0f;
|
|
else if(err > 100) step = 3.0f;
|
|
else if(err > 50) step = 2.0f;
|
|
else step = 1.0f;
|
|
u += step;
|
|
}
|
|
|
|
clampU();
|
|
|
|
// 转速上限保护
|
|
if(sysPara->para.flagOfReclaimPumEnable &&
|
|
sysPara->status.gearPumpRunSpeed >= maxSpeed)
|
|
{
|
|
u -= 3.0f;
|
|
clampU();
|
|
}
|
|
|
|
cur = (int)u;
|
|
|
|
// 进入闭环条件：压力已稳定在目标±50以内
|
|
if(sysPara->status.selfCheckDone && err >= -50 && err <= 50)
|
|
{
|
|
m_rampDone = true;
|
|
m_adjSkip = 0;
|
|
}
|
|
|
|
sysPara->para.gearPumpValue = (unsigned short)cur;
|
|
sysPara->devOp->WriteMoterPump();
|
|
return;
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// 闭环：等压力稳定后再调速，自适应管路响应时间
|
|
//
|
|
// 每100ms采样一次，连续3次压力变化<15认为稳定，才执行调速
|
|
// 最长等待5s（50次）兜底，防止管路持续抖动导致永远不调
|
|
//
|
|
// 调速后立即重置稳定计数，重新等待下一次稳定
|
|
//
|
|
// 分区Kp：误差大步子大，误差小步子小
|
|
// |err| > 100 → Kp=0.05，限幅±5
|
|
// |err| 50~100→ Kp=0.04，限幅±4
|
|
// |err| < 50 → Kp=0.03，限幅±3
|
|
// ---------------------------------------------------------------
|
|
{
|
|
// 稳定检测用平均值，滤掉传感器噪声
|
|
int pressureChange = avgPressure - m_lastPressure;
|
|
if(pressureChange < 0) pressureChange = -pressureChange;
|
|
m_lastPressure = avgPressure;
|
|
m_adjSkip++; // 复用为超时计数
|
|
|
|
bool stable = (pressureChange < 10);
|
|
bool timeout = (m_adjSkip >= 50); // 5s兜底
|
|
|
|
if(stable)
|
|
m_stableCount++;
|
|
else
|
|
m_stableCount = 0;
|
|
|
|
bool readyToAdj = (m_stableCount >= 15) || timeout;
|
|
|
|
if(!readyToAdj)
|
|
{
|
|
sysPara->para.gearPumpValue = (unsigned short)(int)u;
|
|
sysPara->devOp->WriteMoterPump();
|
|
return;
|
|
}
|
|
|
|
// 平均压力已稳定（或超时兜底），执行调速，重置计数
|
|
m_adjSkip = 0;
|
|
m_stableCount = 0;
|
|
|
|
// 误差用平均值计算，避免瞬时噪声影响调速幅度
|
|
float absErr = (float)(target - avgPressure);
|
|
if(absErr < 0.0f) absErr = -absErr;
|
|
|
|
float kp, capDelta;
|
|
if(absErr > 100.0f) { kp = 0.05f; capDelta = 5.0f; }
|
|
else if(absErr > 50.0f) { kp = 0.04f; capDelta = 4.0f; }
|
|
else { kp = 0.03f; capDelta = 3.0f; }
|
|
|
|
float err = (float)(target - avgPressure);
|
|
float delta_u = kp * err;
|
|
|
|
if(delta_u > capDelta) delta_u = capDelta;
|
|
if(delta_u < -capDelta) delta_u = -capDelta;
|
|
|
|
// 转速上限软限制：转速已达上限时禁止继续加速
|
|
if(sysPara->para.flagOfReclaimPumEnable &&
|
|
sysPara->status.gearPumpRunSpeed >= maxSpeed)
|
|
{
|
|
if(delta_u > 0.0f) delta_u = 0.0f;
|
|
}
|
|
|
|
u += delta_u;
|
|
clampU();
|
|
cur = (int)u;
|
|
|
|
sysPara->para.gearPumpValue = (unsigned short)cur;
|
|
sysPara->devOp->WriteMoterPump();
|
|
}
|
|
}
|
|
|
|
|
|
static bool firstTime = true;
|
|
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 ControledSwitchFlag = false;
|
|
static bool delay3s;
|
|
bool InkSwintFlag = false,lastInkSwintFlag = false;
|
|
static float gearPumpRunNormalValue = 0.0;
|
|
if(sysPara){
|
|
ui.m_LabelTimer->setText(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));
|
|
xxxm=1;
|
|
if(sysPara->para.flagOfModuleDecimal || sysPara->para.flagOfModuleHide){
|
|
sysPara->para.flagOfModuleDecimal = 0;
|
|
sysPara->para.flagOfModuleHide = 0;
|
|
}
|
|
|
|
sysPara->para.ReadFileErrorCnt=0; // 正常打开文件
|
|
|
|
if(sysPara->para.gearPumpEnable)
|
|
{
|
|
// m_MainWidget->enablePushButtonStart(true);
|
|
if(!pushButtonStartFlag)
|
|
{
|
|
gearPumpRunNormalFlag = false;
|
|
}
|
|
if(!gearPumpRunFlag)
|
|
{
|
|
m_MainWidget->setReclaimOpenBtnStatus(false);
|
|
m_MainWidget->setReclaimCloseBtnStatus(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;
|
|
}
|
|
|
|
// static QElapsedTimer *timer_3s_elapsed = nullptr;
|
|
// if(timer_3s_elapsed == nullptr) {
|
|
// timer_3s_elapsed = new QElapsedTimer();
|
|
// timer_3s_elapsed->start();
|
|
// }
|
|
|
|
// if(timer_3s_elapsed->elapsed() >= 3000) //读取状态后再检測
|
|
// {
|
|
// if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN) && !gearPumpRunFlag && !sysPara->status.isPumpValveControledByHand)//刚启动前3秒
|
|
// {
|
|
// if(sysPara->para.gearPumpEnable) {
|
|
// // 确保开机时控制字从 0 开始，让 pressureAdj 软启动从 0 爬坡，避免突变到高转速
|
|
// if(sysPara->para.gearPumpValue != 0) {
|
|
// sysPara->para.gearPumpValue = 0;
|
|
// u = 0.0f;
|
|
// sysPara->devOp->WriteMoterPump();
|
|
// }
|
|
// gearPumpStartFlag = true;
|
|
// }
|
|
// }
|
|
|
|
// timer_3s_elapsed->restart();
|
|
// }
|
|
|
|
if(pushButtonStartFlag && sysPara->status.selfCheckDone)
|
|
{
|
|
if((sysPara->status.PRESSURE > (sysPara->para.pressure -10)) && (sysPara->status.PRESSURE < (sysPara->para.pressure +10)))
|
|
{
|
|
if(pulse_1s)
|
|
{
|
|
|
|
pulse_5s++;
|
|
}
|
|
if( pulse_5s == 5)
|
|
{
|
|
pulse_5s = 0;
|
|
gearPumpRunNormalFlag = true;
|
|
gearPumpRunNormalValue = u;
|
|
}
|
|
}
|
|
}
|
|
if(sysPara->status.isPumpValveControledByHand)
|
|
{
|
|
gearPumpRunNormalFlag = false;
|
|
ControledSwitchFlag = false;
|
|
pulse_3s = 0;
|
|
}
|
|
// 检测手动→自动边沿，直接恢复压力控制，不走 gearPumpStartFlag 的 3s 等待
|
|
if(m_lastByHand && !sysPara->status.isPumpValveControledByHand)
|
|
{
|
|
ControledSwitchFlag = true;
|
|
u = (float)sysPara->para.gearPumpValue; // 同步当前转速，避免突变
|
|
m_rampDone = false; // 重新软启动，适应切换后的压力状态
|
|
m_adjSkip = 0;
|
|
m_lastPressure = 0;
|
|
m_stableCount = 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 count_3s = 0;
|
|
if(u > gearPumpRunNormalValue*1.5)//改大一点
|
|
{
|
|
if(pulse_1s)
|
|
{
|
|
count_3s++;
|
|
if(count_3s == 3)
|
|
{
|
|
count_3s = 0;
|
|
m_MainWidget->setRunStatus(tr("压力泄漏或压力传感器故障!"));
|
|
sysPara->status.gearPumpRunStopFlag = true;
|
|
gearPumpRunNormalFlag = false;
|
|
LogInfo::setRunStatusText(tr("运行中压力泄漏，停齿轮泵!"));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
count_3s = 0;
|
|
}
|
|
}
|
|
if(sysPara->para.gearPumpEnable && (sysPara->status.gearPumpRunSpeed < 100) && test_flag){
|
|
if(test_flag % 2)
|
|
m_MainWidget->on_m_LeftBtn_clicked();
|
|
test_flag = 0;
|
|
}
|
|
|
|
if(pulse_1s) {
|
|
if(sysPara->status.selfCheckDone && sysPara->para.gearPumpEnable && sysPara->para.flagOfReclaimPumEnable)
|
|
checkPressureControl();
|
|
|
|
if((QTime::currentTime()>=QTime(00,00,00))&&(QTime::currentTime()<=QTime(00,00,02))&&sysPara->para.Reciclar){
|
|
if(sysPara->status.isPrinting == false){
|
|
m_MainWidget->_on_pushButtonPowerOff_pressed(false);
|
|
LogInfo::setRunStatusText(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 == 6)
|
|
{
|
|
pulse_3s = 0;
|
|
gearPumpRunFlag = true;
|
|
ControledSwitchFlag = true;
|
|
}
|
|
}
|
|
if( sysPara->status.reclainTankReachEnd) sysPara->para.openInkLineTime++;
|
|
}
|
|
|
|
if(pulse_1s && flagOfSerialThreadStratEn){
|
|
#ifdef ARCH_AARCH64
|
|
if (!m_serialThreadFPGA->isRunning()) {
|
|
qDebug()<<"start FPGA tread";
|
|
m_serialThreadFPGA->start();
|
|
}
|
|
if (!m_serialThreadSTM32->isRunning()){
|
|
qDebug()<<"start STM32 tread";
|
|
m_serialThreadSTM32->start();
|
|
}
|
|
#endif
|
|
flagOfSerialThreadStratEn = false;
|
|
}
|
|
|
|
if(pulse_10s){
|
|
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)
|
|
{
|
|
m_MainWidget->_on_pushButtonPowerOff_pressed(false);
|
|
LogInfo::setRunStatusText(tr("定时开机循环完成，准备关机"));
|
|
m_MainWidget->setRunStatus(tr("准备关机"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------*/
|
|
if(pulse_100ms) {
|
|
sysPara->devOp->stm32Rd(0x07,(unsigned char *)&PulseCnt,2);//读取脉冲个数低字节
|
|
sysPara->devOp->readFgaStatus();
|
|
}
|
|
|
|
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(sysPara->status.isPrinting && sysPara->para.ResetSendData)
|
|
{
|
|
static bool oneTimeFlag = false;
|
|
if(sysPara->status.productCnt== 0 && (oneTimeFlag==false))//计米复位发送打印数据
|
|
{
|
|
oneTimeFlag = true;
|
|
m_MainWidget->on_m_StartBtn_clicked();
|
|
//复位重设起始值
|
|
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;
|
|
|
|
if(vartypeR != 0){ //更新替换变量的值
|
|
MySleep(100);
|
|
m_MainWidget->onPreviewScene();
|
|
m_MainWidget->SendPrintDataToFpga(0);
|
|
}
|
|
|
|
sysPara->modbusStatus.printFinishFlag = 1;
|
|
memcpy((void*)(&sysPara->modbusStatus.orderCode), (void*)(&sysPara->modbusParas.QRcode_buf), 2);//写返回序列号
|
|
// ui->tabMainWindow->UpdateDateTimeQRCode(QDateTime::currentDateTime().toString("hh:mm"));
|
|
}
|
|
|
|
// byons: 时间类型图元更新 @2026年4月11日
|
|
// byons: 变量类图元现在优化为局部更新，避免每次都要把整个打印内容发送给FPGA，现在只发送被更新的列区间 2026年7月16日
|
|
auto updateAreas = m_MainWidget->variableItemsUpdate();
|
|
if(sysPara->status.isPrinting && !updateAreas.isEmpty()){
|
|
m_MainWidget->SendPrintDataToFpga(0, true);
|
|
}
|
|
|
|
if (!updateAreas.isEmpty() && m_StackedWidget->currentWidget() == m_MainWidget) {
|
|
m_MainWidget->updatePrintDisplayLabel();
|
|
}
|
|
|
|
// if (modbus->getModbusStatus() == 1) {
|
|
// refreshModbusStatus();
|
|
// }
|
|
}
|
|
|
|
if(gearPumpRunFlag || sysPara->para.gearPumpEnable == 0)
|
|
{
|
|
if(!sysPara->status.selfCheckDone && sysPara->status.isPrinting){
|
|
m_MainWidget->updatePrintDisplayLabel();
|
|
qDebug()<<"打印过程中死机了!!!";
|
|
|
|
m_MainWidget->on_m_StopBtn_clicked();
|
|
}
|
|
|
|
if(!sysPara->status.selfCheckDone)
|
|
{
|
|
/*开机自检*/
|
|
autoControlValvePump();
|
|
if(pulse_100ms){
|
|
pressureAdj();
|
|
}
|
|
/*-----------------------------------------------------*/
|
|
if(!sysPara->status.selfCheckCnt) {
|
|
LogInfo::setRunStatusText(tr("开始自检,请等待60秒..."));
|
|
|
|
m_MainWidget->setReclaimOpenBtnStatus(false);
|
|
m_MainWidget->setReclaimCloseBtnStatus(false);
|
|
|
|
sysPara->devOp->mainInkCtrl();
|
|
sysPara->para.TrunOnPowerCnt++;// 20151218 开机次数加1
|
|
sysPara->saveParaToFile(); // 保存开机次数值
|
|
|
|
sysPara->status.lastProductCnt = sysPara->status.productCnt ; //这会让产品计数显示出来
|
|
|
|
m_MainWidget->updateTotalCnt(0);
|
|
|
|
|
|
}
|
|
if((++sysPara->status.selfCheckCnt % 100) == 0){
|
|
m_MainWidget->setRunStatus(tr("开始自检,请等待%1秒...").
|
|
arg((MAX_SELF_CHECK_CNT - sysPara->status.selfCheckCnt)/100));
|
|
}
|
|
#ifdef BNS_DEBUG
|
|
if(sysPara->status.selfCheckCnt >= 500) // 测试自检改为5s
|
|
#else
|
|
if(sysPara->status.selfCheckCnt >= MAX_SELF_CHECK_CNT)
|
|
#endif
|
|
{
|
|
// 自检完成 selfCheckDone=true
|
|
// 通过状态管理器发送事件，在 onStateChanged 中更新 sysPara
|
|
if (m_stateManager && m_stateManager->isState(PrinterState::IDLE)) {
|
|
m_stateManager->requestTransition(PrinterEvent::PowerOn);
|
|
}
|
|
|
|
// 自检完成后管道恢复正常阻力，重置软启动让压力重新平稳收敛
|
|
// 不清零 u，从当前控制字开始，避免突变
|
|
u = (float)sysPara->para.gearPumpValue;
|
|
// m_rampDone = false;
|
|
// m_adjSkip = 0;
|
|
// m_lastPressure = 0;
|
|
// m_stableCount = 0;
|
|
autoControlValvePump();
|
|
for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
|
|
m_bufIdx = 0;
|
|
|
|
sysPara->devOp->mainInkCtrl();
|
|
sysPara->status.canRunAirPushing = true;
|
|
|
|
// 自检完成后，关闭高电压，不知道为什么，有时候开机自检都有高压
|
|
sysPara->devOp->highVoltageCtrl(0);
|
|
|
|
if(sysPara->para.Reciclar)
|
|
test_flag = 1;
|
|
}
|
|
|
|
}
|
|
else{
|
|
// 开机自检完成的前提下
|
|
if (!sysPara->status.airPushing || m_MainWidget->m_2sFlag) {
|
|
autoControlValvePump();
|
|
}
|
|
|
|
// 检测回收泵模式切换，切换时重置泄漏保护学习状态和软启动状态
|
|
if(m_lastReclaimMode != sysPara->para.flagOfReclaimPumEnable)
|
|
{
|
|
m_lastReclaimMode = sysPara->para.flagOfReclaimPumEnable;
|
|
gearPumpRunNormalFlag = false; // 泄漏保护重新学习
|
|
gearPumpRunNormalValue = 0.0f;
|
|
m_rampDone = false; // 软启动重新爬坡适应新上限
|
|
m_adjSkip = 0;
|
|
m_lastPressure = 0;
|
|
m_stableCount = 0;
|
|
for(int i = 0; i < 10; i++) m_pressureBuf[i] = 0;
|
|
m_bufIdx = 0;
|
|
}
|
|
|
|
if(pulse_100ms && sysPara->para.gearPumpEnable && !sysPara->status.isPumpValveControledByHand && ControledSwitchFlag ) {
|
|
pressureAdj();
|
|
}
|
|
}
|
|
}
|
|
//自检时不显示报警logo
|
|
else if(m_warn){
|
|
static bool flag = 1;
|
|
if(delay3s){
|
|
if(flag && gearPumpStartFlag){
|
|
flag = 0;
|
|
LogInfo::setRunStatusText(tr("缺少墨水,喷码机不能正常工作!"));
|
|
qDebug()<<"缺少墨水,喷码机不能正常工作!";
|
|
m_MainWidget->setRunStatus(tr("缺少墨水,喷码机不能正常工作!"), true, true);
|
|
}
|
|
}
|
|
}
|
|
/*----------------------------控制温度--------------------------------------*/
|
|
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;
|
|
// m_MainWidget->CheckStatus(pulse_300ms); //
|
|
/*----------------------------------界面更新状态---------------------------------------*/
|
|
#ifdef __RFID_CARD
|
|
static bool flag6 = true;
|
|
unsigned int addr = m_MainInstruction->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
|
|
//reserved
|
|
QWidget *widget = m_StackedWidget->currentWidget();
|
|
if((widget == m_MainWidget || widget == m_LogInfo) && pulse_100ms) {
|
|
m_MainWidget->updateSysStatusToUI();
|
|
m_MainWidget->updateGeneralState(m_MainWidget->alarmStatus);
|
|
m_LogInfo->updateSysStatusToUI(m_MainWidget->alarmStatus);
|
|
}
|
|
|
|
else if(widget == m_PrintSetting)
|
|
{
|
|
m_PrintSetting->updateSysStatusToUI();
|
|
}
|
|
else if(widget == m_SystemSetting){
|
|
|
|
m_SystemSetting->updateSysStatusToUI();
|
|
}
|
|
else if(widget == m_SystemManage){
|
|
m_SystemManage->updateSysStatusToUI();
|
|
}
|
|
else if(widget == m_OtherInfo){
|
|
m_OtherInfo->updateSysStatusToUI();
|
|
}
|
|
// else if(widget == ui->tabNetworkManager){
|
|
// if(!sysPara->status.bLanConfigManual)
|
|
// {
|
|
// ui->tabNetworkManager->updateSysStatusToUI();
|
|
// }
|
|
// }
|
|
|
|
// 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) {
|
|
// m_MainWidget->on_pushButtonPausePrint_pressed();// 2014-03-19
|
|
// ui->tabMainWindow->setRunStatus(tr("喷印速度过快！无法喷印完全，自动暂停喷印!!!"));
|
|
|
|
}
|
|
else {
|
|
// 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 (m_stateManager) {
|
|
m_stateManager->checkReadyState();
|
|
}
|
|
}
|
|
|
|
/*---------------------------------处理警告--------------------------------------------*/
|
|
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
|
|
// hlp 0513 :甲方要求提示越来越频繁
|
|
// if(sysPara->status.needMaintenanceRemind){
|
|
// warningHandler(3);
|
|
// }
|
|
|
|
handleWarnInk(); // 处理墨水警告
|
|
handleWarnSolvent(); // 处理溶剂警告
|
|
#endif
|
|
|
|
static bool resumeFlag = false;
|
|
if(lostCommuFlag || m_MainWidget->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)
|
|
{
|
|
sysPara->status.beeperOnFlag = true;
|
|
if(sysPara->status.gearPumpRunStopFlag && pushButtonStartFlag)
|
|
{
|
|
m_MainWidget->setRunStatus(tr("压力泄漏或压力传感器故障!"));
|
|
}
|
|
if(!resumeFlag)
|
|
{
|
|
resumeFlag = true;
|
|
pulse_4s = 0;
|
|
if(!sysPara->status.lastHighVoltageFault)
|
|
{
|
|
m_MainWidget->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->isBeeperEnable()){ //报警会时有时无
|
|
sysPara->devOp->controlBeeper(true);
|
|
}
|
|
|
|
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);
|
|
m_MainWidget->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){
|
|
if((!sysPara->para.flagOfReclaimPumEnable && sysPara->status.gearPumpRunSpeed <= 2000)
|
|
||(sysPara->para.flagOfReclaimPumEnable && sysPara->status.gearPumpRunSpeed <= sysPara->para.gearPumpSpeedAlarm))
|
|
{
|
|
pulse_30s = 0;
|
|
}
|
|
else{
|
|
pulse_30s++;
|
|
if(pulse_30s >= 30){
|
|
if((sysPara->status.gearPumpRunSpeed >= 2500)||(sysPara->devOp->color_flag == 2)
|
|
||(sysPara->para.flagOfReclaimPumEnable && sysPara->status.gearPumpRunSpeed > sysPara->para.gearPumpSpeedAlarm))
|
|
{
|
|
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)
|
|
m_MainWidget->on_m_StopBtn_clicked();
|
|
}
|
|
else{
|
|
sysPara->devOp->color_flag = 1;
|
|
if(pulse_30s % 500 == 0){
|
|
// LogInfo::setRunStatusText(tr("齿轮泵转速过高，请清理过滤器或者检查是否泄露!"));
|
|
qDebug()<<"齿轮泵转速过高，请清理过滤器或者检查是否泄露!";
|
|
}
|
|
// ui->tabMainWindow->setRunStatus(tr("齿轮泵转速过高，请清理过滤器或者检查是否泄露!"));
|
|
sysPara->devOp->controlYellowLight(true);
|
|
}
|
|
}
|
|
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::slt_mTimer()
|
|
{
|
|
m_warn = true;
|
|
setWarn(m_warn);
|
|
m_Timer->stop();
|
|
}
|
|
|
|
void InkJetPrinter::checkStatusAndStartGearPump()
|
|
{
|
|
// 使用 QElapsedTimer 去抖：要求条件连续保持 >= 2000ms
|
|
if(!sysPara)
|
|
return;
|
|
|
|
bool cond = !(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
|
|
&& !gearPumpRunFlag
|
|
&& !sysPara->status.isPumpValveControledByHand
|
|
&& sysPara->para.gearPumpEnable;
|
|
|
|
if (cond) {
|
|
// 若尚未开始计时，启动计时
|
|
if (!m_pipingClearSince.isValid()) {
|
|
m_pipingClearSince.start();
|
|
return;
|
|
}
|
|
|
|
// 若计时已到达阈值，再次确认条件并执行启动动作
|
|
if (m_pipingClearSince.elapsed() >= 2000) {
|
|
if (!(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
|
|
&& !gearPumpRunFlag
|
|
&& !sysPara->status.isPumpValveControledByHand) {
|
|
if (sysPara->para.gearPumpValue != 0) {
|
|
sysPara->para.gearPumpValue = 0;
|
|
u = 0.0f;
|
|
sysPara->devOp->WriteMoterPump();
|
|
}
|
|
gearPumpStartFlag = true; // 设置标记位，让 timerHandler 启动齿轮泵
|
|
}
|
|
m_pipingClearSince.invalidate();
|
|
}
|
|
} else {
|
|
// 条件不满足，取消计时
|
|
if (m_pipingClearSince.isValid())
|
|
m_pipingClearSince.invalidate();
|
|
}
|
|
}
|
|
|
|
|
|
// 以下槽函数逻辑完全不变
|
|
void InkJetPrinter::getTestPrintWidgetButtonClickedSlot(int index)
|
|
{
|
|
switch (index)
|
|
{
|
|
case 201:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_BarCodeDlg);
|
|
break;
|
|
}
|
|
case 202:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_QRCodeDlg);
|
|
break;
|
|
}
|
|
|
|
case 9:
|
|
{
|
|
m_PrintSetting->updateModelToUI();
|
|
m_StackedWidget->setCurrentWidget(m_PrintSetting);
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_FontSetWidget);
|
|
break;
|
|
}
|
|
case 16:
|
|
{
|
|
// 已经转由 @see InkJetPrinter::openDatetimeEditor 处理
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
// m_StackedWidget->setCurrentWidget(m_CounterVarSet);
|
|
// 转由 @see InkJetPrinter::slt_editCounter 处理
|
|
break;
|
|
}
|
|
case 20:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_MainWidget);
|
|
ui.label_currEditFile->setText("");
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::openDatetimeEditor(DateItemModel dateModel, TextItemModel textItemModel)
|
|
{
|
|
m_DateVarSet->initUI();
|
|
m_DateVarSet->initReplaceValue();
|
|
|
|
m_DateVarSet->setTextItemModel(textItemModel);
|
|
m_DateVarSet->setDateModel(dateModel);
|
|
|
|
m_StackedWidget->setCurrentWidget(m_DateVarSet);
|
|
}
|
|
|
|
void InkJetPrinter::slt_updatePrintContent(const QString &filename)
|
|
{
|
|
loadWorkFileAndPreparePrint(filename);
|
|
}
|
|
|
|
void InkJetPrinter::getFontSetWidgetButtonClickedSlot(int index)
|
|
{
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::getMainWidgetButtonClickedSlot(int index)
|
|
{
|
|
switch (index)
|
|
{
|
|
case 1: { // 编辑当前文件
|
|
|
|
// 如果上次打开的文件不存在或者不是xml文件，则创建一个新的作业文件
|
|
if(currWorkFile.isEmpty()){
|
|
createNewJobFile();
|
|
break;
|
|
}
|
|
|
|
// 如果上次打开的文件存在且是xml文件，则直接打开该文件
|
|
QFileInfo fileInfo(currWorkFile);
|
|
m_TestPrintWidget->openWorkFile(currWorkFile);
|
|
ui.label_currEditFile->setText(QString("E: %1").arg(fileInfo.baseName()));
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
|
|
QVector<int> counterValues{QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt(),
|
|
QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt()};
|
|
m_TestPrintWidget->updateCountersCurrVal(counterValues);
|
|
|
|
break;
|
|
}
|
|
case 2: // 调入文件喷印
|
|
m_dlgFileOperation->setWindowModality(Qt::WindowModal);
|
|
m_dlgFileOperation->refreshListView(SCENE);
|
|
m_dlgFileOperation->show();
|
|
break;
|
|
case 3:
|
|
close();
|
|
break;
|
|
case 4:
|
|
m_StackedWidget->setCurrentWidget(m_MainInstruction);
|
|
break;
|
|
case 5:
|
|
m_StackedWidget->setCurrentWidget(m_LogInfo);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::getPrintSettingButtonClickedSlot(int index){
|
|
if (m_isDefaultPrintSettingMode) {
|
|
exitDefaultPrintSettingMode();
|
|
m_StackedWidget->setCurrentWidget(m_MainInstruction); // 修改完默认设置后，回到MainInstruction
|
|
return;
|
|
}
|
|
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::enterDefaultPrintSettingMode()
|
|
{
|
|
m_savedPrintSettingModel = m_PrintSetting->model();
|
|
m_PrintSetting->setDefaultSettingMode(true);
|
|
m_PrintSetting->setModel(PrintSettingModel::defPrintSettingModel());
|
|
m_isDefaultPrintSettingMode = true;
|
|
m_StackedWidget->setCurrentWidget(m_PrintSetting);
|
|
}
|
|
|
|
void InkJetPrinter::exitDefaultPrintSettingMode()
|
|
{
|
|
m_PrintSetting->setModel(m_savedPrintSettingModel);
|
|
m_PrintSetting->setDefaultSettingMode(false);
|
|
m_isDefaultPrintSettingMode = false;
|
|
}
|
|
|
|
void InkJetPrinter::getMainInstructWidgetButtonClickedSlot(int index)
|
|
{
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_MainWidget);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_SystemManage);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
m_SystemSetting->updateSysParaToUI();
|
|
m_StackedWidget->setCurrentWidget(m_SystemSetting);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_OtherInfo);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_SystemUpdate);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
enterDefaultPrintSettingMode();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::getSystemManageWidgetButtonClickSlot(int index){
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_MainInstruction);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::getSystemUpdateWidgetButtonClickSlot(int index){
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_MainInstruction);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::getSystemSettingWidgetButtonClickSlot(int index){
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_MainInstruction);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::getOtherInfoWidgetButtonClickSlot(int index){
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_MainInstruction);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::getLogInfoWidgetButtonClickSlot(int index){
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_MainWidget);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::getDateSetWidgetButtonClickSlot(int index){
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
// m_TestPrintWidget->onEditItemVarDone();
|
|
DateItemModel model = m_DateVarSet->dateModel();
|
|
const auto textModel = m_DateVarSet->textItemModeL();
|
|
qInfo() << "A new datetime pattern: " << model.datetimePattern;
|
|
qInfo() << "Text model: " << TextItemModel::toString(textModel);
|
|
m_TestPrintWidget->addDateTimeItem(model, textModel);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void InkJetPrinter::getCounterVarSetWidgetButtonClickSlot(int index){
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
{
|
|
CounterViewModel vm = m_CounterVarSet->getCounterConfig();
|
|
m_TestPrintWidget->addCounterItem(vm);
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::slt_counterVarUpdate()
|
|
{
|
|
// m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
}
|
|
|
|
void InkJetPrinter::showScheduleShiftsEditor(QVector<ScheduleModel> schedules, TextItemModel txtModel)
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_scheduleShiftsEditor);
|
|
m_scheduleShiftsEditor->setItemModel(schedules, txtModel);
|
|
}
|
|
|
|
void InkJetPrinter::onScheduleShiftsEditDone()
|
|
{
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
m_TestPrintWidget->addScheduleShiftsItem(m_scheduleShiftsEditor->scheduleModel(), m_scheduleShiftsEditor->textItemModel());
|
|
}
|
|
|
|
bool InkJetPrinter::eventFilter(QObject *watched, QEvent *event)
|
|
{
|
|
|
|
// if(sysPara->status.flagOfKeyBoardType)
|
|
// return QTabWidget::eventFilter(watched,event);
|
|
//qDebug()<<"eventFilter";
|
|
QSpinBox *qsb=dynamic_cast<QSpinBox*>(watched);
|
|
QLineEdit *qle=dynamic_cast<QLineEdit*>(watched);
|
|
QTextEdit *qte=dynamic_cast<QTextEdit*>(watched);
|
|
QWidget *widget = qobject_cast<QWidget *>(watched);
|
|
switch (event->type()){
|
|
case QEvent::FocusIn:
|
|
if(qsb&&!qsb->isReadOnly()||qle&&!qle->isReadOnly()||qte&&!qte->isReadOnly() && watched->objectName() != "inputPreviewBox")
|
|
myInputMethod->updateHandler(1);
|
|
break;
|
|
case QEvent::FocusOut:
|
|
if(watched->objectName() != "inputPreviewBox")
|
|
myInputMethod->updateHandler(2);
|
|
break;
|
|
case QEvent::MouseButtonPress:
|
|
if(widget && !qsb && !qle && !qte && !myInputMethod->shouldIgnoreHideForWidget(widget))
|
|
myInputMethod->clearCurrentFocusAndHide();
|
|
break;
|
|
}
|
|
|
|
return QWidget::eventFilter(watched,event);
|
|
}
|
|
|
|
void InkJetPrinter::initStateManager()
|
|
{
|
|
if (!sysPara) return;
|
|
|
|
// 初始化状态管理器
|
|
m_stateManager = PrinterStateManager::instance();
|
|
|
|
// 连接状态变化信号 DirectConnection:确保相关状态实时更新
|
|
connect(m_stateManager, &PrinterStateManager::sig_stateChanged,
|
|
this, &InkJetPrinter::slt_stateChanged, Qt::DirectConnection);
|
|
// 使能开始打印、停止打印、开回收槽、关回收槽按钮
|
|
connect(m_stateManager, &PrinterStateManager::sig_enableStartPrint,
|
|
this, &InkJetPrinter::slt_enableStartPrint, Qt::DirectConnection);
|
|
connect(m_stateManager, &PrinterStateManager::sig_enableStopPrint,
|
|
this, &InkJetPrinter::slt_enableStopPrint, Qt::DirectConnection);
|
|
connect(m_stateManager, &PrinterStateManager::sig_enableOpenTank,
|
|
this, &InkJetPrinter::slt_enableOpenTank, Qt::DirectConnection);
|
|
connect(m_stateManager, &PrinterStateManager::sig_enableCloseTank,
|
|
this, &InkJetPrinter::slt_enableCloseTank, Qt::DirectConnection);
|
|
// 更新回收槽状态
|
|
connect(m_stateManager, &PrinterStateManager::sig_updateReclaimStatus,
|
|
this, [=](){m_MainWidget->updateReclaimText();});
|
|
// 不能进入准备状态，关回收槽
|
|
connect(m_stateManager, &PrinterStateManager::sig_closeTank,
|
|
this, [=](){m_MainWidget->on_m_LeftBtn_clicked();});
|
|
// 信息
|
|
connect(m_stateManager, &PrinterStateManager::sig_infoMsg,
|
|
this, [=](QString msg){m_MainWidget->setRunStatus(msg);});
|
|
|
|
|
|
// ============ 开机时重置状态 ============
|
|
m_stateManager->initFromSysPara();
|
|
sysPara->status.selfCheckDone = false; // 自检是否完成
|
|
sysPara->status.isPrinting = false; // 是否正在打印
|
|
sysPara->status.powerOffAppending = false; // 是否正在关机
|
|
m_stateManager->bindSysPara(sysPara);
|
|
}
|
|
|
|
void InkJetPrinter::handleSelfCheck()
|
|
{
|
|
// 自检完成，非打印状态，回收槽放下后使能打印按钮
|
|
if (!sysPara->status.selfCheckDone) {
|
|
sysPara->status.selfCheckDone = true;
|
|
LogInfo::setRunStatusText(tr("自检完成!!!"));
|
|
m_MainWidget->setRunStatus(tr("自检完成!!!"));
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::handleReady()
|
|
{
|
|
sysPara->status.isPrinting = false;
|
|
// MySleep(50);
|
|
// m_MainWidget->updateReclaimStatus();
|
|
}
|
|
|
|
void InkJetPrinter::handleStartPrint()
|
|
{
|
|
sysPara->status.isPrinting = true;
|
|
sysPara->status.waitHightVolOff = 0;
|
|
sysPara->status.lastSynColDelay = -1; //目的是为了清空原来的数据
|
|
sysPara->devOp->highVoltageCtrl(1);
|
|
sysPara->devOp->setHighVoltageAmplitudetoSTM32();
|
|
sysPara->devOp->printCtrl(PRINT_CTRL_START);
|
|
// MySleep(50);
|
|
// m_MainWidget->updateReclaimStatus();
|
|
}
|
|
|
|
void InkJetPrinter::handleStopPrint()
|
|
{
|
|
sysPara->status.isPrinting = false;
|
|
sysPara->devOp->printCtrl2(1);
|
|
sysPara->devOp->printCtrl( PRINT_CTRL_STOP);
|
|
sysPara->status.waitHightVolOff = 1;
|
|
sysPara->saveParaToFile(); // 将相关配置保存
|
|
// 停止完毕后再进入就绪状态，允许开始打印
|
|
m_stateManager->requestTransition(PrinterEvent::StopComplete);
|
|
// MySleep(50);
|
|
// m_MainWidget->updateReclaimStatus();
|
|
}
|
|
|
|
void InkJetPrinter::handlePowerOff()
|
|
{
|
|
// m_MainWidget->setRunStatus("正在关机...");
|
|
m_MainWidget->checkForPowerOff();
|
|
}
|
|
|
|
// ============ 状态机槽函数 ============
|
|
void InkJetPrinter::slt_stateChanged(PrinterState newState, PrinterState oldState, QString reason)
|
|
{
|
|
Q_UNUSED(oldState)
|
|
LogInfo::setRunStatusText(reason);
|
|
|
|
// ============ 统一更新 sysPara 状态 ============
|
|
switch (newState) {
|
|
case PrinterState::SELF_CHECK:
|
|
// 进入自检完成状态
|
|
handleSelfCheck();
|
|
LogInfo::setRunStatusText("SELF_CHECK_DONE");
|
|
break;
|
|
|
|
case PrinterState::READY:
|
|
// 进入就绪状态
|
|
handleReady();
|
|
LogInfo::setRunStatusText("READY");
|
|
break;
|
|
|
|
case PrinterState::PRINTING:
|
|
// 进入打印状态
|
|
handleStartPrint();
|
|
LogInfo::setRunStatusText("PRINTING");
|
|
break;
|
|
|
|
case PrinterState::STOPPING:
|
|
// 进入停止状态
|
|
handleStopPrint();
|
|
LogInfo::setRunStatusText("STOPPING");
|
|
break;
|
|
|
|
case PrinterState::ERROR:
|
|
// 进入故障状态
|
|
break;
|
|
|
|
case PrinterState::POWER_OFF:
|
|
// 进入关机状态
|
|
handlePowerOff();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::slt_enableStartPrint(bool able)
|
|
{
|
|
m_MainWidget->enabeleStartBtn(able);
|
|
}
|
|
|
|
void InkJetPrinter::slt_enableStopPrint(bool able)
|
|
{
|
|
m_MainWidget->enabeleStopBtn(able);
|
|
}
|
|
|
|
// 排气过程中不使能
|
|
void InkJetPrinter::slt_enableOpenTank(bool able)
|
|
{
|
|
m_MainWidget->setReclaimOpenBtnStatus(able);
|
|
}
|
|
|
|
void InkJetPrinter::slt_enableCloseTank(bool able)
|
|
{
|
|
m_MainWidget->setReclaimCloseBtnStatus(able);
|
|
}
|
|
|
|
void InkJetPrinter::slt_infoBox(QString msg)
|
|
{
|
|
QMessageBox::information(this, tr("提示"), 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;
|
|
m_MainWidget->updatePrintDisplayLabel();
|
|
emit printStatusChanged(sysPara->status.isPrinting);
|
|
}
|
|
}
|
|
|
|
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];
|
|
}
|
|
|
|
QString hexStr = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue, 16);
|
|
bool ok;
|
|
// sysPara->para.cnt1CurrValue = hexStr.toUInt(&ok, 10);
|
|
|
|
hexStr = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue, 16);
|
|
// sysPara->para.cnt2CurrValue = hexStr.toUInt(&ok, 10);
|
|
}
|
|
|
|
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;
|
|
int len = data[3];
|
|
for(int i=0;i<data[3];i++){
|
|
if(i==16){
|
|
target[i]=statWarnTempData | (data[4+i] & 0x7c);
|
|
}
|
|
else target[i]=data[4+i];
|
|
}
|
|
|
|
// Always emit pipingStatusChanged so checkStatusAndStartGearPump can perform debounce
|
|
emit pipingStatusChanged();
|
|
|
|
// 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));
|
|
m_SystemManage->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;
|
|
}
|
|
|
|
void InkJetPrinter::closeSerialFPGA(){
|
|
if(m_serialThreadFPGA->isRunning()){
|
|
m_serialThreadFPGA->requestInterruption();
|
|
m_serialThreadFPGA->quit();
|
|
m_serialThreadFPGA->wait();
|
|
}
|
|
|
|
if(serialFPGA){
|
|
delete serialFPGA;
|
|
serialFPGA = nullptr;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::closeSerialSTM32(){
|
|
|
|
if(m_serialThreadSTM32->isRunning()){
|
|
|
|
LogInfo::setRunStatusText("Closing STM32 serial port and exit thread...");
|
|
|
|
m_serialThreadSTM32->requestInterruption();
|
|
m_serialThreadSTM32->quit();
|
|
m_serialThreadSTM32->wait();
|
|
}
|
|
if(serialSTM32){
|
|
delete serialSTM32;
|
|
serialSTM32 = nullptr;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::restartSerialPort(){
|
|
|
|
closeSerialFPGA();
|
|
closeSerialSTM32();
|
|
|
|
initSerialPorts();
|
|
}
|
|
|
|
void InkJetPrinter::initSerialPorts()
|
|
{
|
|
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)),this,SLOT(showFPGAqueuesize(int)));
|
|
connect(serialFPGA,SIGNAL(queueFPGASizeSIG(int)),this,SLOT(showqueueFPGAsize(int)));
|
|
connect(serialFPGA, &Serial::FPGABuildDat, this, [this](int buildTime){
|
|
sysPara->status.build_dat.builTime = quint16(buildTime);
|
|
qDebug() << "FPGA build time: " << buildTime;
|
|
LogInfo::setRunStatusText(QString("FPGA build time: %1").arg(buildTime));
|
|
});
|
|
|
|
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()),m_MainWidget,SLOT(powerOffConfirmed()));
|
|
connect(serialSTM32,SIGNAL(queueSizeSTM32(int)),this,SLOT(showSTM32queuesize(int)));
|
|
connect(serialSTM32, &Serial::STM32Connected, this, [this](bool ok, QString errorMsg){
|
|
if(ok){
|
|
LogInfo::setRunStatusText("Connected to STM32 serial port");
|
|
}
|
|
else{
|
|
LogInfo::setRunStatusText("STM32 serial port connection failed: " + errorMsg);
|
|
}
|
|
|
|
// 连接STM32成功一秒后关闭高压。鬼知道它为什么开机就高压
|
|
QTimer::singleShot(1000, this, [this](){
|
|
if(serialSTM32 && sysPara && sysPara->devOp){
|
|
sysPara->devOp->highVoltageCtrl(0);
|
|
LogInfo::setRunStatusText("Close high voltage ctrl");
|
|
}
|
|
});
|
|
});
|
|
|
|
flagOfSerialThreadStratEn = true;
|
|
}
|
|
|
|
void InkJetPrinter::showFPGAqueuesize(int size){
|
|
sysPara->status.sizeFPGA = size;
|
|
}
|
|
|
|
void InkJetPrinter::showSTM32queuesize(int size){
|
|
sysPara->status.sizeSTM32 = size;
|
|
}
|
|
|
|
void InkJetPrinter::showqueueFPGAsize(int size){
|
|
sysPara->status.sizequeueFPGA = size;
|
|
}
|
|
|
|
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(!m_MainWidget->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.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);
|
|
}
|
|
/*-----------------------------------压缩机------------------------------------------*/
|
|
/*reserved
|
|
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);
|
|
}*/
|
|
|
|
/*------------------------------------粘度泵,混合阀-----------------------------------------*/
|
|
|
|
if(sysPara->status.selfCheckDone)
|
|
autoControlViscosityPump();
|
|
else
|
|
autoControlViscosityPumpForSelfCheck(sysPara->status.selfCheckCnt);
|
|
|
|
/*-----------------------------每30s打开一次粘度泵以及相关处理--------------------------------------*/
|
|
|
|
// }
|
|
/*-----------------------------------回收泵------------------------------------------*/
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------------------------*/
|
|
}
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::autoControlViscosityPump()
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::autoControlViscosityPumpForSelfCheck(int selfCheckCnt)
|
|
{
|
|
if(sysPara->devOp->isCycleValveOpen()) {
|
|
sysPara->devOp->controlCycleValve(false);
|
|
}
|
|
|
|
if(sysPara->devOp->isMixValveOpen()) {
|
|
sysPara->devOp->controlMixValve(false);
|
|
}
|
|
|
|
if(selfCheckCnt >= MAX_SELF_CHECK_CNT) {
|
|
|
|
if(sysPara->devOp->isViscosityPumpOpen())
|
|
sysPara->devOp->controlViscosityPump(false);
|
|
|
|
return;
|
|
}
|
|
|
|
int stageCnt = selfCheckCnt % 1000;
|
|
|
|
if(stageCnt >= 0 && stageCnt < 300) {
|
|
if(!sysPara->devOp->isViscosityPumpOpen()) {
|
|
sysPara->devOp->controlViscosityPump(true);
|
|
qDebug() << "Start test viscosity pump.";
|
|
// LogInfo::setRunStatusText("Start test viscosity pump.");
|
|
}
|
|
}
|
|
|
|
if(stageCnt >= 300) {
|
|
if(sysPara->devOp->isViscosityPumpOpen()) {
|
|
sysPara->devOp->controlViscosityPump(false);
|
|
qDebug() << "Stop test viscosity pump.";
|
|
// LogInfo::setRunStatusText("Stop test viscosity pump.");
|
|
}
|
|
}
|
|
}
|
|
|
|
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::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::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 ++;
|
|
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::detectAndcontrolReclaimTank(){
|
|
sysPara->status.currReclaimTankPos =10*sysPara->status.curr_reclaimTankTime;
|
|
sysPara->status.reclaimTankBlockedAppending =0;
|
|
if(sysPara->status.reclaimTankstatus == 0x10) //7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
|
|
{
|
|
LogInfo::setRunStatusText(tr("电机故障"));
|
|
m_MainWidget->setRunStatus(tr("电机故障"));
|
|
if(sysPara->devOp->isReclaimTankCloseEnable())
|
|
{
|
|
sysPara->devOp->controlReclaimTankClose(false);
|
|
}
|
|
else {
|
|
if(sysPara->devOp->isReclaimTankOpenEnable())
|
|
sysPara->devOp->controlReclaimTankOpen(false);
|
|
}
|
|
|
|
m_MainWidget->stopFlashReclaimOpenBtn();
|
|
}
|
|
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;
|
|
m_MainWidget->setRunStatus(tr("回收槽到头"));
|
|
sysPara->devOp->highVoltageCtrl(0);
|
|
|
|
m_MainWidget->stopFlashReclaimOpenBtn();
|
|
|
|
/*回收槽开关时间校正*/
|
|
sysPara->para.reclaimTankTime =( sysPara->status.currReclaimTankPos>120 )? sysPara->status.currReclaimTankPos/10-1:12;
|
|
m_SystemSetting->updateReclaimTime( sysPara->para.reclaimTankTime );
|
|
|
|
LogInfo::setRunStatusText("reclaimTankOpenDone currReclaimTankPos:"+QString::number(sysPara->status.currReclaimTankPos));
|
|
}
|
|
else if(sysPara->status.reclaimTankstatus == 0x11 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
|
|
{
|
|
sysPara->devOp->controlReclaimTankOpen(false); //卡住，关闭
|
|
m_MainWidget->stopFlashReclaimOpenBtn();
|
|
// ui->tabMainWindow->setRunStatus(tr("回收槽卡住或者回收槽开关时间设置错误"));
|
|
}
|
|
else if(sysPara->status.reclaimTankstatus == 1 || sysPara->status.reclaimTankstatus == 2)//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
|
|
{
|
|
// auto recliamTime = (sysPara->para.reclaimTankTime != 0 ? sysPara->para.reclaimTankTime : 15.0f) * 10.0f;
|
|
// int rate = qBound(0, 100, int((sysPara->status.currReclaimTankPos / recliamTime) * 100));
|
|
|
|
if(sysPara->status.reclaimTankstatus != 2) {
|
|
|
|
#ifdef BNS_DEBUG
|
|
if(rate == 100) {
|
|
m_MainWidget->enablePrintButton(true);
|
|
m_MainWidget->stopFlashReclaimOpenBtn();
|
|
sysPara->status.reclaimTankstatus = 5;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
m_MainWidget->setReclaimOpenBtnStatus(sysPara->status.reclaimTankstatus == 2);
|
|
m_MainWidget->setReclaimCloseBtnStatus(sysPara->status.reclaimTankstatus == 1);
|
|
}
|
|
else if(sysPara->status.reclaimTankstatus == 6 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
|
|
{
|
|
if(sysPara->devOp->isReclaimTankCloseEnable())
|
|
sysPara->devOp->controlReclaimTankClose(false); //到头，关闭
|
|
m_MainWidget->stopFlashReclaimOpenBtn();
|
|
sysPara->status.lastRecycleWarn = 0;
|
|
sysPara->status.HVFaultCloseEn=0;
|
|
sysPara->status.reclainCloseAppending=false;
|
|
sysPara->status.canRunAirPushing = true; //下次开回收槽就执行排气程序
|
|
}
|
|
else if(sysPara->status.reclaimTankstatus == 0x12 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
|
|
{
|
|
sysPara->devOp->controlReclaimTankOpen(false); //到头，关闭
|
|
LogInfo::setRunStatusText(tr("回收槽卡住或者回收槽开关时间设置错误"));
|
|
m_MainWidget->setRunStatus(tr("回收槽卡住或者回收槽开关时间设置错误"));
|
|
}
|
|
else if(sysPara->status.reclaimTankstatus == 4 )
|
|
{
|
|
m_MainWidget->setReclaimOpenBtnStatus(true);
|
|
m_MainWidget->setReclaimCloseBtnStatus(true);
|
|
LogInfo::setRunStatusText("Reclaim tank hold on "+QString::number(sysPara->status.currReclaimTankPos));
|
|
}
|
|
|
|
}
|
|
|
|
void InkJetPrinter::viscosity_timerHandler()
|
|
{
|
|
if(!firstTime)
|
|
qDebug()<<"错误!粘度计故障:检测不到上位灯";
|
|
// LogInfo::setRunStatusText(tr("错误!粘度计故障:检测不到上位灯"));
|
|
viscosity_timer->stop();
|
|
firstTime = 0;
|
|
}
|
|
|
|
void InkJetPrinter::rebootApp()
|
|
{
|
|
if(!sysPara->status.selfCheckDone)
|
|
sysPara->status.selfCheckDone = true;
|
|
|
|
this->setDisabled(true);
|
|
|
|
m_StackedWidget->setCurrentWidget(m_MainWidget);
|
|
|
|
// emit setDisableAll();
|
|
if(!TEST_MODE && sysPara->para.flagOfReclaimPumEnable){
|
|
for(int i=15;i>11;i--)
|
|
{
|
|
if(i == 15){
|
|
sysPara->status.isPumpValveControledByHand = true; //停止自动
|
|
sysPara->devOp->controlInkValve(true);
|
|
sysPara->devOp->controlInkValvePWM(true);
|
|
sysPara->devOp->controlReclaimPump(true,true);
|
|
sysPara->devOp->controlViscosityPump(true);
|
|
sysPara->devOp->controlCycleValve(true);
|
|
sysPara->para.gearPumpValue = 0;
|
|
sysPara->devOp->WriteMoterPump();
|
|
}
|
|
if(i == 12){
|
|
sysPara->devOp->controlInkValve(false);
|
|
sysPara->devOp->controlInkValvePWM(false);
|
|
}
|
|
m_MainWidget->setRunStatus(tr("正在准备重启,请等待%1秒......").arg(i), false);
|
|
MySleep(1000);
|
|
}
|
|
}
|
|
sysPara->devOp->controlReclaimTankOpen(true);
|
|
sysPara->status.isPumpValveControledByHand = true; //停止自动
|
|
if(sysPara->para.gearPumpEnable ){
|
|
if(!sysPara->para.flagOfReclaimPumEnable){
|
|
sysPara->para.gearPumpValue = 360;
|
|
sysPara->devOp->WriteMoterPump();
|
|
}
|
|
else{
|
|
sysPara->devOp->controlReclaimPump(true,false);
|
|
sysPara->para.gearPumpValue = 0;
|
|
sysPara->devOp->WriteMoterPump();
|
|
}
|
|
}
|
|
else{
|
|
sysPara->para.reclaimPumpPWMWidth = 95;
|
|
sysPara->devOp->controlReclaimPump(true,true);
|
|
}
|
|
|
|
if(!sysPara->devOp->isViscosityPumpOpen())
|
|
sysPara->devOp->controlViscosityPump(true);
|
|
sysPara->devOp->controlCycleValve(true);
|
|
sysPara->devOp->controlInkValve(false); //关供墨
|
|
sysPara->devOp->controlInkValvePWM(false); //关供墨
|
|
|
|
if(!TEST_MODE){
|
|
for(int i=11;i>7;i--)
|
|
{
|
|
if(i==9)
|
|
sysPara->devOp->controlReclaimTankOpen(false);
|
|
m_MainWidget->setRunStatus(tr("正在准备重启,请等待%1秒......").arg(i), false);
|
|
MySleep(1000);
|
|
}
|
|
}
|
|
|
|
if(!sysPara->status.lostCommuFlag){
|
|
sysPara->para.calandar_and_dat.cnt1CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt1CurrValue,16).toInt();
|
|
sysPara->para.calandar_and_dat.cnt2CurrValue = QString::number(sysPara->status.calandar_and_dat.cnt2CurrValue,16).toInt();
|
|
sysPara->para.Counter3.cnt3CurrValue = QString::number(sysPara->status.Status_Counter3.cnt3CurrValue,16).toInt();
|
|
|
|
m_MainWidget->updateTotalCnt(0);
|
|
sysPara->saveParaToFile(); // 关机前将相关配置保存
|
|
}
|
|
sysPara->status.powerOffAppending = false;
|
|
if(!TEST_MODE){
|
|
for(int i=7;i>0;i--)
|
|
{
|
|
if(i == 5)
|
|
sysPara->devOp->controlReclaimTankClose(true);
|
|
if(i == 4){
|
|
sysPara->devOp->controlViscosityPump(false);
|
|
sysPara->devOp->controlCycleValve(false);
|
|
sysPara->devOp->controlReclaimPump(false,false);
|
|
sysPara->para.gearPumpValue = 0;
|
|
sysPara->devOp->WriteMoterPump();
|
|
}
|
|
m_MainWidget->setRunStatus(tr("正在准备重启,请等待%1秒......").arg(i), false);
|
|
MySleep(1000);
|
|
}
|
|
}
|
|
|
|
sysPara->saveParaToFile(); // 关机前将相关配置保存
|
|
sysPara->saveRFIDPara();
|
|
MySleep(200);
|
|
system("sync");//缓存同步
|
|
QCoreApplication::quit();
|
|
}
|
|
|
|
void InkJetPrinter::handleInitedPID()
|
|
{
|
|
PID_init();
|
|
}
|
|
|
|
|
|
bool InkJetPrinter::loadLastWorkAndPreparePrint()
|
|
{
|
|
// 打开最后一次作业文件
|
|
qDebug() << sysPara->sysFile;
|
|
qDebug() << sysPara->para.lastOpenedFileName;
|
|
QString lastFilename = QString(sysPara->para.lastOpenedFileName);
|
|
|
|
QFileInfo fileInfo(lastFilename);
|
|
if (!(fileInfo.exists() && fileInfo.isFile())) {
|
|
LogInfo::setRunStatusText(QString("Last work file not found: %1").arg(lastFilename));
|
|
return false;
|
|
}
|
|
|
|
return loadWorkFileAndPreparePrint(lastFilename);
|
|
}
|
|
|
|
void InkJetPrinter::restartPrintWhenSwitchedWorkFile(bool isPrinting)
|
|
{
|
|
if(!isPrinting) {
|
|
m_MainWidget->on_m_StartBtn_clicked();
|
|
auto ret = disconnect(this, &InkJetPrinter::printStatusChanged, this, &InkJetPrinter::restartPrintWhenSwitchedWorkFile);
|
|
LogInfo::setRunStatusText(QString("Printing has restarted: %1").arg(ret));
|
|
}
|
|
}
|
|
|
|
bool InkJetPrinter::loadWorkFileAndPreparePrint(const QString &filename)
|
|
{
|
|
auto u8Filename = filename.toUtf8();
|
|
if(u8Filename.size() > int(ARRAY_SIZE(sysPara->para.lastOpenedFileName) - 1)) {
|
|
LogInfo::setRunStatusText(QString("File name is too long: %1").arg(filename));
|
|
return false;
|
|
}
|
|
|
|
PicScene* scene = new PicScene();
|
|
PrintSettingModel model;
|
|
auto ret = PicSceneLoader::loadSceneFromFile(filename, scene, &model);
|
|
if(!ret) {
|
|
LogInfo::setRunStatusText(QString("Failed to load work file: %1").arg(filename));
|
|
delete scene;
|
|
return false;
|
|
}
|
|
|
|
bool rePrint = false;
|
|
if(sysPara->status.isPrinting && sysPara->status.selfCheckDone) {
|
|
// connect(this, &InkJetPrinter::printStatusChanged,
|
|
// this, &InkJetPrinter::restartPrintWhenSwitchedWorkFile, Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
|
|
m_MainWidget->on_m_StopBtn_clicked();
|
|
LogInfo::setRunStatusText("Pause printing first, then write to the new file");
|
|
rePrint = true;
|
|
}
|
|
|
|
PrintSettingModel::applyToSysPara(model, sysPara);
|
|
|
|
ret = m_MainWidget->generatePrintContent(scene, model);
|
|
if(!ret) {
|
|
LogInfo::setRunStatusText(QString("Failed to generate print content from work file: %1").arg(filename));
|
|
delete scene;
|
|
return false;
|
|
}
|
|
|
|
LogInfo::setRunStatusText(QString("Work file loaded: %1").arg(filename));
|
|
|
|
ui.label_currWorkFile->setText(QFileInfo(filename).baseName());
|
|
|
|
strncpy(sysPara->para.lastOpenedFileName, u8Filename.constData(), sizeof(sysPara->para.lastOpenedFileName) - 1);
|
|
sysPara->para.lastOpenedFileName[sizeof(sysPara->para.lastOpenedFileName) - 1] = '\0';
|
|
sysPara->saveParaToFile();
|
|
|
|
currWorkFile = filename;
|
|
|
|
if(rePrint) {
|
|
m_MainWidget->on_m_StartBtn_clicked();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
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;
|
|
m_MainWidget->setRunStatus(str,1,0);
|
|
}
|
|
|
|
void InkJetPrinter::resetPressureCnt(){
|
|
logCnt = 0;
|
|
highPressureCnt = 0;
|
|
}
|
|
|
|
void InkJetPrinter::disableTabClick(){
|
|
this->setDisabled(true);
|
|
// this->setCurrentIndex(0);
|
|
}
|
|
|
|
void InkJetPrinter::setShowVserionInfo(QString str){
|
|
// ui.label_version->setText(str);
|
|
}
|
|
|
|
void InkJetPrinter::OnFinished(int event){
|
|
//msgtest->setText(" ");msgtest->show();
|
|
Q_UNUSED(event);
|
|
msgtest->hide();
|
|
|
|
}
|
|
|
|
|
|
#define INTERVAL_AFTER48H 5
|
|
|
|
void InkJetPrinter::warningHandler(int type){
|
|
static bool flagOfWarning = true;
|
|
static bool flagOfmtWarning = true;
|
|
static int i = 1;
|
|
int elasped = curPowerOnDateTime.secsTo(QDateTime::currentDateTime());// 本次开机运行秒数
|
|
if(elasped >= 60*60*i){ //开机后1小时提醒一次,测试时可以缩短
|
|
// if (elasped > 10*i) {//test
|
|
i++;
|
|
flagOfmtWarning = true;
|
|
flagOfWarning = true;
|
|
LogInfo::setRunStatusText("Next Hour Warning");
|
|
}
|
|
int inkTime = 0, solventTime = 0;
|
|
|
|
/***********处理保养到期提示start******************/
|
|
if(type == CARD_TYPE::MAINTENANCE){
|
|
if(sysPara->RFIDPara.needMaintenance){//保养到期,喷码机禁用
|
|
warningShow(CARD_TYPE::MAINTENANCE,timeoutDay);
|
|
}
|
|
//needMaintenanceRemind:保养到期提前一个月提示标志
|
|
else if(sysPara->status.needMaintenanceRemind){
|
|
if(flagOfmtWarning){
|
|
warningShow(CARD_TYPE::MAINTENANCE,timeoutDay);
|
|
flagOfmtWarning = false;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
/***********处理保养到期提示end******************/
|
|
|
|
// 超过48小时后，不会执行这一段
|
|
if(flagOfWarning){
|
|
//48小时后禁用，小时=第一次提示时间到当前时间的间隔秒数/60/60
|
|
flagOfWarning = false;
|
|
}
|
|
}
|
|
|
|
// 1:Ink 2:Solvent 3:Maintenance
|
|
void InkJetPrinter::warningShow(int type,int num){
|
|
QString str = "";
|
|
if(type == CARD_TYPE::INK && sysPara->RFIDPara.needInkCard){
|
|
if(num < 49)
|
|
str = tr("请刷墨水卡,请使用原厂墨水耗材,否则机器将在%1小时后禁止使用!").arg(num);
|
|
else if(num == 49)
|
|
str = tr("墨水液位报警超过48小时,机器无法正常打印,请先添加原厂墨水再刷墨水卡,以恢复喷码机的正常工作!");
|
|
slt_showMsg(str);
|
|
// m_MainWidget->setRunStatus(str);
|
|
LogInfo::setRunStatusText(str);
|
|
qDebug()<<str;
|
|
}
|
|
else if(type == CARD_TYPE::SOLVENT && sysPara->RFIDPara.needSolventCard){
|
|
if(num < 49)
|
|
str = tr("请刷溶剂卡,请使用原厂溶剂耗材,否则机器将在%1小时后禁止使用!").arg(num);
|
|
else if(num == 49)
|
|
str = tr("溶剂液位报警超过48小时,机器无法正常打印,请先添加溶剂再刷溶剂卡以恢复喷码机的正常工作!");
|
|
slt_showMsg(str);
|
|
// m_MainWidget->setRunStatus(str);
|
|
LogInfo::setRunStatusText(str);
|
|
qDebug()<<str;
|
|
}
|
|
else if(type == CARD_TYPE::MAINTENANCE){
|
|
if(timeoutDay >= 0)
|
|
str = tr("保养期还有%1天到期,请及时保养,否则喷码机容易损坏").arg(num);
|
|
else
|
|
str = tr("保养期已超过%1天,请进行保养以恢复喷码机的正常使用").arg(num*(-1));
|
|
slt_showMsg(str);
|
|
LogInfo::setRunStatusText(str);
|
|
qDebug()<<str;
|
|
}
|
|
}
|
|
/**
|
|
* @brief 创建新的工作文件
|
|
*
|
|
*/
|
|
void InkJetPrinter::createNewJobFile()
|
|
{
|
|
LogInfo::setRunStatusText("Create new job file...");
|
|
qInfo() << "Switch to job edit widget...";
|
|
ui.label_currEditFile->setText(("E: (New file)"));
|
|
m_StackedWidget->setCurrentWidget(m_TestPrintWidget);
|
|
m_TestPrintWidget->on_newfileButton_pressed();
|
|
}
|
|
|
|
int InkJetPrinter::updateWarningTime(int type){
|
|
QFile file;
|
|
if(type == 1)
|
|
file.setFileName("/home/plg/inkRFIDTime.txt");
|
|
else if(type == 2)
|
|
file.setFileName("/home/plg/solventRFIDTime.txt");
|
|
else
|
|
return -1;
|
|
|
|
if(!file.exists()){
|
|
LogInfo::setRunStatusText(tr("刷卡倒计时起始时间文件不存在"));
|
|
return -1;
|
|
}
|
|
|
|
QDateTime curDateTime = QDateTime::currentDateTime();
|
|
int dateTimeDiff = -1;
|
|
if (type == 1) {
|
|
if (inkWarnTime == QDateTime()) {
|
|
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
// 读取文件内容
|
|
QTextStream in(&file);
|
|
QString starTime = in.readAll(); // 第一次提示的时间
|
|
starTime = starTime.trimmed();
|
|
// 关闭文件
|
|
file.close();
|
|
inkWarnTime = QDateTime::fromString(starTime,"yyyy-MM-dd HH::mm::ss");
|
|
qDebug() << inkWarnTime;
|
|
} else {
|
|
qDebug() << "Failed to open file for reading:";
|
|
LogInfo::setRunStatusText("Failed to open file for reading");
|
|
return -1;
|
|
}
|
|
}
|
|
dateTimeDiff = inkWarnTime.secsTo(curDateTime);
|
|
|
|
} else if (type == 2) {
|
|
if (solventWarnTime == QDateTime()) {
|
|
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
// 读取文件内容
|
|
QTextStream in(&file);
|
|
QString starTime = in.readAll(); // 第一次提示的时间
|
|
starTime = starTime.trimmed();
|
|
// 关闭文件
|
|
file.close();
|
|
solventWarnTime = QDateTime::fromString(starTime,"yyyy-MM-dd HH::mm::ss");
|
|
} else {
|
|
qDebug() << "Failed to open file for reading:";
|
|
LogInfo::setRunStatusText("Failed to open file for reading");
|
|
return -1;
|
|
}
|
|
}
|
|
dateTimeDiff = solventWarnTime.secsTo(curDateTime);
|
|
}
|
|
return dateTimeDiff;
|
|
}
|
|
|
|
bool InkJetPrinter::cardTouchConfirm(QString msgTxt, QString variableMsgTxt)
|
|
{
|
|
QMessageBox box(QMessageBox::Warning, tr("警告"),
|
|
msgTxt, QMessageBox::Ok | QMessageBox::Cancel,
|
|
this);
|
|
|
|
int rfidCountDown = sysPara->para.rfidCountDown;
|
|
QTimer msgTimer;
|
|
QString boxTxt = variableMsgTxt;
|
|
connect(&msgTimer, &QTimer::timeout, [this, &box, &rfidCountDown, boxTxt]() {
|
|
box.setText(boxTxt.arg(rfidCountDown));
|
|
box.update();
|
|
rfidCountDown--;
|
|
if(rfidCountDown == 0) {
|
|
box.accept();
|
|
}
|
|
});
|
|
|
|
if(sysPara->para.rfidCountDown > 0) {
|
|
box.setText(boxTxt.arg(sysPara->para.rfidCountDown));
|
|
msgTimer.start(1000);
|
|
}
|
|
|
|
box.exec();
|
|
|
|
return box.result() == QMessageBox::Ok || box.result() == QMessageBox::Accepted;
|
|
}
|
|
|
|
void InkJetPrinter::initRunTimeCtrl()
|
|
{
|
|
if (ctrl_runTime == nullptr) {
|
|
ctrl_runTime = RunTimeCtrl::instance();
|
|
#ifdef __RFID_CARD
|
|
connect(ctrl_runTime, &RunTimeCtrl::sig_updateTimeoutDay, this, [=](int days) {
|
|
// timeoutDay：仅适用于原来月份的处理
|
|
this->timeoutDay = days;
|
|
if(timeoutDay <= 30)
|
|
sysPara->status.needMaintenanceRemind = true;
|
|
});
|
|
connect(ctrl_runTime, &RunTimeCtrl::sig_saveRunTime, this, [=]() {
|
|
// 运行时间处理
|
|
sysPara->RFIDPara.runtimeMs = ctrl_runTime->totalRuntimeMs();
|
|
sysPara->saveRFIDPara();
|
|
});
|
|
|
|
// 弹窗提示
|
|
connect(ctrl_runTime, &RunTimeCtrl::sig_alertTimeout,
|
|
this, &InkJetPrinter::slt_warningMaintenance);
|
|
|
|
curPowerOnDateTime = QDateTime::currentDateTime();
|
|
if (sysPara)
|
|
ctrl_runTime->loadConfig(&sysPara->RFIDPara);
|
|
ctrl_runTime->start();
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
#ifdef __RFID_CARD
|
|
void InkJetPrinter::initRFIDManager()
|
|
{
|
|
if (manager_rfid == nullptr) {
|
|
manager_rfid = RFIDManager::instance();
|
|
}
|
|
|
|
connect(manager_rfid, &RFIDManager::sig_showMsg,
|
|
this, &InkJetPrinter::slt_showMsg);
|
|
connect(manager_rfid,SIGNAL(sig_maintenanceShow()),
|
|
m_MainInstruction,SLOT(maintenanceDialogShow()));
|
|
|
|
connect(manager_rfid, &RFIDManager::sig_inkCardProgressFinished, this, [this](){
|
|
sysPara->RFIDPara.needInkCard = false;
|
|
sysPara->saveRFIDPara();
|
|
|
|
if(!sysPara->RFIDPara.addedInk) {
|
|
slt_showMsg(tr("刷墨水卡成功, 请及时将该墨水卡对应的墨水添加到机器中"));
|
|
}
|
|
else {
|
|
slt_showMsg(tr("刷墨水卡成功!"));
|
|
}
|
|
});
|
|
|
|
connect(manager_rfid, &RFIDManager::sig_solventProgressFinished, this, [this](){
|
|
sysPara->RFIDPara.needSolventCard = false;
|
|
sysPara->saveRFIDPara();
|
|
|
|
if(!sysPara->RFIDPara.addedSolvent) {
|
|
slt_showMsg(tr("刷溶剂卡成功, 请及时将该溶剂卡对应的溶剂添加到机器中"));
|
|
}
|
|
else {
|
|
slt_showMsg(tr("刷溶剂卡成功!"));
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
#define MAX_WARNING_TIME_HOUR 48
|
|
//#define WARNING_INTERVAL_SEC 3600
|
|
#define WARNING_INTERVAL_SEC 10
|
|
|
|
#ifdef BNS_DEBUG
|
|
|
|
#undef MAX_WARNING_TIME_HOUR
|
|
#undef WARNING_INTERVAL_SEC
|
|
|
|
#define MAX_WARNING_TIME_HOUR 10
|
|
#define WARNING_INTERVAL_SEC 20
|
|
|
|
#endif
|
|
|
|
void InkJetPrinter::resetRFIDStatus()
|
|
{
|
|
if(!sysPara)
|
|
return;
|
|
|
|
// 停止刷卡请求
|
|
if(manager_rfid) {
|
|
manager_rfid->requireInkCard(false);
|
|
manager_rfid->requireSolventCard(false);
|
|
}
|
|
|
|
sysPara->RFIDPara.needInkCard = false;
|
|
sysPara->RFIDPara.needSolventCard = false;
|
|
|
|
sysPara->RFIDPara.inkCardTimeOut = false;
|
|
sysPara->RFIDPara.solventCardTimeOut = false;
|
|
|
|
sysPara->saveRFIDPara();
|
|
sysPara->saveParaToFile();
|
|
|
|
LogInfo::setRunStatusText("RFID/ink/solvent flows terminated by resetRFIDStatus");
|
|
QMessageBox::information(this, "", "RFID progress has been cleaned.", QMessageBox::Ok);
|
|
}
|
|
|
|
void InkJetPrinter::slt_close(bool height)
|
|
{
|
|
QString str = "";
|
|
if (height) {
|
|
str = tr("粘度过高,即将关闭喷嘴");
|
|
} else {
|
|
str = tr("粘度过低,即将关闭喷嘴");
|
|
}
|
|
if (sysPara && sysPara->status.selfCheckDone) {
|
|
QMessageBox::warning(this, tr("警告"), str);
|
|
if (sysPara->status.reclainTankReachEnd || sysPara->status.reclaimTankstatus == 1) {
|
|
// 关闭喷嘴
|
|
m_MainWidget->on_m_LeftBtn_clicked();
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void InkJetPrinter::slt_alert(bool height)
|
|
{
|
|
QString str = "";
|
|
if (height) {
|
|
str = tr("粘度较高,请注意调整粘度");
|
|
} else {
|
|
str = tr("粘度较低,请注意调整粘度");
|
|
}
|
|
if (sysPara && sysPara->status.selfCheckDone)
|
|
QMessageBox::information(this, tr("提示"), str);
|
|
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* @brief 处理墨水警告
|
|
* 如果发生墨水警告，则进入 加墨水&刷卡 流程。
|
|
* 该流程要求 用户加入墨水并且刷了对应的墨水卡 才退出流程。
|
|
* 如果流程没有完成，则每隔一个小时提示一次，如果超过48小时，则sysPara->RFIDPara.inkCardTimeOut = true，禁用喷码机
|
|
* 该流程不受关机影响
|
|
*
|
|
* 该函数 使用定时器 1s 调用一次
|
|
*
|
|
*/
|
|
void InkJetPrinter::handleWarnInk()
|
|
{
|
|
if(!sysPara || !manager_rfid)
|
|
return;
|
|
|
|
// 墨水盒警告抖动处理
|
|
if(sysPara->status.statWarn & WARN_STATUS_INK_WARN) {
|
|
sysPara->status.inkWarningCnt = qMax(0, sysPara->status.inkWarningCnt);
|
|
sysPara->status.inkWarningCnt++; // 累计警报10次就提示
|
|
}
|
|
else {
|
|
sysPara->status.inkWarningCnt = qMin(0, sysPara->status.inkWarningCnt);
|
|
--sysPara->status.inkWarningCnt;
|
|
}
|
|
|
|
// 墨水被加入后处理
|
|
if(sysPara->status.inkWarningCnt <= -5 && sysPara->RFIDPara.inInkAndRFIDProgress) {
|
|
if(!sysPara->RFIDPara.addedInk) {
|
|
sysPara->RFIDPara.addedInk = true;
|
|
sysPara->saveRFIDPara();
|
|
|
|
if(sysPara->RFIDPara.needInkCard) {
|
|
slt_showMsg(tr("请及时使用墨水盒附带的IC卡激活墨水盒"));
|
|
}
|
|
m_MainWidget->powerOnWarn = false;
|
|
}
|
|
}
|
|
|
|
// 墨水盒空，进入 刷卡&加墨水 流程
|
|
if(sysPara->status.inkWarningCnt >= DETECT_WARNING_TIME && sysPara->RFIDPara.inInkAndRFIDProgress == 0) {
|
|
// 只处理自检期间出现的问题
|
|
if (!sysPara->status.selfCheckDone) {
|
|
m_MainWidget->powerOnWarn = true;
|
|
}
|
|
|
|
sysPara->RFIDPara.addedInk = false;
|
|
sysPara->RFIDPara.needInkCard = true;
|
|
sysPara->status.showInkWarningNumber = 0;
|
|
sysPara->RFIDPara.inInkAndRFIDProgress = 1;
|
|
|
|
QString strCurDateTime = QDateTime::currentDateTime().toString("yyMMddhhmmss");
|
|
LogInfo::setRunStatusText("Ink warning.");
|
|
qDebug()<<"墨水液位报警";
|
|
|
|
sysPara->para.inkWarnDate = strCurDateTime.mid(0,6).toInt();
|
|
sysPara->para.inkWarnTime = strCurDateTime.mid(6,6).toInt();
|
|
|
|
slt_showMsg(tr("请刷墨水卡,请使用原厂墨水耗材,否则机器将在%1小时后禁止使用!").arg(MAX_WARNING_TIME_HOUR));
|
|
|
|
sysPara->saveParaToFile();
|
|
sysPara->saveRFIDPara();
|
|
}
|
|
|
|
// 放在这里是为了防止在 刷卡&加墨水 流程中，用户没有刷卡就关机了。关机后再开机，仍然需要 刷卡&加墨水 才能继续使用喷码机。
|
|
if(sysPara->RFIDPara.needInkCard)
|
|
manager_rfid->requireInkCard();
|
|
|
|
|
|
// 计算刷卡时间间隔
|
|
|
|
QDateTime inkWarnDateTime = QDateTime::fromString(QString("20%1%2").
|
|
arg(sysPara->para.inkWarnDate, 6, 10, QChar('0')).
|
|
arg(sysPara->para.inkWarnTime, 6, 10, QChar('0')), "yyyyMMddhhmmss");
|
|
|
|
if (!inkWarnDateTime.isValid()) {
|
|
// 数据异常时，重置为当前时间并持久化
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
QString s = now.toString("yyMMddhhmmss");
|
|
sysPara->para.inkWarnDate = s.mid(0,6).toInt();
|
|
sysPara->para.inkWarnTime = s.mid(6,6).toInt();
|
|
sysPara->saveParaToFile();
|
|
inkWarnDateTime = now;
|
|
}
|
|
|
|
// 墨水卡未刷，或者没有加墨水，每隔一个小时提示一次。
|
|
if((!sysPara->RFIDPara.addedInk || sysPara->RFIDPara.needInkCard) && sysPara->RFIDPara.inInkAndRFIDProgress != 0) {
|
|
|
|
auto differHours = inkWarnDateTime.secsTo(QDateTime::currentDateTime()) / WARNING_INTERVAL_SEC;
|
|
|
|
// 如果differHours小于sysPara->status.showInkWarningNumber，说明系统时间被往前修改过。此时调整开始时间，直接进入超时状态。
|
|
// 我们让用户承担这个风险，直接进入超时状态，用户需要刷卡才能继续使用喷码机。
|
|
if(differHours < sysPara->status.showInkWarningNumber) {
|
|
auto now = QDateTime::currentDateTime();
|
|
auto newWarnDateTime = now.addSecs(-(MAX_WARNING_TIME_HOUR + 1) * 3600); // 直接进入超时状态，设置为当前时间的前49小时
|
|
auto str = newWarnDateTime.toString("yyMMddhhmmss");
|
|
sysPara->para.inkWarnDate = str.mid(0,6).toInt();
|
|
sysPara->para.inkWarnTime = str.mid(6,6).toInt();
|
|
|
|
LogInfo::setRunStatusText("Detected system time rollback; forcing ink warn timeout.");
|
|
differHours = newWarnDateTime.secsTo(now) / WARNING_INTERVAL_SEC;
|
|
sysPara->status.showInkWarningNumber = differHours - 1;
|
|
sysPara->saveParaToFile();
|
|
sysPara->saveRFIDPara();
|
|
}
|
|
|
|
// if(differHours >= sysPara->status.showInkWarningNumber) {
|
|
if(differHours > sysPara->status.showInkWarningNumber) {
|
|
|
|
// 理论上differHours只会比 sysPara->status.showInkWarningNumber 大 1， 如果大于1，说明系统时间被被往后修改过或者关过机。
|
|
|
|
if(differHours > MAX_WARNING_TIME_HOUR) {
|
|
slt_showMsg(tr("墨水液位报警超过%1小时,机器无法正常打印,请添加墨水并刷卡.").arg(MAX_WARNING_TIME_HOUR));
|
|
}
|
|
else {
|
|
// 累计 3 小时未补充，自动关喷嘴
|
|
if ((differHours > 0 && differHours % 3 == 0)
|
|
&& differHours < MAX_WARNING_TIME_HOUR
|
|
&& (sysPara->status.statWarn & WARN_STATUS_INK_WARN)) {
|
|
slt_showMsg(tr("墨水告警已累计3小时，自动关喷嘴。"));
|
|
if (sysPara->status.isPrinting)
|
|
m_MainWidget->on_m_StopBtn_clicked();
|
|
if (sysPara->status.reclaimTankstatus != 2)
|
|
m_MainWidget->on_m_LeftBtn_clicked();
|
|
} else {
|
|
slt_showMsg(tr("请刷墨水卡,请使用原厂墨水耗材,否则机器将在%1小时后禁止使用!").arg(MAX_WARNING_TIME_HOUR - differHours));
|
|
}
|
|
}
|
|
|
|
sysPara->status.showInkWarningNumber = differHours;
|
|
sysPara->saveRFIDPara();
|
|
}
|
|
|
|
// 进入超时状态，禁用喷码机
|
|
if(differHours > MAX_WARNING_TIME_HOUR) {
|
|
sysPara->RFIDPara.inkCardTimeOut = true;
|
|
sysPara->saveRFIDPara();
|
|
}
|
|
}
|
|
|
|
// 如果用户已经刷了墨水卡，并且加了墨水，则清除 刷卡&加墨水 流程
|
|
if(sysPara->RFIDPara.addedInk && !sysPara->RFIDPara.needInkCard && sysPara->RFIDPara.inInkAndRFIDProgress != 0) {
|
|
sysPara->status.showInkWarningNumber = 0;
|
|
sysPara->RFIDPara.inkCardTimeOut = false;
|
|
sysPara->RFIDPara.inInkAndRFIDProgress = 0;
|
|
sysPara->saveRFIDPara();
|
|
manager_rfid->requireInkCard(false);
|
|
|
|
LogInfo::setRunStatusText("Ink card has been added, and the ink card requirement has been cleared.");
|
|
|
|
if(sysPara->status.selfCheckDone && (sysPara->status.reclaimTankstatus == 2 || sysPara->status.reclaimTankstatus == 6)) {
|
|
m_MainWidget->setReclaimOpenBtnStatus(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::handleWarnSolvent()
|
|
{
|
|
if(!sysPara || !manager_rfid)
|
|
return;
|
|
|
|
// 溶剂液位抖动处理
|
|
if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN) {
|
|
sysPara->status.solventWarningCnt = qMax(0, sysPara->status.solventWarningCnt);
|
|
sysPara->status.solventWarningCnt++; // 累计警报10次就提示
|
|
}
|
|
else {
|
|
sysPara->status.solventWarningCnt = qMin(0, sysPara->status.solventWarningCnt);
|
|
--sysPara->status.solventWarningCnt;
|
|
}
|
|
|
|
// 溶剂被加入后处理
|
|
if(sysPara->status.solventWarningCnt <= -5 && sysPara->RFIDPara.inSolventAndRFIDProgress) {
|
|
if(!sysPara->RFIDPara.addedSolvent) {
|
|
sysPara->RFIDPara.addedSolvent = true;
|
|
sysPara->saveRFIDPara();
|
|
|
|
if(sysPara->RFIDPara.needSolventCard) {
|
|
slt_showMsg(tr("请及时使用溶剂盒附带的IC卡激活溶剂盒"));
|
|
}
|
|
m_MainWidget->powerOnWarn = false;
|
|
}
|
|
}
|
|
|
|
// 溶剂盒空，进入 刷卡&加溶剂 流程
|
|
if(sysPara->status.solventWarningCnt >= DETECT_WARNING_TIME && sysPara->RFIDPara.inSolventAndRFIDProgress == 0) {
|
|
// 只处理自检期间出现的问题
|
|
if (!sysPara->status.selfCheckDone) {
|
|
m_MainWidget->powerOnWarn = true;
|
|
}
|
|
|
|
QDateTime curDateTime = QDateTime::currentDateTime();
|
|
QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
|
|
LogInfo::setRunStatusText("Solvent warning.");
|
|
qDebug()<<"溶剂液位报警";
|
|
sysPara->para.solventWarnDate = strCurDateTime.mid(0,6).toInt();
|
|
sysPara->para.solventWarnTime = strCurDateTime.mid(6,6).toInt();
|
|
|
|
sysPara->RFIDPara.addedSolvent = false;
|
|
sysPara->RFIDPara.needSolventCard = true;
|
|
sysPara->status.showSolventWarningNumber = 0;
|
|
|
|
sysPara->RFIDPara.inSolventAndRFIDProgress = 1;
|
|
|
|
slt_showMsg(tr("请刷溶剂卡,请使用原厂溶剂耗材,否则机器将在%1小时后禁止使用!").arg(MAX_WARNING_TIME_HOUR));
|
|
|
|
sysPara->saveParaToFile();
|
|
sysPara->saveRFIDPara();
|
|
}
|
|
|
|
// 放在这里是为了防止在 刷卡&加溶剂 流程中，用户没有刷卡就关机了。关机后再开机，仍然需要 刷卡&加溶剂 才能继续使用喷码机。
|
|
if(sysPara->RFIDPara.needSolventCard)
|
|
manager_rfid->requireSolventCard();
|
|
|
|
// 计算刷卡时间间隔
|
|
|
|
QDateTime solventWarnDateTime = QDateTime::fromString(QString("20%1%2").
|
|
arg(sysPara->para.solventWarnDate, 6, 10, QChar('0')).
|
|
arg(sysPara->para.solventWarnTime, 6, 10, QChar('0')), "yyyyMMddhhmmss");
|
|
|
|
if (!solventWarnDateTime.isValid()) {
|
|
// 数据异常时，重置为当前时间并持久化
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
QString s = now.toString("yyMMddhhmmss");
|
|
sysPara->para.solventWarnDate = s.mid(0,6).toInt();
|
|
sysPara->para.solventWarnTime = s.mid(6,6).toInt();
|
|
sysPara->saveParaToFile();
|
|
solventWarnDateTime = now;
|
|
}
|
|
|
|
// 溶剂卡未刷，或者没有加溶剂，每隔一个小时提示一次。
|
|
if((!sysPara->RFIDPara.addedSolvent || sysPara->RFIDPara.needSolventCard) && sysPara->RFIDPara.inSolventAndRFIDProgress != 0) {
|
|
auto differHours = solventWarnDateTime.secsTo(QDateTime::currentDateTime()) / WARNING_INTERVAL_SEC;
|
|
|
|
// 如果differHours小于sysPara->status.showSolventWarningNumber，说明系统时间被往前修改过。此时调整开始时间，直接进入超时状态。
|
|
if(differHours < sysPara->status.showSolventWarningNumber) {
|
|
auto now = QDateTime::currentDateTime();
|
|
auto newWarnDateTime = now.addSecs(-(MAX_WARNING_TIME_HOUR + 1) * 3600); // 直接进入超时状态，设置为当前时间的前49小时
|
|
auto str = newWarnDateTime.toString("yyMMddhhmmss");
|
|
sysPara->para.solventWarnDate = str.mid(0,6).toInt();
|
|
sysPara->para.solventWarnTime = str.mid(6,6).toInt();
|
|
|
|
LogInfo::setRunStatusText("Detected system time rollback; forcing solvent warn timeout.");
|
|
differHours = newWarnDateTime.secsTo(now) / WARNING_INTERVAL_SEC;
|
|
sysPara->status.showSolventWarningNumber = differHours - 1;
|
|
sysPara->saveParaToFile();
|
|
}
|
|
|
|
if(differHours > sysPara->status.showSolventWarningNumber) {
|
|
if(differHours > MAX_WARNING_TIME_HOUR) {
|
|
slt_showMsg(tr("溶剂液位报警超过%1小时,机器无法正常打印,请添加溶剂并刷卡.").arg(MAX_WARNING_TIME_HOUR));
|
|
}else {
|
|
// 累计 3 小时未补充，自动关喷嘴
|
|
if ((differHours > 0 && differHours % 3 == 0)
|
|
&& differHours < MAX_WARNING_TIME_HOUR
|
|
&& (sysPara->status.statWarn & WARN_STATUS_SOLV_WARN)) {
|
|
slt_showMsg(tr("溶剂告警已累计3小时，自动关喷嘴。"));
|
|
if (sysPara->status.isPrinting)
|
|
m_MainWidget->on_m_StopBtn_clicked();
|
|
if (sysPara->status.reclaimTankstatus != 2)
|
|
m_MainWidget->on_m_LeftBtn_clicked();
|
|
} else {
|
|
slt_showMsg(tr("请刷溶剂卡,请使用原厂溶剂耗材,否则机器将在%1小时后禁止使用!").arg(MAX_WARNING_TIME_HOUR - differHours));
|
|
}
|
|
}
|
|
|
|
sysPara->status.showSolventWarningNumber = differHours;
|
|
sysPara->saveRFIDPara();
|
|
}
|
|
|
|
// 进入超时状态，禁用喷码机
|
|
if(differHours > MAX_WARNING_TIME_HOUR) {
|
|
sysPara->RFIDPara.solventCardTimeOut = true;
|
|
sysPara->saveRFIDPara();
|
|
}
|
|
}
|
|
|
|
// 如果用户已经刷了溶剂卡，并且加了溶剂，则清除 刷卡&加溶剂 流程
|
|
if(sysPara->RFIDPara.addedSolvent && !sysPara->RFIDPara.needSolventCard
|
|
&& sysPara->RFIDPara.inSolventAndRFIDProgress != 0) {
|
|
sysPara->status.showSolventWarningNumber = 0;
|
|
sysPara->RFIDPara.inSolventAndRFIDProgress = 0;
|
|
sysPara->RFIDPara.solventCardTimeOut = false;
|
|
sysPara->saveRFIDPara();
|
|
manager_rfid->requireSolventCard(false);
|
|
|
|
LogInfo::setRunStatusText("Solvent card has been added, and the solvent card requirement has been cleared.");
|
|
|
|
if(sysPara->status.selfCheckDone && (sysPara->status.reclaimTankstatus == 2 || sysPara->status.reclaimTankstatus == 6)) {
|
|
m_MainWidget->setReclaimOpenBtnStatus(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InkJetPrinter::setWarn(bool flag)
|
|
{
|
|
if (m_MainWidget) {
|
|
m_MainWidget->m_warn = flag;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void InkJetPrinter::slt_showMsg(QString msg)
|
|
{
|
|
static QList<QMessageBox*> msgPool;
|
|
|
|
QMessageBox * msgBox = new QMessageBox(QMessageBox::NoIcon, tr("提示"), msg, QMessageBox::StandardButton::Ok);
|
|
msgPool.push_back(msgBox);
|
|
connect(msgBox, &QMessageBox::finished, [this, msgBox, &msgPool](){
|
|
auto idx = msgPool.lastIndexOf(msgBox);
|
|
if(idx != -1) {
|
|
msgPool.removeAt(idx);
|
|
}
|
|
|
|
msgBox->deleteLater();
|
|
});
|
|
|
|
msgBox->show();
|
|
|
|
if(msgPool.size() > 3) {
|
|
msgPool.takeFirst()->deleteLater();
|
|
}
|
|
|
|
LogInfo::setRunStatusText(msg);
|
|
}
|
|
|
|
void InkJetPrinter::onDlgFileOpen(const QString& filename)
|
|
{
|
|
QFileInfo fileInfo(filename);
|
|
if(!fileInfo.exists() || !fileInfo.isFile()) {
|
|
LogInfo::setRunStatusText(tr("File not found: %1").arg(filename));
|
|
return;
|
|
}
|
|
|
|
loadWorkFileAndPreparePrint(filename);
|
|
}
|