#include "update.h" #include "worker.h" #include "utils.h" #include "update_dc_event.h" #include "mainwindow.h" #include #include #include #include #include #include #include #include #include #if defined (Q_OS_UNIX) || defined (Q_OS_LINUX) #include "unistd.h" #endif #include "plugins/interfaces.h" #include #include #include #include #include #include #include #define UPDATE_OPKG (1) #define UPDATE_DC (0) static const QMap baudrateMap = { {"1200" , 0}, {"9600" , 1}, {"19200" , 2}, {"38400" , 3}, {"57600" , 4}, {"115200" , 5} }; QPluginLoader Update::pluginLoader; hwinf *Update::loadDCPlugin(QDir const &plugInDir, QString const &fname) { hwinf *hw = nullptr; if (plugInDir.exists()) { QString pluginLibName(fname); pluginLibName = plugInDir.absoluteFilePath(pluginLibName); QFileInfo info(pluginLibName); if (info.exists()) { pluginLibName = plugInDir.absoluteFilePath(pluginLibName); pluginLoader.setFileName(pluginLibName); // static QPluginLoader pluginLoader(pluginLibName); if (!pluginLoader.load()) { qCritical() << "in directory" << plugInDir.absolutePath(); qCritical() << "cannot load plugin" << pluginLoader.fileName(); qCritical() << pluginLoader.errorString(); exit(-1); } if (!pluginLoader.isLoaded()) { qCritical() << pluginLoader.errorString(); exit(-2); } QObject *plugin = pluginLoader.instance(); if (!plugin) { qCritical() << "cannot start instance"; exit(-3); } if (! (hw = qobject_cast(plugin))) { qCritical() << "cannot cast plugin" << plugin << "to hwinf"; exit(-4); } } else { qCritical() << pluginLibName << "does not exist"; exit(-5); } } else { qCritical() << "plugins directory" << plugInDir.absolutePath() << "does not exist"; exit(-6); } return hw; } bool Update::unloadDCPlugin() { if (pluginLoader.unload()) { qCritical() << "unloaded plugin" << pluginLoader.fileName(); // Note: will re-instantiate the library ! // QObject *rootObject = pluginLoader.instance(); // if (rootObject) { // qCritical() << "reloaded plugin: root object again available"; // return false; // } // qCritical()unloaded plugin: root object gone"; return true; } return false; } Update::Update(Worker *worker, QString customerRepository, QString customerNrStr, QString branchName, QString plugInDir, QString pluginName, QString workingDir, bool dryRun, QObject *parent, char const *serialInterface, char const *baudrate) : QObject(parent) , m_hw(loadDCPlugin(QDir(plugInDir), pluginName)) , m_worker(worker) , m_serialInterface(serialInterface) , m_baudrate(baudrate) , m_customerRepository(customerRepository) , m_customerNrStr(customerNrStr) , m_branchName(branchName) , m_pluginName(pluginName) , m_workingDir(workingDir) , m_dryRun(dryRun) , m_sys_areDCdataValid(false) { int tries = 20; while ((m_sys_areDCdataValid = m_hw->sys_areDCdataValid()) == false) { // must deliver 'true', only then are all data from hwapi valid if (--tries < 0) { qCritical() << "ERROR!!! DC DATA NOT VALID -> CA-MASTER-PLUGIN NOT CONNECTED"; } m_hw->dc_autoRequest(true); QThread::msleep(500); } qCritical() << "UPDATE: m_sys_areDCDataValid ..." << m_sys_areDCdataValid; //qInfo() << "UPDATE: m_serialInterface ..." << m_serialInterface; //qInfo() << "UPDATE: m_baudrate ..." << m_baudrate; //qInfo() << "UPDATE: m_customerRepository ..." << m_customerRepository; //qInfo() << "UPDATE: m_customerNr ..........." << m_customerNrStr; //qInfo() << "UPDATE: m_branchName ..........." << m_branchName; //qInfo() << "UPDATE: m_pluginName ..........." << m_pluginName; //qInfo() << "UPDATE: m_workingDirectory ....." << m_workingDir; } Update::~Update() { } // br is a index into a table, used for historical reasons. bool Update::openSerial(int br, QString baudrate, QString comPort) const { qDebug() << "opening serial" << br << baudrate << comPort << "..."; if (m_hw->dc_openSerial(br, baudrate, comPort, 1) == true) { // 1 for connect Utils::printInfoMsg( QString("OPENING SERIAL %1").arg(br) + " " + baudrate + " " + comPort + "...OK"); // m_hw->dc_autoRequest(true); m_hw->dc_autoRequest(false); QThread::sleep(1); Utils::printInfoMsg(QString("IS PORT OPEN %1").arg(m_hw->dc_isPortOpen())); return true; } Utils::printCriticalErrorMsg( QString("OPENING SERIAL %1").arg(br) + " " + baudrate + " " + comPort + "...FAILED"); return false; } void Update::closeSerial() const { qInfo() << "CLOSED SERIAL" << m_baudrate << m_serialInterface; m_hw->dc_closeSerial(); } bool Update::isSerialOpen() const { return m_hw->dc_isPortOpen(); } /* /////////////////////////////////////////////////////////////////////////////// // // USING THE DC BOOTLOADER // /////////////////////////////////////////////////////////////////////////////// 1 : bl_reboot() // send to application, want DC2 to reset (in order to // start the bootloader) // // NOTE: this function is NOT reliable !!! Sometimes it // simply does not work, in which case bl_startBL, // bl_checkBL and bl_isUp do not work as well. // Alas, there is no feedback if bl_reboot worked! // // NOTE: this function can be called only once per // minute, because once called again, the controller // performs some self-checks consuming some time. // // NOTE: after a successful bl_reboot(), the device is // waiting about 4 seconds in the bootloader. To stay in // the bootloader, we have to send the command // bl_startBL(), which is kind of a misnomer, as it // should be bl_doNotLeaveBL(). // 2 : bl_startBL(): // send within 4s after DC power-on, otherwise // bootloader is left. // // NOTE: a running bootloader is a MUST for the download // process of a device controller firmware as it does // the actual writing of the memory (the bl_reboot() // from above erases the available memory). // 3 : bl_check(): // send command to verify if bl is up // // NOTE: this command is kind of a request that we want // to check if the bootloader is up. The device // (actually the bootloader) responds with its version. // 4 : bl_isUp(): // returns true if bl is up and running // // NOTE: we know what the bootloader version actually is // as the bootloader does not change. By comparing the // string received in the previous step with this known // version string we know if the bootloader is up. // // NOTE FOR ALL PREVIOUS STEPS: execute them in their // own slots each to be sure to receive any possible // responds from the device. // 5 : bl_sendAddress(blockNumber) // send start address, nr of 64-byte block, start with 0 // will be sent only for following block-numbers: // 0, 1024, 2048, 3072 and 4096, so basically every // 64kByte. // for other addresses nothing happens 6 : bl_wasSendingAddOK() // return val: 0: no response by now // 1: error // 10: OK 7 : bl_sendDataBlock() // send 64 byte from bin file 8 : bl_sendLastBlock() // send this command after all data are transferred 9 : bl_wasSendingDataOK() // return val: 0: no response by now // 1: error // 10: OK 10 : bl_stopBL() // leave bl and start (the new) application // // NOTE: this function MUST work under all conditions. // Alas, there is no direct result for this command, so // the only way of knowing it was successful is to ask // the device if the bootloader is still running. // There is no problem to repeat this command until the // bootloader is really not running anymore. */ bool Update::updateBinary(QString const &fileToSendToDC) { qInfo() << "UPDATING DEVICE CONTROLLER FIRMWARE BINARY" << fileToSendToDC; return false; QFile fn(fileToSendToDC); if (!fn.exists()) { // output via CONSOLE() etc return false; } bool bl_isUp = false; if (m_hw->bl_completeStart()) { int cnt = 5; while (--cnt > 0) { if (m_hw->bl_isUp()) { bl_isUp = true; break; } } } if (!bl_isUp) { return false; } if (!m_hw->bl_storeFirmware(fileToSendToDC)) { m_hw->bl_stopBL(); return false; } uint16_t const nrOfFirmwareBlocks = m_hw->bl_getNrOfFirmwareBlocks(); for (uint16_t blockNr = 0; blockNr <= nrOfFirmwareBlocks; ++blockNr) { m_hw->bl_blockAutoLoad(blockNr); int sleepTime = 0; while (1) { if (sleepTime > 1500) { m_hw->bl_stopBL(); return false; } int8_t const r = m_hw->bl_blockAutoResponse(); // after every "bl_blockAutoLoad()" call this until response // retval 0: wait 1: OK, blk was sent 2: OK, transfer complete // 3: error despite repeating, cancel. probably bin file corrupted // Max duration: 3x no response from BL = 900ms switch(r) { case 1: /* fall through */ case 2: sleepTime = 0; break; case 0: { QThread::msleep(100); sleepTime += 100; } break; case 3: m_hw->bl_stopBL(); return false; default: m_hw->bl_stopBL(); return false; // unknown error code } } m_hw->bl_stopBL(); } return true; } QString Update::jsonType(enum FileTypeJson type) { switch (type) { case FileTypeJson::CASH: return "CASH"; case FileTypeJson::CONFIG: return "CONFIG"; case FileTypeJson::PRINTER: return "PRINTER"; case FileTypeJson::SERIAL: return "SERIAL"; case FileTypeJson::DEVICE: return "DEVICE"; case FileTypeJson::TIME: return "TIME"; } return "N/A"; } bool Update::downloadJson(enum FileTypeJson type, int templateIdx, QString jsFileToSendToDC) const { m_hw->dc_autoRequest(true); // downloading Json needs the AutoEmission flag qDebug() << "SET AUTO-REQUEST=TRUE"; QThread::sleep(1); // make sure the auto-request flag is acknowledged bool ready = false; int nTry = 25; while ((ready = m_hw->sys_ready4sending()) == false) { QThread::msleep(200); if (--nTry <= 0) { Utils::printCriticalErrorMsg("SYS NOT READY FOR SENDING AFTER 5 SECONDS"); break; } } bool ret = false; if (ready) { QFile file(jsFileToSendToDC); QFileInfo fi(jsFileToSendToDC); // max. size of template file is 800 bytes if (file.exists()) { if (file.open(QIODevice::ReadOnly)) { if (fi.size() <= 800) { QByteArray ba = file.readAll(); // kindOfFile: 1=config, 2=device, 3=cash, 4=serial, 5=time, 6=printer // nrOfTemplate=1...32 if kindOfFile==6 // content = content of the Json file, max 800byte ascii signs if (m_hw->sys_sendJsonFileToDc((uint8_t)(type), templateIdx, (uint8_t *)ba.data())) { m_hw->dc_autoRequest(true); QThread::msleep(500); // testing m_hw->request_ReadbackMachineID(); QThread::msleep(500); uint8_t data[64]; memset(data, 0x00, sizeof(data)); uint8_t length = 0; m_hw->readback_machineIDdata(&length, data); QThread::msleep(500); QByteArray ba((const char*)data, length); qCritical() << length << "MACHINE ID =" << ba.toHex(':'); ret = true; } } else { Utils::printCriticalErrorMsg( QString("SIZE OF %1 TOO BIG (%2 BYTES)") .arg(jsFileToSendToDC).arg(fi.size())); } } else { Utils::printCriticalErrorMsg( QString("CAN NOT OPEN ") + jsFileToSendToDC + " FOR READING"); } } else { Utils::printCriticalErrorMsg( QString(jsFileToSendToDC) + " DOES NOT EXIST"); } } m_hw->dc_autoRequest(false); qDebug() << "SET AUTO-REQUEST=FALSE"; QThread::sleep(1); // make sure the auto-request flag is acknowledged return ret; } bool Update::updatePrinterTemplate(int templateIdx, QString jsFile) const { return downloadJson(FileTypeJson::PRINTER, templateIdx, jsFile); } bool Update::updateConfig(QString jsFile) { return downloadJson(FileTypeJson::CONFIG, 0, jsFile); } bool Update::updateCashConf(QString jsFile) { return downloadJson(FileTypeJson::CASH, 0, jsFile); } bool Update::updateDeviceConf(QString jsFile) { return downloadJson(FileTypeJson::DEVICE, 0, jsFile); } QStringList Update::split(QString line, QChar sep) { QStringList lst; QString next; int start = 0, end; while ((end = line.indexOf(sep, start)) != -1) { next = line.mid(start, end - start).trimmed(); lst << next; start = end + 1; } next = line.mid(start, end - start).trimmed(); lst << next; return lst; } void Update::readyReadStandardOutput() { QProcess *p = (QProcess *)sender(); QByteArray buf = p->readAllStandardOutput(); qCritical() << buf; } void Update::readyReadStandardError() { QProcess *p = (QProcess *)sender(); QByteArray buf = p->readAllStandardError(); qCritical() << buf; } void Update::finished(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/) { QProcess *p = (QProcess *)sender(); disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardOutput())); disconnect(p, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(readyReadStandardError())); } QStringList Update::getDcSoftAndHardWareVersion() { m_hw->dc_autoRequest(true); QThread::sleep(1); // make sure the timer-slots are active for (int i=0; i < 3; ++i) { // send explicit reuests to get // current SW/HW-versions m_hw->request_DC2_SWversion(); m_hw->request_DC2_HWversion(); QThread::sleep(1); } QString const &hwVersion = m_hw->dc_getHWversion().toLower().trimmed(); QString const &swVersion = m_hw->dc_getSWversion().toLower().trimmed(); m_hw->dc_autoRequest(false); QThread::sleep(1); // make sure the timer-slots are inactive if (!hwVersion.isEmpty() && !swVersion.isEmpty()) { return QStringList() << hwVersion << swVersion; } return QStringList() << "DC HW-version not available" << "DC SW-version not available"; } QString Update::getFileVersion(QString const& jsonFileName) { // "version":"15.10.2023 14:55 02.00.06", static const QRegularExpression re("^.*(\\\"version\\\":)(.*)$"); QString fileVersion; QFile inputFile(jsonFileName); if (inputFile.open(QIODevice::ReadOnly)) { QTextStream in(&inputFile); while (!in.atEnd()) { QString line = in.readLine(); QRegularExpressionMatch match; int idx = line.indexOf(re, 0, &match); if (idx != -1) { fileVersion = match.captured(match.lastCapturedIndex()); break; } } inputFile.close(); } return fileVersion; } bool Update::checkDownloadedJsonVersions(QStringList const& jsonFileNames) { for (QStringList::size_type i=0; i < jsonFileNames.size(); ++i) { uint8_t jsonNr = 0; QFileInfo fInfo(jsonFileNames[i]); if (fInfo.fileName().endsWith("conf.json")) { jsonNr = 1; } else if (fInfo.fileName().endsWith("device.json")) { jsonNr = 2; } else if (fInfo.fileName().endsWith("cash.json")) { jsonNr = 3; } else { QRegularExpressionMatch match; static const QRegularExpression re("^(.*print)([0-3][0-9])\\.json\\s*$"); int idx = fInfo.fileName().indexOf(re, 0, &match); if (idx != -1) { QString captured = match.captured(match.lastCapturedIndex()); bool ok = false; int n = captured.toInt(&ok); if (ok) { jsonNr = n + 4; } } } qCritical() << __PRETTY_FUNCTION__ << fInfo.fileName() << "jsonNr" << jsonNr; if (jsonNr != 0) { m_hw->sys_requestJsonVersions(jsonNr); QThread::msleep(500); char buf[64]; memset(buf, 0x00, sizeof(buf)); m_hw->sys_getJsonVersions(jsonNr, buf); buf[sizeof(buf)-1] = '\0'; QString const installedVersion(buf); QString const fileVersion = getFileVersion(jsonFileNames[i]); qCritical() << "installed version:" << installedVersion; qCritical() << " file version:" << fileVersion; if (installedVersion == fileVersion) { } } else { qCritical() << "CANNOT FIND JSON-NR FOR" << jsonFileNames[i]; } } return false; } bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) { if (m_sys_areDCdataValid == false) { qCritical() << "ERROR!!! DC DATA NOT VALID -> CA-MASTER-PLUGIN NOT CONNECTED"; return false; } bool res = false; QList::const_iterator it; for (it = filesToWorkOn.cbegin(); it != filesToWorkOn.cend(); ++it) { m_worker->startProgressLoop(); QString const &fToWorkOn = QDir::cleanPath(m_customerRepository + QDir::separator() + it->trimmed()); if (fToWorkOn.contains("dc2c.bin")) { bool updateBinaryRes = true; // CONSOLE() m_hw->dc_autoRequest(false);// default: turn auto-request setting off QThread::sleep(1); // wait to be sure that there are no more // commands sent to dc-hardware if ((updateBinaryRes = updateBinary(fToWorkOn)) == true) { // qCritical() << "downloaded binary" << fToWorkOn; ++displayIndex; emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(2, ' ') + QString(")") + QString(" Update ") + QFileInfo(fToWorkOn).fileName(), Worker::UPDATE_STEP_DONE); } m_hw->dc_autoRequest(true); // turn auto-request setting on // qInfo() << "SET AUTO-REQUEST=TRUE"; QStringList const &versions = Update::getDcSoftAndHardWareVersion(); if (versions.size() >= 2) { if (updateBinaryRes == true) { qInfo() << "dc-hardware-version (UPDATED)" << versions[0]; qInfo() << "dc-firmware-version (UPDATED)" << versions[1]; } else { qInfo() << "dc-hardware-version (NOT UPDATED)" << versions[0]; qInfo() << "dc-firmware-version (NOT UPDATED)" << versions[1]; } } res = updateBinaryRes; } else if (fToWorkOn.contains("DC2C_print", Qt::CaseInsensitive) && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) { res = true; int i = fToWorkOn.indexOf("DC2C_print", Qt::CaseInsensitive); int const templateIdx = fToWorkOn.mid(i).midRef(10, 2).toInt(); if ((templateIdx < 1) || (templateIdx > 32)) { qCritical() << "WRONG TEMPLATE INDEX" << templateIdx; res = false; } else { if ((res = updatePrinterTemplate(templateIdx, fToWorkOn))) { Utils::printInfoMsg( QString("DOWNLOADED PRINTER TEMPLATE %1 WITH INDEX=%2") .arg(fToWorkOn) .arg(templateIdx)); ++displayIndex; emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")") + QString(" Update ") + QFileInfo(fToWorkOn).fileName(), Worker::UPDATE_STEP_DONE); } } } else if (fToWorkOn.contains("DC2C_cash", Qt::CaseInsensitive) && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) { res = true; if ((res = updateCashConf(fToWorkOn))) { Utils::printInfoMsg(QString("DOWNLOADED CASH TEMPLATE %1").arg(fToWorkOn)); ++displayIndex; emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")") + QString(" Update ") + QFileInfo(fToWorkOn).fileName(), Worker::UPDATE_STEP_DONE); } } else if (fToWorkOn.contains("DC2C_conf", Qt::CaseInsensitive) && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) { res = true; if ((res= updateConfig(fToWorkOn))) { Utils::printInfoMsg(QString("DOWNLOADED CONFIG TEMPLATE %1").arg(fToWorkOn)); ++displayIndex; emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")") + QString(" Update ") + QFileInfo(fToWorkOn).fileName(), Worker::UPDATE_STEP_DONE); } } else if (fToWorkOn.contains("DC2C_device", Qt::CaseInsensitive) && fToWorkOn.endsWith(".json", Qt::CaseInsensitive)) { res = true; if ((res = updateDeviceConf(fToWorkOn))) { Utils::printInfoMsg(QString("DOWNLOADED DEVICE TEMPLATE %1").arg(fToWorkOn)); ++displayIndex; emit m_worker->appendText(QString("\n(") + QString("%1").arg(displayIndex).rightJustified(3, ' ') + QString(")") + QString(" Update ") + QFileInfo(fToWorkOn).fileName(), Worker::UPDATE_STEP_DONE); } } else { qCritical() << "UNKNOWN JSON FILE NAME" << fToWorkOn; res = false; } if (res == false) { break; } } // for (it = openLines.cbegin(); it != openLines.end(); ++it) { m_hw->dc_autoRequest(true); // ALWAYS turn autoRequest ON qDebug() << "SET AUTO-REQUEST=TRUE"; return res; }