3454 lines
135 KiB
C++
3454 lines
135 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)
|
||
{
|
||
// 加载.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
|
||
|
||
QThread::sleep(3);
|
||
qApp->installEventFilter(this);
|
||
|
||
QString ARM_Version;
|
||
ARM_Version.sprintf("%d.%d.%02d%s%s", UP_PRINTER_MAJOR_VER, UP_PRINTER_MINOR_VER,UP_PRINTER_RIVISION_VER,SUB_VERSION,SUB_RFID);
|
||
// ui.label_version->setText(QString("A%1/F%2.%3.%4").arg(ARM_Version).arg(sysPara->status.fpgaVersionNum >> 12)
|
||
// .arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff) );
|
||
|
||
|
||
#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);
|
||
|
||
#ifndef FPGA_TEST
|
||
// 调入文件喷印时，主动重启打印
|
||
// connect(m_TestPrintWidget, &TestPrintWidget::sig_currentFileChanged, this, [this](){
|
||
|
||
// ui.label_currWorkFile->setText(m_TestPrintWidget->currentFile());
|
||
|
||
// auto isPrinting = sysPara->status.isPrinting;
|
||
// if(isPrinting) {
|
||
// m_MainWidget->on_m_StopBtn_clicked();
|
||
|
||
// QTimer::singleShot(500, [this](){
|
||
|
||
// m_PrintSetting->applyPrintSettingsToSysPara(false);
|
||
|
||
// m_MainWidget->on_m_StartBtn_clicked();
|
||
// LogInfo::setRunStatusText("Restarting the print because the work file was switched.");
|
||
// });
|
||
// }
|
||
// else {
|
||
// QTimer::singleShot(300, [this](){
|
||
// m_PrintSetting->applyPrintSettingsToSysPara(false);
|
||
// });
|
||
// }
|
||
// });
|
||
#endif
|
||
|
||
// 班时元素与编辑 连接
|
||
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(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();
|
||
|
||
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;
|
||
|
||
timer = new QTimer();
|
||
connect(timer, SIGNAL(timeout()), this, SLOT(timerHandler()));
|
||
timer->start(10);
|
||
}
|
||
|
||
// type 1,2: 分别显示计数器1或2的界面
|
||
void InkJetPrinter::slt_editCounter(CounterViewModel vm)
|
||
{
|
||
if (m_CounterVarSet) {
|
||
m_CounterVarSet->updateSysParaToUI();
|
||
m_CounterVarSet->setCounterConfig(vm);
|
||
m_StackedWidget->setCurrentWidget(m_CounterVarSet);
|
||
}
|
||
}
|
||
|
||
void InkJetPrinter::slt_warningMaintenance()
|
||
{
|
||
// 距离维护时间结束大于30天，判断运行时间的检测
|
||
if (timeoutDay >= 30) {
|
||
double runHours = sysPara->RFIDPara.runTime / 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) {
|
||
loadLastWorkAndPreparePrint();
|
||
firstShow = false;
|
||
}
|
||
}
|
||
|
||
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;
|
||
|
||
// 双模式PID参数配置
|
||
struct DualModePIDParams {
|
||
// 快速收敛模式（大偏差）
|
||
float fast_Kp;
|
||
float fast_Ki; // 通常为0
|
||
float fast_Kd;
|
||
float fast_maxDelta; // 单次调整限幅
|
||
int fast_cycle; // 调整周期（单位：100ms）
|
||
|
||
// 精准稳压模式（小偏差）
|
||
float precision_Kp;
|
||
float precision_Ki;
|
||
float precision_Kd;
|
||
float precision_maxDelta;
|
||
int precision_cycle;
|
||
float integral_limit; // 积分限幅
|
||
int stable_threshold; // 稳定判定阈值
|
||
int stable_count_req; // 需要稳定的次数
|
||
|
||
// 模式切换阈值
|
||
float switch_threshold; // 切换到精准模式的误差阈值
|
||
float switch_hysteresis; // 模式切换滞后带宽，避免反复切换
|
||
float deadzone; // 死区：误差小于此值时不调整
|
||
};
|
||
|
||
// 无分流管设备参数
|
||
static DualModePIDParams params_no_reclaim = {
|
||
// 快速模式：保持不变
|
||
0.06f, // fast_Kp
|
||
0.0f, // fast_Ki
|
||
0.02f, // fast_Kd
|
||
8.0f, // fast_maxDelta
|
||
10, // fast_cycle (1000ms)
|
||
|
||
// 精准模式：降低Kp，大幅增加Kd抑制振荡
|
||
0.004f, // precision_Kp (从0.010降到0.004，降低60%，减少过调)
|
||
0.0015f, // precision_Ki (从0.002降到0.0015，降低25%，减缓积分)
|
||
0.025f, // precision_Kd (从0.005增加到0.025，提高5倍，抑制振荡)
|
||
1.0f, // precision_maxDelta (从1.5降到1.0，更平滑)
|
||
15, // precision_cycle (1500ms)
|
||
80.0f, // integral_limit (从100降到80，防止积分饱和)
|
||
8, // stable_threshold (保持8)
|
||
8, // stable_count_req (从15降到8，更快响应)
|
||
|
||
80.0f, // switch_threshold
|
||
15.0f, // switch_hysteresis
|
||
5.0f // deadzone (从15降到5，缩小不动区，减少振荡幅度)
|
||
};
|
||
|
||
// 有分流管设备参数
|
||
static DualModePIDParams params_with_reclaim = {
|
||
// 快速模式
|
||
0.08f, // fast_Kp
|
||
0.0f, // fast_Ki
|
||
0.03f, // fast_Kd
|
||
10.0f, // fast_maxDelta
|
||
10, // fast_cycle (1000ms)
|
||
|
||
// 精准模式：降低Kp，大幅增加Kd抑制振荡
|
||
0.006f, // precision_Kp (从0.015降到0.006，降低60%，减少过调)
|
||
0.002f, // precision_Ki (从0.003降到0.002，降低33%，减缓积分)
|
||
0.035f, // precision_Kd (从0.008增加到0.035，提高4倍，抑制振荡)
|
||
1.2f, // precision_maxDelta (从2.0降到1.2，更平滑)
|
||
15, // precision_cycle (1500ms)
|
||
100.0f, // integral_limit (从120降到100，防止积分饱和)
|
||
12, // stable_threshold (保持12)
|
||
8, // stable_count_req (从12降到8，更快响应)
|
||
|
||
80.0f, // switch_threshold
|
||
15.0f, // switch_hysteresis
|
||
8.0f // deadzone (从18降到8，缩小不动区，减少振荡幅度)
|
||
};
|
||
|
||
// PID控制器状态
|
||
struct PIDController {
|
||
float integral; // 积分累积
|
||
float last_actual; // 上次实际值（用于微分先行）
|
||
float last_output; // 上次输出值（用于变化率限制）
|
||
int adjust_skip; // 周期计数器
|
||
int stable_count; // 稳定计数器
|
||
bool in_precision_mode; // 当前是否在精准模式
|
||
|
||
void reset() {
|
||
integral = 0.0f;
|
||
last_actual = 0.0f;
|
||
last_output = 0.0f;
|
||
adjust_skip = 0;
|
||
stable_count = 0;
|
||
in_precision_mode = false;
|
||
}
|
||
};
|
||
|
||
static PIDController pid_ctrl;
|
||
|
||
|
||
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;
|
||
|
||
// 重置双模式PID控制器
|
||
pid_ctrl.reset();
|
||
}
|
||
|
||
// 微分先行PID计算函数
|
||
// derivative_on_measurement: 只对实际值求微分，避免设定值突变冲击
|
||
float DualModePID_Calculate(float setpoint, float actual, const DualModePIDParams& params,
|
||
PIDController& ctrl, float u_current, float u_min, float u_max) {
|
||
float error = setpoint - actual;
|
||
float abs_error = (error < 0) ? -error : error;
|
||
|
||
// 判断当前应该使用哪种模式
|
||
bool use_precision = (abs_error <= params.switch_threshold);
|
||
|
||
float Kp, Ki, Kd, max_delta;
|
||
|
||
if (use_precision) {
|
||
// 精准稳压模式
|
||
Kp = params.precision_Kp;
|
||
Ki = params.precision_Ki;
|
||
Kd = params.precision_Kd;
|
||
max_delta = params.precision_maxDelta;
|
||
ctrl.in_precision_mode = true;
|
||
} else {
|
||
// 快速收敛模式
|
||
Kp = params.fast_Kp;
|
||
Ki = params.fast_Ki; // 通常为0
|
||
Kd = params.fast_Kd;
|
||
max_delta = params.fast_maxDelta;
|
||
ctrl.in_precision_mode = false;
|
||
|
||
// 快速模式下清零积分，避免积分累积
|
||
ctrl.integral = 0.0f;
|
||
}
|
||
|
||
// 比例项
|
||
float p_term = Kp * error;
|
||
|
||
// 积分项（带抗饱和和变速积分）
|
||
float i_term = 0.0f;
|
||
if (use_precision && Ki > 0.0f) {
|
||
// 积分分离：只在精准模式下累积
|
||
// 积分抗饱和：转速到达限位时停止累积
|
||
bool at_upper_limit = (u_current >= u_max - 1.0f) && (error > 0);
|
||
bool at_lower_limit = (u_current <= u_min + 1.0f) && (error < 0);
|
||
|
||
if (!at_upper_limit && !at_lower_limit) {
|
||
// 变速积分：误差越大，积分增益越小，防止积分饱和
|
||
float ki_adjust = 1.0f;
|
||
if (abs_error > 30.0f) {
|
||
ki_adjust = 0.3f; // 大误差时降低积分作用
|
||
} else if (abs_error > 15.0f) {
|
||
ki_adjust = 0.6f; // 中等误差时适度降低
|
||
}
|
||
|
||
ctrl.integral += error * ki_adjust;
|
||
|
||
// 积分限幅
|
||
if (ctrl.integral > params.integral_limit) {
|
||
ctrl.integral = params.integral_limit;
|
||
} else if (ctrl.integral < -params.integral_limit) {
|
||
ctrl.integral = -params.integral_limit;
|
||
}
|
||
}
|
||
|
||
i_term = Ki * ctrl.integral;
|
||
}
|
||
|
||
// 微分先行：只对实际值求微分，避免设定值突变时微分项冲击
|
||
// 传统微分：Kd * (error - error_last) = Kd * [(set-act) - (set_last-act_last)]
|
||
// 微分先行：-Kd * (actual - actual_last) 当设定值不变时两者等价，但设定值变化时微分先行无冲击
|
||
float d_term = 0.0f;
|
||
if (Kd > 0.0f) {
|
||
float derivative = -(actual - ctrl.last_actual); // 负号因为是对实际值求导
|
||
d_term = Kd * derivative;
|
||
ctrl.last_actual = actual;
|
||
}
|
||
|
||
// PID输出
|
||
float delta_u = p_term + i_term + d_term;
|
||
|
||
// 输出限幅
|
||
if (delta_u > max_delta) {
|
||
delta_u = max_delta;
|
||
} else if (delta_u < -max_delta) {
|
||
delta_u = -max_delta;
|
||
}
|
||
|
||
// 输出变化率限制（精准模式下更平滑）
|
||
if (use_precision && ctrl.last_output != 0.0f) {
|
||
float max_rate = max_delta * 0.5f; // 最大变化率为max_delta的50%
|
||
float output_change = delta_u - ctrl.last_output;
|
||
if (output_change > max_rate) {
|
||
delta_u = ctrl.last_output + max_rate;
|
||
} else if (output_change < -max_rate) {
|
||
delta_u = ctrl.last_output - max_rate;
|
||
}
|
||
}
|
||
|
||
ctrl.last_output = delta_u;
|
||
|
||
return delta_u;
|
||
}
|
||
|
||
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;
|
||
pid_ctrl.reset(); // 重置双模式PID控制器
|
||
sysPara->devOp->WriteMoterPump();
|
||
return;
|
||
}
|
||
|
||
if(!sysPara->para.gearPumpEnable)
|
||
{
|
||
// 非使能状态保留旧PID逻辑
|
||
if(u > 0 || ((sysPara->para.pressure - sysPara->status.PRESSURE) > 0))
|
||
u = PID_realize((float)sysPara->para.pressure, (float)sysPara->status.PRESSURE);
|
||
sysPara->para.gearPumpValue = (u > 0) ? (unsigned short)u : 0;
|
||
if(sysPara->para.gearPumpValue > 800)
|
||
sysPara->para.gearPumpValue = 800;
|
||
sysPara->devOp->WriteMoterPump();
|
||
return;
|
||
}
|
||
|
||
// 根据是否有分流管选择参数集
|
||
const DualModePIDParams& params = sysPara->para.flagOfReclaimPumEnable
|
||
? params_with_reclaim
|
||
: params_no_reclaim;
|
||
|
||
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;
|
||
|
||
// 每次进入都更新滑动平均缓冲
|
||
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();
|
||
|
||
// 超调时清零积分，避免积分饱和
|
||
pid_ctrl.integral = 0.0f;
|
||
|
||
sysPara->para.gearPumpValue = (unsigned short)(int)u;
|
||
sysPara->devOp->WriteMoterPump();
|
||
return;
|
||
}
|
||
|
||
// ---------------------------------------------------------------
|
||
// 双模式PID控制：根据误差大小自动切换快速/精准模式
|
||
// 快速模式：大偏差快速收敛，周期1000ms
|
||
// 精准模式：小偏差精准稳压，周期1500ms，等待压力稳定后调整
|
||
// 带死区和模式切换滞后，避免频繁调整和模式抖动
|
||
// ---------------------------------------------------------------
|
||
|
||
// 计算误差（统一使用平均压力，避免瞬时噪声）
|
||
float error_avg = (float)(target - avgPressure);
|
||
float abs_error_avg = (error_avg < 0) ? -error_avg : error_avg;
|
||
|
||
// 死区控制：误差很小时不调整，避免频繁微调
|
||
// 使用平均压力判断，与后续调整逻辑一致
|
||
// 优化：在死区内不清零积分，保持积分补偿效果
|
||
if(abs_error_avg < params.deadzone)
|
||
{
|
||
// 在死区内：保持积分不变，不再清零
|
||
// 只有误差超过死区时才会重新累积或调整积分
|
||
pid_ctrl.adjust_skip = 0;
|
||
pid_ctrl.stable_count = 0;
|
||
|
||
sysPara->para.gearPumpValue = (unsigned short)(int)u;
|
||
sysPara->devOp->WriteMoterPump();
|
||
return;
|
||
}
|
||
|
||
// 模式切换逻辑（带滞后，避免在阈值附近反复切换）
|
||
bool use_precision;
|
||
if(pid_ctrl.in_precision_mode)
|
||
{
|
||
// 当前在精准模式，需要误差大于阈值+滞后才切回快速模式
|
||
use_precision = (abs_error_avg <= params.switch_threshold + params.switch_hysteresis);
|
||
}
|
||
else
|
||
{
|
||
// 当前在快速模式，误差小于阈值即切到精准模式
|
||
use_precision = (abs_error_avg <= params.switch_threshold);
|
||
}
|
||
|
||
int cycle = use_precision ? params.precision_cycle : params.fast_cycle;
|
||
|
||
// 周期控制
|
||
if(++pid_ctrl.adjust_skip < cycle)
|
||
{
|
||
sysPara->para.gearPumpValue = (unsigned short)(int)u;
|
||
sysPara->devOp->WriteMoterPump();
|
||
return;
|
||
}
|
||
|
||
// 精准模式需要等待压力稳定
|
||
if(use_precision)
|
||
{
|
||
// 稳定检测用平均值，滤掉传感器噪声
|
||
int pressureChange = avgPressure - m_lastPressure;
|
||
if(pressureChange < 0) pressureChange = -pressureChange;
|
||
m_lastPressure = avgPressure;
|
||
|
||
bool stable = (pressureChange < params.stable_threshold);
|
||
|
||
if(stable)
|
||
pid_ctrl.stable_count++;
|
||
else
|
||
pid_ctrl.stable_count = 0;
|
||
|
||
// 如果还未稳定，继续等待
|
||
if(pid_ctrl.stable_count < params.stable_count_req)
|
||
{
|
||
sysPara->para.gearPumpValue = (unsigned short)(int)u;
|
||
sysPara->devOp->WriteMoterPump();
|
||
return;
|
||
}
|
||
|
||
// 压力已稳定，执行调速，重置计数
|
||
pid_ctrl.adjust_skip = 0;
|
||
pid_ctrl.stable_count = 0;
|
||
pid_ctrl.in_precision_mode = true;
|
||
|
||
// 精准模式使用平均压力计算
|
||
float delta_u = DualModePID_Calculate((float)target, (float)avgPressure, params,
|
||
pid_ctrl, u, 60.0f, (float)maxValue);
|
||
|
||
// 转速上限软限制：转速已达上限时禁止继续加速
|
||
if(sysPara->para.flagOfReclaimPumEnable &&
|
||
sysPara->status.gearPumpRunSpeed >= maxSpeed)
|
||
{
|
||
if(delta_u > 0.0f) delta_u = 0.0f;
|
||
}
|
||
|
||
u += delta_u;
|
||
clampU();
|
||
}
|
||
else
|
||
{
|
||
// 快速模式：立即调整，重置计数
|
||
pid_ctrl.adjust_skip = 0;
|
||
pid_ctrl.stable_count = 0;
|
||
pid_ctrl.in_precision_mode = false;
|
||
|
||
// 快速模式也使用平均压力，避免瞬时噪声导致过度调整
|
||
float delta_u = DualModePID_Calculate((float)target, (float)avgPressure, params,
|
||
pid_ctrl, u, 60.0f, (float)maxValue);
|
||
|
||
// 转速上限软限制
|
||
if(sysPara->para.flagOfReclaimPumEnable &&
|
||
sysPara->status.gearPumpRunSpeed >= maxSpeed)
|
||
{
|
||
if(delta_u > 0.0f) delta_u = 0.0f;
|
||
}
|
||
|
||
u += delta_u;
|
||
clampU();
|
||
}
|
||
|
||
sysPara->para.gearPumpValue = (unsigned short)(int)u;
|
||
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 gearPumpRunFlag = false;
|
||
static bool ControledSwitchFlag = false;
|
||
static bool gearPumpStartFlag = false;
|
||
static bool delay3s;
|
||
bool InkSwintFlag = false,lastInkSwintFlag = false;
|
||
static float gearPumpRunNormalValue = 0.0;
|
||
if(sysPara){
|
||
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;
|
||
}
|
||
if(pulse_300ms) tempFlag=1;
|
||
if((sysPara->status.delay10ms%3) == 0) //读取状态后再检測
|
||
{
|
||
if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN) && !gearPumpRunFlag && !sysPara->status.isPumpValveControledByHand)//刚启动前3秒
|
||
{
|
||
if(sysPara->para.gearPumpEnable) {
|
||
// 确保开机时控制字从 0 开始，让 pressureAdj 软启动从 0 爬坡，避免突变到高转速
|
||
if(sysPara->para.gearPumpValue != 0) {
|
||
sysPara->para.gearPumpValue = 0;
|
||
u = 0.0f;
|
||
sysPara->devOp->WriteMoterPump();
|
||
}
|
||
gearPumpStartFlag = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(pushButtonStartFlag && sysPara->status.selfCheckDone)
|
||
{
|
||
if((sysPara->status.PRESSURE > (sysPara->para.pressure -10)) && (sysPara->status.PRESSURE < (sysPara->para.pressure +10)))
|
||
{
|
||
if(pulse_1s)
|
||
{
|
||
|
||
pulse_5s++;
|
||
}
|
||
if( pulse_5s == 5)
|
||
{
|
||
pulse_5s = 0;
|
||
gearPumpRunNormalFlag = true;
|
||
gearPumpRunNormalValue = u;
|
||
}
|
||
}
|
||
}
|
||
if(sysPara->status.isPumpValveControledByHand)
|
||
{
|
||
gearPumpRunNormalFlag = false;
|
||
ControledSwitchFlag = false;
|
||
pulse_3s = 0;
|
||
}
|
||
// 检测手动→自动边沿，直接恢复压力控制，不走 gearPumpStartFlag 的 3s 等待
|
||
if(m_lastByHand && !sysPara->status.isPumpValveControledByHand)
|
||
{
|
||
ControledSwitchFlag = true;
|
||
u = (float)sysPara->para.gearPumpValue; // 同步当前转速，避免突变
|
||
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;
|
||
// ui->tabMainWindow->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)
|
||
// ui->tabMainWindow->on_pushButtonReclaimTankClose_pressed();
|
||
test_flag = 0;
|
||
}
|
||
if(pulse_1s) {
|
||
// 回收泵模式切换时重置软启动和泄漏保护学习状态
|
||
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(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(m_MainWidget->getCurrPrintStatus() != 1){
|
||
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 == 3)
|
||
{
|
||
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();
|
||
}
|
||
|
||
/**************桂澳增加超速提示*****************************/
|
||
static int logCtrl = 0;
|
||
if((sysPara->para.printTriggerMode == PRINT_TRIGGER_SYNCHRONIZER || sysPara->para.eleEyeTriggerSynPrintEn)
|
||
&& sysPara->status.lesslen_warn == 1){ //置1表示超速了
|
||
if(logCtrl++ % 500 == 0){
|
||
// LogInfo::setRunStatusText(tr("速度过快,请检查是否漏喷!!!"));
|
||
qDebug()<<"速度过快,请检查是否漏喷!!!";
|
||
}
|
||
|
||
/*if(msgBox1->isHidden()){ //桂澳的超速提示先保留
|
||
msgBox1->setText(tr("速度过快,请检查是否漏喷!!!"));
|
||
msgBox1->show();
|
||
LogInfo::setRunStatusText(tr("速度过快,请检查是否漏喷!!!"));
|
||
qDebug()<<"速度过快,请检查是否漏喷!!!";
|
||
}*/
|
||
sysPara->devOp->controlRedLight(true);
|
||
sysPara->devOp->controlGreenLight(false);
|
||
}
|
||
else{
|
||
// if(!msgBox1->isHidden())
|
||
// sysPara->devOp->controlRedLight(false);
|
||
}
|
||
|
||
sysPara->status.gearPumpRunSpeed = (PulseCnt * 60 * 1000) / (500 * 2);
|
||
if(!sysPara->para.gearPumpEnable)
|
||
sysPara->status.PRESSURE *= 5; //响应群众号召，数值放大五倍
|
||
|
||
/*-------------------------------------------------------*/
|
||
bool lostCommuFlag = 1;
|
||
if(sysPara->status.fpgaVersionNum != 0)
|
||
lostCommuFlag = 0;
|
||
|
||
if(sysPara->status.delay10ms%5 == 0)
|
||
{//复位发送打印数据
|
||
if((m_MainWidget->getCurrPrintStatus() == 1)&&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){ //更新替换变量的值
|
||
// LogInfo::setRunStatusText("vartypeR");
|
||
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) {
|
||
// // 统计追踪更新频率
|
||
// static QElapsedTimer bnsTimer;
|
||
// static int toogleCount = 0;
|
||
// ++toogleCount;
|
||
// if(toogleCount > 10) {
|
||
// auto elapsed = bnsTimer.restart();
|
||
// qDebug() << (QString("timeHandler avg elapsed: %1 s").arg(elapsed / qreal(toogleCount) / 1000.0));
|
||
// toogleCount = 0;
|
||
// }
|
||
m_MainWidget->updatePrintDisplayLabel();
|
||
}
|
||
|
||
// if (modbus->getModbusStatus() == 1) {
|
||
// refreshModbusStatus();
|
||
// }
|
||
}
|
||
|
||
if(gearPumpRunFlag || sysPara->para.gearPumpEnable == 0)
|
||
{
|
||
if(!sysPara->status.selfCheckDone && sysPara->status.isPrinting){
|
||
// sysPara->status.selfCheckDone = true;
|
||
m_MainWidget->updatePrintDisplayLabel();
|
||
// sysPara->status.flagOfAbnormalStatus = true;
|
||
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);
|
||
|
||
m_MainWidget->enablePrintButton(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 QT_DEBUG
|
||
if(sysPara->status.selfCheckCnt >= 1500) // 测试自检改为15s
|
||
#else
|
||
if(sysPara->status.selfCheckCnt >= MAX_SELF_CHECK_CNT)
|
||
#endif
|
||
{
|
||
sysPara->status.selfCheckDone = 1;
|
||
// 自检完成后管道恢复正常阻力，重置软启动让压力重新平稳收敛
|
||
// 不清零 u，从当前控制字开始，避免突变
|
||
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_MainWidget->setReclaimOpenBtnStatus(true);
|
||
m_MainWidget->setReclaimCloseBtnStatus(false);
|
||
|
||
sysPara->devOp->mainInkCtrl();
|
||
sysPara->status.canRunAirPushing = true;
|
||
|
||
// 自检结束发送打印设置
|
||
qInfo() << "Self check done and send print para to FPGA";
|
||
// sysPara->devOp->setHighVoltageAmplitudetoSTM32();
|
||
// sysPara->devOp->writeFpgaCalandar(0);
|
||
// sysPara->devOp->writeFpgaPrintPara(true);
|
||
|
||
// 自检完成后，关闭高电压，不知道为什么，有时候开机自检都有高压
|
||
sysPara->devOp->highVoltageCtrl(0);
|
||
|
||
m_MainWidget->on_m_StopBtn_clicked();
|
||
|
||
LogInfo::setRunStatusText(tr("自检完成!!!"));
|
||
m_MainWidget->setRunStatus(tr("自检完成!!!"));
|
||
qDebug()<<"自检完成!!!";
|
||
|
||
if(sysPara->para.Reciclar)
|
||
test_flag = 1;
|
||
}
|
||
else {
|
||
if((sysPara->status.selfCheckCnt % 200) == 0)
|
||
m_MainWidget->setReclaimOpenBtnStatus(false);
|
||
m_MainWidget->setReclaimCloseBtnStatus(false);
|
||
}
|
||
|
||
}
|
||
else{
|
||
// 开机自检完成的前提下
|
||
if (!sysPara->status.airPushing || m_MainWidget->m_2sFlag) {
|
||
autoControlValvePump();
|
||
}
|
||
static qint32 adjDbgCnt = 0;
|
||
if(pulse_100ms && ++adjDbgCnt % 50 == 0){
|
||
|
||
// 调整压力算法时用这个追踪
|
||
// qDebug()<<"[adjCond] gearPumpEnable="<<sysPara->para.gearPumpEnable
|
||
// <<" isPumpValveControledByHand="<<sysPara->status.isPumpValveControledByHand
|
||
// <<" ControledSwitchFlag="<<ControledSwitchFlag
|
||
// <<" gearPumpRunFlag="<<gearPumpRunFlag
|
||
// <<" gearPumpStartFlag="<<gearPumpStartFlag;
|
||
}
|
||
if(pulse_100ms && sysPara->para.gearPumpEnable && !sysPara->status.isPumpValveControledByHand && ControledSwitchFlag ) {
|
||
pressureAdj();
|
||
}
|
||
}
|
||
}
|
||
else{
|
||
static bool flag = 1;
|
||
if(delay3s){
|
||
if(flag){
|
||
flag = 0;
|
||
// LogInfo::setRunStatusText(tr("缺少墨水,喷码机不能正常工作!"));
|
||
qDebug()<<"缺少墨水,喷码机不能正常工作!";
|
||
}
|
||
// ui->tabMainWindow->setRunStatus(tr("缺少墨水,喷码机不能正常工作!"));
|
||
}
|
||
}
|
||
/*----------------------------控制温度--------------------------------------*/
|
||
if(pulse_300ms){
|
||
autoControlHeater();
|
||
sysPara->devOp->readSyncCounterAtZero();
|
||
}
|
||
|
||
sysPara->status.lostCommuFlag = lostCommuFlag; //务必放在后面
|
||
static unsigned int lastProductCnt =0;
|
||
static int lastalterMode=-1;
|
||
if(sysPara->para.alterPrint.enable)
|
||
{
|
||
sysPara->para.AlterMode=sysPara->status.AlterMode; // 电眼触发交替功能：新增这一行
|
||
if( (sysPara->para.AlterMode!=lastalterMode)
|
||
|| (lastProductCnt != sysPara->status.productCnt)
|
||
)
|
||
{
|
||
// ui->tabMainWindow->alterDataPrint (sysPara->para.AlterMode);
|
||
}
|
||
}
|
||
else sysPara->para.AlterMode=0;
|
||
lastalterMode = sysPara->para.AlterMode;
|
||
lastProductCnt = sysPara->status.productCnt;
|
||
// 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();
|
||
static bool read_flag = false;
|
||
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 == ui->tabTriggerMode){
|
||
ui->tabTriggerMode->updateSysStatusToUI();
|
||
|
||
if(sysPara->status.fpgaVersionNum != 0){
|
||
QString FpgaVersion;
|
||
if((sysPara->status.fpgaVersionNum>>12) == 8 || (sysPara->status.fpgaVersionNum>>12) == 6)
|
||
FpgaVersion = "72";
|
||
else if((sysPara->status.fpgaVersionNum>>12) == 2 || (sysPara->status.fpgaVersionNum>>12) == 1){
|
||
if(sysPara->para.flagOfFastMode)
|
||
FpgaVersion = "66";
|
||
else
|
||
FpgaVersion = "67";
|
||
}
|
||
FpgaVersion += QString("_F%1.%2.%3").arg(sysPara->status.fpgaVersionNum >> 12)
|
||
.arg((sysPara->status.fpgaVersionNum>>8) & 0x0f).arg(sysPara->status.fpgaVersionNum&0xff);
|
||
ui->tabTriggerMode->setBuildTime(QString(" No%1").arg(FpgaVersion));
|
||
}
|
||
|
||
}
|
||
*/
|
||
else if(widget == m_PrintSetting)
|
||
{
|
||
m_PrintSetting->updateSysStatusToUI();
|
||
// if(!read_flag)
|
||
// {
|
||
// emit sendPicScene(ui->tabMainWindow->getPicScene());
|
||
// }
|
||
read_flag = true;
|
||
}
|
||
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();
|
||
// }
|
||
// }
|
||
if(widget != m_PrintSetting)
|
||
{
|
||
read_flag = false;
|
||
}
|
||
|
||
// 20140306
|
||
static int last_lesslen_warn=0,lesslen_cnt=0;
|
||
if(sysPara->status.lesslen_warn && (sysPara->para.printTriggerMode != PRINT_TRIGGER_TIME))
|
||
{
|
||
if(last_lesslen_warn==0)
|
||
{
|
||
last_lesslen_warn =lesslen_cnt;
|
||
if(lesslen_cnt<60)lesslen_cnt +=6;
|
||
if(lesslen_cnt>40) sysPara->devOp->resumeFault();
|
||
|
||
if(sysPara->para.speedoverPaushPrint) {
|
||
// 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(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);
|
||
// }
|
||
// LogInfo::setRunStatusText(tr("处理警告:%1").arg(QDateTime::currentDateTime()));
|
||
|
||
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->controlBeeper(!sysPara->devOp->isBeeperEnable());
|
||
}
|
||
|
||
if((sysPara->status.statWarn & (WARN_STATUS_POWER_MON))
|
||
||sysPara->status.lastwarmInkPump||sysPara->status.lastwarmInkPump||sysPara->status.mainInkPumpError
|
||
||sysPara->status.compressPumpError||sysPara->status.lastPhaseFault||sysPara->status.lastRecycleWarn||sysPara->status.lastHighVoltageFault)
|
||
{ //2013-12-12故障报警灯 杨
|
||
sysPara->status.RedLightOnFlag = true;
|
||
|
||
}
|
||
else {
|
||
sysPara->status.RedLightOnFlag = false;
|
||
sysPara->devOp->controlRedLight(false);
|
||
//sysPara->devOp->controlRedLight(true);
|
||
}
|
||
if(sysPara->status.RedLightOnFlag){ //报警会时有时无
|
||
sysPara->devOp->controlRedLight(!sysPara->devOp->isRedLightEnable());
|
||
}
|
||
if((sysPara->status.statWarn & (WARN_STATUS_INK_WARN|WARN_STATUS_SOLV_WARN |WARN_STATUS_RECYCLE_FAULT|WARN_STATUS_SUMP_WARN))
|
||
&& !sysPara->status.RedLightOnFlag){
|
||
//if(!sysPara->status.RedLightOnFlag){
|
||
sysPara->status.YellowLightOnFlag = true;
|
||
}
|
||
else {
|
||
sysPara->status.YellowLightOnFlag = false;
|
||
sysPara->devOp->controlYellowLight(false);
|
||
//sysPara->devOp->controlYellowLight(true);
|
||
}
|
||
if(sysPara->status.YellowLightOnFlag){ //报警会时有时无
|
||
sysPara->devOp->controlYellowLight(!sysPara->devOp->isYellowLightEnable());
|
||
}
|
||
|
||
if(sysPara->status.waitHightVolOff>0){
|
||
sysPara->status.waitHightVolOff--;
|
||
if(sysPara->status.waitHightVolOff==0){
|
||
sysPara->devOp->highVoltageCtrl(0);
|
||
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::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);
|
||
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);
|
||
}
|
||
|
||
/*************************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];
|
||
}
|
||
|
||
// 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);
|
||
}
|
||
});
|
||
|
||
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 || (sysPara->status.needPowerOffTimerout && sysPara->para.gearPumpEnable)){
|
||
// if(!sysPara->devOp->isCycleValveOpen()){ //循环阀 //定时开机循环时隔膜泵不开关循环阀
|
||
// sysPara->devOp->controlCycleValve(true);
|
||
// }
|
||
cycleValveRunForSelfCheck();
|
||
if(sysPara->status.needPowerOffTimerout)
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
|
||
/*----------------------------------泄压阀-------------------------------------------*/
|
||
//=====================================================================================================
|
||
|
||
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);
|
||
}*/
|
||
|
||
/*------------------------------------粘度泵,混合阀-----------------------------------------*/
|
||
|
||
/*-----------------------------每30s打开一次粘度泵以及相关处理--------------------------------------*/
|
||
static bool hasDetectedBellow = false; // 检测到下位灯
|
||
static bool hasDetectedTop = false; // 检测到上位灯
|
||
static int viscosity_low = 0; //统计粘度连续偏低10%次数
|
||
static unsigned char Mixing_valve_open = 0; //统计粘度连续偏高5%次数
|
||
static unsigned char viscosity_faulty_num = 0; //统计粘度连续偏高13%次数
|
||
static bool flag = 0;
|
||
|
||
if(sysPara->status.cycleValveOpenCntAfterSWintOff) { //关闭墨线的时候要提前开粘度泵
|
||
sysPara->status.viscosityDelayCnt = sysPara->para.viscosityPumpInterval*100 + 100;
|
||
}
|
||
++sysPara->status.viscosityDelayCnt;
|
||
int mixer_open_threshold = (105*sysPara->para.viscosity)/100;
|
||
int viscosity_faulty_threshold =(113*sysPara->para.viscosity)/100;
|
||
if(sysPara->status.viscosityDelayCnt >= sysPara->para.viscosityPumpInterval*100 && flag == 0)
|
||
{
|
||
flag=1;
|
||
if (!sysPara->devOp->isViscosityPumpOpen())
|
||
{
|
||
sysPara->devOp->controlViscosityPump(true);
|
||
viscosity_timer->start(10000);
|
||
qDebug()<<"粘度: "<<QString::number(sysPara->status.viscosity);
|
||
}
|
||
if((sysPara->status.viscosity >= 90*sysPara->para.viscosity/100) && (sysPara->status.viscosity <= mixer_open_threshold))
|
||
{
|
||
sysPara->status.viscosityFault = 0;
|
||
viscosity_low=0;
|
||
Mixing_valve_open = 0;
|
||
viscosity_faulty_num = 0;
|
||
}
|
||
if(sysPara->status.viscosity < 90*sysPara->para.viscosity/100)
|
||
{
|
||
viscosity_low++;
|
||
viscosity_faulty_num = 0;
|
||
Mixing_valve_open = 0;
|
||
}
|
||
if(sysPara->status.viscosity > mixer_open_threshold && sysPara->status.viscosity <= viscosity_faulty_threshold)
|
||
{
|
||
Mixing_valve_open++;
|
||
viscosity_low = 0;
|
||
viscosity_faulty_num = 0;
|
||
}
|
||
if(sysPara->status.viscosity > viscosity_faulty_threshold){
|
||
Mixing_valve_open++;
|
||
viscosity_faulty_num++;
|
||
viscosity_low = 0;
|
||
}
|
||
|
||
if((!sysPara->devOp->isMixValveOpen()) && (((Mixing_valve_open > 1) && (!sysPara->para.gearPumpEnable)) || ((Mixing_valve_open > 4) && sysPara->para.gearPumpEnable))) { //
|
||
sysPara->devOp->controlMixValve(true);
|
||
Mixing_valve_open = 0;
|
||
// LogInfo::setRunStatusText(tr("添加溶剂:")+QString::number(sysPara->status.viscosity));
|
||
qDebug()<<"添加溶剂";
|
||
}
|
||
|
||
if(viscosity_low >= 60)
|
||
{
|
||
// LogInfo::setRunStatusText(tr("警告!!!!!!!!!!!粘度值偏低")+QString::number(sysPara->status.viscosity));
|
||
qDebug()<<"粘度值偏低";
|
||
sysPara->status.viscosityFault = 2;
|
||
if(sysPara->devOp->isMixValveOpen()) {
|
||
sysPara->devOp->controlMixValve(false);
|
||
}
|
||
}
|
||
if(viscosity_faulty_num >= 5)
|
||
{
|
||
// LogInfo::setRunStatusText(tr("错误!!!!!!!!!!!粘度偏大故障")+QString::number(sysPara->status.viscosity));
|
||
qDebug()<<"粘度偏大故障";
|
||
sysPara->status.viscosityFault = 1;
|
||
}
|
||
|
||
}
|
||
if((sysPara->status.viscosityDelayCnt >= (sysPara->para.viscosityPumpInterval*100+120)) && flag==1)
|
||
{
|
||
if(sysPara->devOp->isMixValveOpen()) {
|
||
sysPara->devOp->controlMixValve(false);
|
||
}
|
||
}
|
||
|
||
if((sysPara->status.viscosityDelayCnt >= (sysPara->para.viscosityPumpInterval*100+130)) && flag==1)
|
||
{
|
||
if (sysPara->devOp->isViscosityPumpOpen()) {
|
||
sysPara->devOp->controlViscosityPump(false);
|
||
}
|
||
sysPara->status.viscosityDelayCnt = 0;
|
||
flag=0;
|
||
}
|
||
|
||
if(sysPara->status.statWarn & WARN_STATUS_VISCOTITY_MEASURE_READY){ //上位灯检测标志位
|
||
viscosity_timer->stop();
|
||
}
|
||
|
||
if(sysPara->status.viscosityDelayCnt < sysPara->para.viscosityPumpInterval*100) {
|
||
static int detectBelow = 0;
|
||
if (++detectBelow%400 == 0) {
|
||
if(sysPara->status.statWarn & WARN_STATUS_VISCOTITY_MEASURE_READY)
|
||
{
|
||
if(sysPara->status.rWarnViscoReady>=15){
|
||
sysPara->status.viscosityFault = 1;
|
||
sysPara->status.viscosity=0;
|
||
if(!firstTime)
|
||
qDebug()<<"错误!粘度计下位灯故障."+QString::number(sysPara->status.viscosity);
|
||
// LogInfo::setRunStatusText(tr("错误!粘度计下位灯故障.")+QString::number(sysPara->status.viscosity));
|
||
hasDetectedBellow = true;
|
||
}
|
||
else sysPara->status.rWarnViscoReady++;
|
||
}
|
||
else {
|
||
sysPara->status.rWarnViscoReady = 0;
|
||
sysPara->status.viscosityFault = 0;
|
||
}
|
||
}
|
||
}
|
||
if(hasDetectedBellow && hasDetectedTop)
|
||
{
|
||
if(sysPara->devOp->isMixValveOpen()) { //
|
||
sysPara->devOp->controlMixValve(false); //如果检测不到上下位灯就关掉混合阀
|
||
}
|
||
}
|
||
if(sysPara->status.viscosityFault==0)
|
||
{
|
||
hasDetectedBellow = false;
|
||
hasDetectedTop = false;
|
||
}
|
||
// }
|
||
/*-----------------------------------回收泵------------------------------------------*/
|
||
|
||
if(!sysPara->status.autoCtlReclaimAfterSWintOff)
|
||
{
|
||
if(!sysPara->devOp->isReclaimPumpOpen() ){ //回收泵
|
||
// ui->tabMainWindow->setRunStatus(tr("全速回收泵!!!"));
|
||
sysPara->status.reclaimPumpFullSpeedCnt = 0;
|
||
sysPara->devOp->controlReclaimPump(true,true); //先全速，后降速
|
||
}
|
||
else if(sysPara->status.reclaimPumpFullSpeedCnt <= RECLAIM_PUMP_FULL_SPEED_CNT){
|
||
sysPara->status.reclaimPumpFullSpeedCnt ++;
|
||
if(sysPara->status.reclaimPumpFullSpeedCnt == RECLAIM_PUMP_FULL_SPEED_CNT){ //降速
|
||
// ui->tabMainWindow->setRunStatus(tr("降速回收泵!!!"));
|
||
sysPara->devOp->controlReclaimPump(true,false);
|
||
}
|
||
}
|
||
}
|
||
/*-----------------------------------------------------------------------------*/
|
||
}
|
||
}
|
||
}
|
||
|
||
//在开机自检过程中交替打开和关闭循环阀
|
||
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("回收槽到头"));
|
||
m_MainWidget->setReclaimStatus(true, 100);
|
||
m_MainWidget->enablePrintButton(true); //仅仅在此时能使能打印按钮
|
||
// sysPara->devOp->highVoltageCtrl(1);
|
||
|
||
m_MainWidget->stopFlashReclaimOpenBtn();
|
||
|
||
// emit reclaimTankOpenDone();
|
||
/*回收槽开关时间校正*/
|
||
sysPara->para.reclaimTankTime =( sysPara->status.currReclaimTankPos>120 )? sysPara->status.currReclaimTankPos/10-1:12;
|
||
m_SystemSetting->updateReclaimTime( sysPara->para.reclaimTankTime );
|
||
|
||
qDebug()<<"reclaimTankOpenDone currReclaimTankPos:"<<sysPara->status.currReclaimTankPos;
|
||
qDebug()<<"reclaimTankOpenDone curr_reclaimTankTime:"<<sysPara->status.curr_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));
|
||
|
||
// 不知道为什么会有rate为0，且 sysPara->status.reclaimTankstatus == 2 ，也就是 关的状态。 回收槽位置在0处，而状态却是 关 ，很奇怪
|
||
if(sysPara->status.reclaimTankstatus != 2 && rate != 0) {
|
||
m_MainWidget->setReclaimStatus(sysPara->status.reclaimTankstatus == 1, rate);
|
||
}
|
||
|
||
m_MainWidget->setReclaimOpenBtnStatus(sysPara->status.reclaimTankstatus == 2);
|
||
m_MainWidget->setReclaimCloseBtnStatus(sysPara->status.reclaimTankstatus == 1);
|
||
|
||
sysPara->status.reclaimBlockedCnt = 0;
|
||
}
|
||
else if(sysPara->status.reclaimTankstatus == 6 )//7 故障，6 关完成，5开完成，4 保持， 3 停止， 2 关， 1 开，0-无操作
|
||
{
|
||
if(sysPara->devOp->isReclaimTankCloseEnable())
|
||
sysPara->devOp->controlReclaimTankClose(false); //到头，关闭
|
||
m_MainWidget->setReclaimStatus(false, 0);
|
||
m_MainWidget->stopFlashReclaimOpenBtn();
|
||
//sysPara->status.currReclaimTankPos = 0; //将回收槽的时间置为零
|
||
// emit reclaimTankCloseDone();
|
||
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));
|
||
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));
|
||
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));
|
||
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);
|
||
|
||
// 应用完数据之后，将当前值编辑标志位清除，避免下次读取时为 true
|
||
model.cnt1Settings.editCurrValue = false;
|
||
model.cnt2Settings.editCurrValue = false;
|
||
PicSceneLoader::saveSceneToXmlFile(filename, scene, &model);
|
||
|
||
ret = m_MainWidget->generatePrintContent(scene);
|
||
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);
|
||
}
|
||
|
||
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;
|
||
if (type == CARD_TYPE::INK) {
|
||
// 只有当报警标志为true时，文件的时间才会更新，此时才读取
|
||
if(sysPara->para.flagOfInkWarning) {
|
||
int dateTimeDiff = updateWarningTime(type);
|
||
if (dateTimeDiff > 60*60*24*2) {
|
||
sysPara->RFIDPara.inkCardTimeOut = true;
|
||
}
|
||
if (!sysPara->RFIDPara.inkCardTimeOut)
|
||
inkTime = 48- dateTimeDiff/60/60;
|
||
}
|
||
if(sysPara->RFIDPara.inkCardTimeOut && flagOfWarning){
|
||
if(++sysPara->status.showInkWarningNumber >= INTERVAL_AFTER48H){
|
||
warningShow(CARD_TYPE::INK,49);
|
||
sysPara->status.showInkWarningNumber = 0;//是否有必要保存?
|
||
sysPara->saveRFIDPara();
|
||
flagOfWarning = false;
|
||
return;
|
||
}
|
||
}
|
||
sysPara->saveRFIDPara();
|
||
}
|
||
else if(type == CARD_TYPE::SOLVENT) {
|
||
//只有当报警标志为true时，文件的时间才会更新，此时才读取
|
||
if (sysPara->para.flagOfSolventWarning) {
|
||
int dateTimeDiff = updateWarningTime(type);
|
||
if (dateTimeDiff > 60*60*24*2) {
|
||
sysPara->RFIDPara.solventCardTimeOut = true;
|
||
}
|
||
|
||
if (!sysPara->RFIDPara.solventCardTimeOut)
|
||
solventTime = 48- dateTimeDiff / 60 / 60;
|
||
}
|
||
|
||
if(sysPara->RFIDPara.solventCardTimeOut && flagOfWarning){
|
||
if(++sysPara->status.showSolventWarningNumber >= INTERVAL_AFTER48H){
|
||
warningShow(CARD_TYPE::SOLVENT,49);
|
||
sysPara->status.showSolventWarningNumber = 0;
|
||
sysPara->saveRFIDPara();
|
||
flagOfWarning = false;
|
||
return;
|
||
}
|
||
}
|
||
|
||
sysPara->saveRFIDPara();
|
||
}
|
||
/***********处理保养到期提示start******************/
|
||
else 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
|
||
if (type == INK && sysPara->para.flagOfInkWarning)
|
||
warningShow(type,inkTime);
|
||
else if (type == SOLVENT && sysPara->para.flagOfSolventWarning)
|
||
warningShow(type,solventTime);
|
||
|
||
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.runTime += 30;
|
||
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()));
|
||
|
||
auto checkReclaimOpenBtn = [this]() {
|
||
if(sysPara->status.selfCheckDone && (sysPara->status.reclaimTankstatus == 2 || sysPara->status.reclaimTankstatus == 6)) {
|
||
m_MainWidget->setReclaimOpenBtnStatus(true);
|
||
}
|
||
};
|
||
|
||
connect(manager_rfid, &RFIDManager::sig_inkCardProgressFinished, this, checkReclaimOpenBtn);
|
||
connect(manager_rfid, &RFIDManager::sig_solventProgressFinished, this, checkReclaimOpenBtn);
|
||
}
|
||
}
|
||
|
||
void InkJetPrinter::handleWarnInk()
|
||
{
|
||
static bool logFlag_inkCard = 1; // 每次启动提示一次即可
|
||
if(!sysPara->para.flagOfInkWarning){
|
||
if(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
|
||
sysPara->status.inkWarningCnt++; // 累计警报10次就提示
|
||
else {
|
||
sysPara->status.inkWarningCnt = 0;
|
||
}
|
||
|
||
if(sysPara->status.inkWarningCnt >= DETECT_WARNING_TIME){
|
||
sysPara->para.flagOfInkWarning = true;
|
||
manager_rfid->setInkCardFirstPrompt(true);
|
||
QString strCurDateTime = QDateTime::currentDateTime().toString("yyMMddhhmmss");
|
||
LogInfo::setRunStatusText("Ink warning.");
|
||
qDebug()<<"墨水液位报警";
|
||
if(sysPara->para.inkWarnDate == 0){
|
||
sysPara->para.inkWarnDate = strCurDateTime.mid(0,6).toInt();
|
||
sysPara->para.inkWarnTime = strCurDateTime.mid(6,6).toInt();
|
||
}
|
||
|
||
warningShow(1, 48);
|
||
|
||
sysPara->saveParaToFile();
|
||
}
|
||
}
|
||
else{
|
||
|
||
if(logFlag_inkCard){
|
||
logFlag_inkCard = 0;
|
||
QString strDate = QString::number(sysPara->para.inkWarnDate);
|
||
QString strTime = QString::number(sysPara->para.inkWarnTime);
|
||
QString str1 = QString::number(strDate.mid(0,2).toInt()).rightJustified(2,'0');
|
||
QString str2 = QString::number(strDate.mid(2,2).toInt()).rightJustified(2,'0');
|
||
QString str3 = QString::number(strDate.mid(4,2).toInt()).rightJustified(2,'0');
|
||
QString str4 = QString::number(strTime.mid(0,2).toInt()).rightJustified(2,'0');
|
||
QString str5 = QString::number(strTime.mid(2,2).toInt()).rightJustified(2,'0');
|
||
QString str6 = QString::number(strTime.mid(4,2).toInt()).rightJustified(2,'0');
|
||
QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
|
||
LogInfo::setRunStatusText(tr("ink Warning at: %1").arg(strDateTime));
|
||
qDebug()<<"ink Warning at:"<<strDateTime;
|
||
}
|
||
}
|
||
|
||
if(sysPara->para.flagOfInkWarning){
|
||
if(!sysPara->RFIDPara.needInkCard){
|
||
// 软件启动后第一次提示的时间
|
||
QDateTime curDateTime = QDateTime::currentDateTime();
|
||
QByteArray curDateTimestr = curDateTime.toString("yyyy-MM-dd HH::mm::ss").toUtf8();
|
||
QFile file("/home/plg/inkRFIDTime.txt");
|
||
if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate)){
|
||
qDebug()<<"Open inkRFIDTime Failure.";
|
||
LogInfo::setRunStatusText("Open inkRFIDTime Failure.");
|
||
}
|
||
int ret = file.write(curDateTimestr);
|
||
if(ret <= 0){
|
||
qDebug()<<"Write inkRFIDTime Failure.";
|
||
LogInfo::setRunStatusText("Write inkRFIDTime Failure.");
|
||
}
|
||
file.close();
|
||
|
||
sysPara->RFIDPara.needInkCard = true;
|
||
sysPara->saveRFIDPara();
|
||
}
|
||
warningHandler(CARD_TYPE::INK);
|
||
// 状态正常但是需要刷卡，说明此时先加的墨水，后面再刷卡
|
||
if(!(sysPara->status.statWarn & WARN_STATUS_INK_WARN)
|
||
&& sysPara->RFIDPara.needInkCard){
|
||
|
||
sysPara->RFIDPara.addedInk = true;
|
||
|
||
sysPara->saveRFIDPara();
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
void InkJetPrinter::handleWarnSolvent()
|
||
{
|
||
static bool logFlag_solventCard = 1; // 每次启动提示一次即可
|
||
if(!sysPara->para.flagOfSolventWarning){
|
||
if(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN)
|
||
sysPara->status.solventWarningCnt++;
|
||
else{
|
||
sysPara->status.solventWarningCnt = 0;
|
||
}
|
||
|
||
if(sysPara->status.solventWarningCnt >= DETECT_WARNING_TIME){
|
||
sysPara->para.flagOfSolventWarning = true;
|
||
manager_rfid->setSolventCardFirstPrompt(true);
|
||
QDateTime curDateTime = QDateTime::currentDateTime();
|
||
QString strCurDateTime = curDateTime.toString("yyMMddhhmmss");
|
||
LogInfo::setRunStatusText("Solvent warning.");
|
||
qDebug()<<"溶剂液位报警";
|
||
if(sysPara->para.solventWarnDate == 0){
|
||
sysPara->para.solventWarnDate = strCurDateTime.mid(0,6).toInt();
|
||
sysPara->para.solventWarnTime = strCurDateTime.mid(6,6).toInt();
|
||
}
|
||
|
||
warningShow(2, 48);
|
||
|
||
sysPara->saveParaToFile();
|
||
}
|
||
}
|
||
else{
|
||
if(logFlag_solventCard){
|
||
logFlag_solventCard = 0;
|
||
QString strDate = QString::number(sysPara->para.solventWarnDate);
|
||
QString strTime = QString::number(sysPara->para.solventWarnTime);
|
||
QString str1 = QString::number(strDate.mid(0,2).toInt()).rightJustified(2,'0');
|
||
QString str2 = QString::number(strDate.mid(2,2).toInt()).rightJustified(2,'0');
|
||
QString str3 = QString::number(strDate.mid(4,2).toInt()).rightJustified(2,'0');
|
||
QString str4 = QString::number(strTime.mid(0,2).toInt()).rightJustified(2,'0');
|
||
QString str5 = QString::number(strTime.mid(2,2).toInt()).rightJustified(2,'0');
|
||
QString str6 = QString::number(strTime.mid(4,2).toInt()).rightJustified(2,'0');
|
||
QString strDateTime = str1 + "-" + str2 + "-" + str3 + " " + str4 + ":" + str5 + ":" + str6;
|
||
LogInfo::setRunStatusText(tr("solvent Warning at: %1").arg(strDateTime));
|
||
qDebug()<<"solvent Warning at:"<<strDateTime;
|
||
}
|
||
}
|
||
|
||
if(sysPara->para.flagOfSolventWarning){
|
||
if(!sysPara->RFIDPara.needSolventCard){
|
||
QDateTime curDateTime = QDateTime::currentDateTime();
|
||
QByteArray curDateTimestr = curDateTime.toString("yyyy-MM-dd HH::mm::ss").toUtf8();
|
||
QFile file("/home/plg/solventRFIDTime.txt");
|
||
if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate)){
|
||
qDebug()<<"Open solventRFIDTime Failure.";
|
||
LogInfo::setRunStatusText("Open solventRFIDTime Failure.");
|
||
}
|
||
int ret = file.write(curDateTimestr);
|
||
if(ret <= 0){
|
||
qDebug()<<"Write solventRFIDTime Failure.";
|
||
LogInfo::setRunStatusText("Write solventRFIDTime Failure.");
|
||
}
|
||
file.close();
|
||
|
||
sysPara->RFIDPara.needSolventCard = true;
|
||
sysPara->saveRFIDPara();
|
||
}
|
||
warningHandler(CARD_TYPE::SOLVENT);
|
||
// 如果溶剂报警，说明此时先加的溶剂，后面再刷卡
|
||
if(!(sysPara->status.statWarn & WARN_STATUS_SOLV_WARN)
|
||
&& sysPara->RFIDPara.needSolventCard){
|
||
|
||
sysPara->RFIDPara.addedSolvent = true;
|
||
sysPara->saveRFIDPara();
|
||
}
|
||
}
|
||
|
||
}
|
||
#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;
|
||
}
|
||
|
||
auto ret = loadWorkFileAndPreparePrint(filename);
|
||
LogInfo::setRunStatusText(QString("Work file opened: %1, result: %2").arg(filename).arg(ret));
|
||
}
|