ostc_companion: OSTC2cOperations.cpp comparison

comparison OSTC2cOperations.cpp @ 8:21ce6187d32e

Minor changes done by automatic style checker

author	Ideenmodellierer
date	Mon, 12 Jan 2026 13:51:17 +0000
parents	0b3630a29ad8
children

comparison

equal deleted inserted replaced

-:0969ef86c42d
+:21ce6187d32e
 #include "Utils/ProgressEvent.h"
 #include <QDateTime>
 #include <QRegularExpression>
-#define FIRMWARE_SIZE       0x17F40
+#define FIRMWARE_SIZE 0x17F40
 // 64 bytes on Mk.2/2n/2c:
 #define FIRMWARE_BLOCK_SIZE 0x40
 //////////////////////////////////////////////////////////////////////////////
 OSTC2cOperations::OSTC2cOperations()
-: HardwareOperations(),
+: HardwareOperations()
-_computerFirmware(0),
+, _computerFirmware(0)
-_computerSerial(0)
+, _computerSerial(0)
-{
+{}
-}
 //////////////////////////////////////////////////////////////////////////////
 void OSTC2cOperations::readBank0(byte bank0[])
 {
 {
 _serial.sleep(100);
 _serial.purge();
 _serial.writeByte('d');
 int reply = _serial.readByte();
-if( reply != 'd' )
+if (reply != 'd')
 LOG_THROW("Write start");
-for(int a=4; a<256; ++a) {
+for (int a = 4; a < 256; ++a) {
 _serial.writeByte(bank0[a]);
 reply = _serial.readByte();
-if( reply != bank0[a] )
+if (reply != bank0[a])
 LOG_THROW("Write bank0 @ " << a);
 }
 _serial.sleep(500); // Allow OSTC2c some time to reboot
 }
 //---- Get a memory dump:
 try {
 readBank0(bank0);
 readBank1(bank1);
-} catch(ReadTimeout) {
+} catch (ReadTimeout) {
 LOG_THROW("No reply from OSTC Mk.2, 2n or 2c...");
 }
 // Sanity check:
-if( bank0[65] == 0xFF || bank1[1] > 99 || bank1[2] > 99 )
+if (bank0[65] == 0xFF || bank1[1] > 99 || bank1[2] > 99)
 LOG_THROW("Not an OSTC Mk.2, 2n or 2c...");
-_computerSerial   = bank0[0] + bank0[1]*256;
+_computerSerial = bank0[0] + bank0[1] * 256;
 _computerFirmware = bank1[1] * 100 + bank1[2];
-_customText       = QString::fromLatin1((char*)bank0+65, 25).section('}', 0,0);
+_customText = QString::fromLatin1((char *) bank0 + 65, 25).section('}', 0, 0);
 _description = QString("%1 #%2, v%3.%4, %5")
 .arg(model())
 .arg(_computerSerial)
-.arg(bank1[1]).arg(bank1[2], 2, 10, QChar('0'))
+.arg(bank1[1])
-.arg( _customText );
+.arg(bank1[2], 2, 10, QChar('0'))
+.arg(_customText);
 }
 int OSTC2cOperations::firmware() const
 {
 return _computerFirmware;
 }
 #endif
 QRegularExpression OSTC2cOperations::portTemplate() const
 {
 #if defined(Q_OS_MAC)
-return QRegularExpression("tty.usbserial-.*",
+return QRegularExpression("tty.usbserial-.*", QRegularExpression::CaseInsensitiveOption);
-QRegularExpression::CaseInsensitiveOption);
 #elif defined(Q_OS_LINUX)
 return QRegularExpression("ttyUSB.*"); // default: case-sensitive
 #elif defined(Q_OS_WIN)
-return QRegularExpression("COM.*");    // default: case-sensitive
+return QRegularExpression("COM.*"); // default: case-sensitive
 #endif
 }
 QStringList OSTC2cOperations::listPorts() const
 {
 return listUSBPorts();
 //////////////////////////////////////////////////////////////////////////////
 HardwareOperations::CompanionFeatures OSTC2cOperations::supported() const
 {
 // No ICON.
-return CompanionFeatures(PARAMETERS|DATE|NAME|DUMPSCREEN|FIRMWARE
+return CompanionFeatures(PARAMETERS | DATE | NAME | DUMPSCREEN | FIRMWARE | HELIUM_DIVE
-|HELIUM_DIVE|CCR_DIVE);
+| CCR_DIVE);
 }
 //////////////////////////////////////////////////////////////////////////////
 QString OSTC2cOperations::firmwareTemplate() const
 try {
 LOG_TRACE("Connecting " << Settings::port);
 _serial.open(Settings::port, "OSTC2c");
 getIdentity();
 return true;
-}
+} catch (const Exception &e) {
-catch(const Exception& e){
 _serial.close();
 LOG_THROW("Cannot connect " << Settings::port << ": " << e.what());
 }
 return false;
 }
 QSize OSTC2cOperations::nameSize() const
 {
 return QSize(25, 1);
 }
-void OSTC2cOperations::writeText(const QString& msg)
+void OSTC2cOperations::writeText(const QString &msg)
 {
 // No hardware support for that. Just skip it, as it is done when
 // writting bank1...
 LOG_TRACE(msg);
 }
 {
 try {
 _serial.open(Settings::port, "OSTC2c");
 _serial.writeByte(0xC1);
-_serial.sleep(500);                    // 0.50 sec for bootloader to start.
+_serial.sleep(500); // 0.50 sec for bootloader to start.
 //---- Send C1C1 to start upgrading firmware -----------------------------
 unsigned char pic = 0;
 unsigned char ok = '?';
-for(int retry=0; retry < 10; ++retry) {
+for (int retry = 0; retry < 10; ++retry) {
 _serial.writeByte(0xC1);
 _serial.sleep(5);
 _serial.writeByte(0xC1);
 _serial.sleep(5);
 try {
 pic = _serial.readByte();
-ok  = _serial.readByte();
+ok = _serial.readByte();
 break;
-}
+} catch (const ReadTimeout &) {
-catch(const ReadTimeout&) {
+if (retry == 9)
-if( retry == 9 )
 LOG_THROW("Cannot start firmware upgrade: timeout.");
-LOG_INFO("Connecting OSTC2c (" << (retry+1) << "/10)...");
+LOG_INFO("Connecting OSTC2c (" << (retry + 1) << "/10)...");
 }
 }
 //---- Check PIC type ----------------------------------------------------
 LOG_TRACE("Pic = " << int(pic));
-if( ! pic )
+if (!pic)
 LOG_THROW("Cannot sync firmware upgrade. Cannot detect chip");
-if( pic != 0x57
+if (pic != 0x57 || ok != 'K')
-|| ok  != 'K'
+LOG_THROW("Cannot sync firmware upgrade. Bad chip " << int(pic) << " " << ok);
-)
-LOG_THROW( "Cannot sync firmware upgrade. Bad chip " << int(pic) << " " << ok);
+_serial.sleep(50); // Wait 0.050 sec here.
-_serial.sleep(50);                       // Wait 0.050 sec here.
 return;
-}
+} catch (const Exception &e) {
-catch(const Exception& e) {
 _serial.close();
 LOG_THROW("Cannot connect " << Settings::port << ": " << e.what());
 }
 return;
 }
 //////////////////////////////////////////////////////////////////////////////
 bool OSTC2cOperations::disconnect(bool /*closing*/)
 {
-if( ! _serial.isOpen() ) return false;
+if (!_serial.isOpen())
+return false;
 LOG_TRACE("Disconnecting.");
 _serial.purge();
 _serial.close();
 buffer[2] = date.time().second();
 buffer[3] = date.date().month();
 buffer[4] = date.date().day();
 buffer[5] = date.date().year() % 100;
-_serial.sleep(100);         // Make sure last command is finished.
+_serial.sleep(100); // Make sure last command is finished.
 _serial.purge();
 _serial.writeByte('b'); // 0x62
 unsigned char reply = _serial.readByte();
-if( reply != 'b' )
+if (reply != 'b')
-LOG_THROW( "sync time" );
+LOG_THROW("sync time");
-_serial.writeBlock( buffer, sizeof buffer);
+_serial.writeBlock(buffer, sizeof buffer);
 _serial.sleep(100);
 }
 //////////////////////////////////////////////////////////////////////////////
 void OSTC2cOperations::setName(const QString &newName)
 {
-QByteArray padded = (newName + QString(25, '}'))
+QByteArray padded = (newName + QString(25, '}')).left(25).toLatin1();
-.left(25)
-.toLatin1();
 byte bank0[256] = {0};
 readBank0(bank0);
-memcpy(bank0+65, padded.constData(), 25);
+memcpy(bank0 + 65, padded.constData(), 25);
 writeBank0(bank0);
 // Then get the new identity:
 getIdentity();
 }
 //////////////////////////////////////////////////////////////////////////////
-void OSTC2cOperations::setIcons(const QString &/*fileName*/)
+void OSTC2cOperations::setIcons(const QString & /*fileName*/)
 {
 LOG_THROW("Not supported");
 }
 //////////////////////////////////////////////////////////////////////////////
 QImage OSTC2cOperations::dumpScreen() const
 {
 QImage image(320, 240, QImage::Format_RGB32);
 //---- Send dump screen command -------------------------------------
 unsigned char reply;
 _serial.writeByte('l');
 reply = _serial.readByte();
-if( reply != 'l' )
+if (reply != 'l')
-LOG_THROW( "Dumpscreen command failed: " << (int)reply );
+LOG_THROW("Dumpscreen command failed: " << (int) reply);
 //---- Read image ----------------------------------------------------
 int percent = 0;
 try {
-for(int x=0; x<320; ++x)
+for (int x = 0; x < 320; ++x) {
-{
+int p = x / 16; // 5% steps
-int p = x/16;       // 5% steps
+if (p != percent) {
-if( p != percent )
+PROGRESS(p, 320 / 16);
-{
-PROGRESS(p, 320/16);
 percent = p;
 }
 int pix = 0, count = 0;
-for(int y=0; y<240; ++y, --count)
+for (int y = 0; y < 240; ++y, --count) {
-{
+if (count <= 0) {
-if( count <= 0 )
-{
 count = _serial.readByte();
-if( (count & 0x80) == 0 )
+if ((count & 0x80) == 0)
 pix = 0;
-else if( (count & 0xC0) == 0xC0 )
+else if ((count & 0xC0) == 0xC0) {
-{
 pix = 0xFFFF;
 count &= 0x3F;
-}
+} else {
-else
-{
 unsigned char bpix[2];
 _serial.readBlock(bpix, 2);
 pix = (bpix[0] << 8) + bpix[1];
 count &= 0x3F;
 }
 count++;
 }
 // Bit extension 5bits --> 8bits:
 //      12345123.45 = (12345 * 0b100001) / 4
 //      12345612.3456 = (123456 * 0xb1000001) / 16
-int r = (31 & (pix >> 11)) * 255/31;
+int r = (31 & (pix >> 11)) * 255 / 31;
-int g = (63 & (pix >>  5)) * 255/63;
+int g = (63 & (pix >> 5)) * 255 / 63;
-int b = (31 &  pix       ) * 255/31;
+int b = (31 & pix) * 255 / 31;
-image.setPixel(x, y, qRgb( r, g, b));
+image.setPixel(x, y, qRgb(r, g, b));
 }
 }
-}
+} catch (ReadTimeout) {
-catch( ReadTimeout ) {
 LOG_THROW("Missing image data...");
 }
 //---- Done ----------------------------------------------------------
 PROGRESS_RESET();
-LOG_INFO( "Screen dumped." );
+LOG_INFO("Screen dumped.");
 return image;
 }
 //////////////////////////////////////////////////////////////////////////////
-void OSTC2cOperations::loadFirmware(HexFile& hex, const QString& fileName) const
+void OSTC2cOperations::loadFirmware(HexFile &hex, const QString &fileName) const
 {
 hex.allocate(FIRMWARE_SIZE);
 hex.load(fileName);
 //---- Patch Firmware intialization GOTO ---------------------------------
-memcpy((void*)(hex.data() + 0x17F38),   // To bootloader vector
+memcpy((void *) (hex.data() + 0x17F38), // To bootloader vector
-(void*)(hex.data() + 0x00000),   // From fw reset code
+(void *) (hex.data() + 0x00000), // From fw reset code
 8);                              // Up to 8 bytes...
 static unsigned char byteCode[8] = {
-0xA0, 0xEF, 0xBF, 0xF0,             // goto 0x1F740 (bootloader 19k)
+0xA0,
-0x00, 0x00,                         // nop
+0xEF,
-0x00, 0x00                          // nop
+0xBF,
+0xF0, // goto 0x1F740 (bootloader 19k)
+0x00,
+0x00, // nop
+0x00,
+0x00 // nop
 };
-memcpy((void*)(hex.data() + 0x00000),   // To OSTC reset vector
+memcpy((void *) (hex.data() + 0x00000), // To OSTC reset vector
-(void*)(byteCode),               // From go back to bootloader.
+(void *) (byteCode),             // From go back to bootloader.
 8);                              // Up to 8 bytes...
 }
 //////////////////////////////////////////////////////////////////////////////
-static void
+static void uploadBlock(Serial &serial, const HexFile &hex, size_t addr)
-uploadBlock(Serial& serial, const HexFile& hex, size_t addr)
 {
 const unsigned char count = FIRMWARE_BLOCK_SIZE;
-assert( 0 < count && count < 255 );
+assert(0 < count && count < 255);
-assert((addr+count) <= FIRMWARE_SIZE );
+assert((addr + count) <= FIRMWARE_SIZE);
 unsigned char reply = 0;
 unsigned char header[4];
 header[0] = 0x1F & (addr >> 16);
-header[1] = 0xFF & (addr >>  8);
+header[1] = 0xFF & (addr >> 8);
 header[2] = 0xFF & (addr);
 header[3] = count;
 unsigned char crc = header[0] + header[1] + header[2] + header[3];
-for(int i=0; i<count; ++i)
+for (int i = 0; i < count; ++i)
-crc += hex.data()[addr+i];
+crc += hex.data()[addr + i];
 crc = -crc; // Sum should make zero.
 try {
 serial.writeBlock(header, sizeof header);
-serial.writeBlock(hex.data()+addr, count);
+serial.writeBlock(hex.data() + addr, count);
 serial.writeByte(crc);
-} catch(...) {
+} catch (...) {
 goto WriteFailed;
 }
-serial.sleep(20);        // 18msec for a FLASH row write, plus VAT.
+serial.sleep(20); // 18msec for a FLASH row write, plus VAT.
 reply = serial.readByte();
-if( reply != 'K' )
+if (reply != 'K') {
-{
 serial.close();
-LOG_THROW( QString("Bad checksum at 0x%1").arg((unsigned int)addr, 0, 16, QChar('0')));
+LOG_THROW(QString("Bad checksum at 0x%1").arg((unsigned int) addr, 0, 16, QChar('0')));
 }
 return;
 WriteFailed:
 serial.close();
-LOG_THROW( QString("Write failed") );
+LOG_THROW(QString("Write failed"));
 }
-void OSTC2cOperations::upgradeFW(const QString& fileName)
+void OSTC2cOperations::upgradeFW(const QString &fileName)
 {
 //---- Load and check firmware ---------------------------------------
 LOG_TRACE("Loading firmware '" << fileName << "'.");
 HexFile hex;
 loadFirmware(hex, fileName);
 connectServiceMode();
 //---- Let's do it -------------------------------------------------------
 int percent = 0;
-for(size_t addr = FIRMWARE_BLOCK_SIZE; addr < FIRMWARE_SIZE; addr += FIRMWARE_BLOCK_SIZE)
+for (size_t addr = FIRMWARE_BLOCK_SIZE; addr < FIRMWARE_SIZE; addr += FIRMWARE_BLOCK_SIZE) {
-{
+int p = int((addr * 200.0f) / float(FIRMWARE_SIZE) + 0.5f);
-int p = int((addr*200.0f) / float(FIRMWARE_SIZE) + 0.5f);
+if (p > percent) {
-if( p > percent )
-{
 PROGRESS(percent, 200);
 percent = p;
 }
 uploadBlock(_serial, hex, addr);
 }
 void OSTC2cOperations::getSignal()
 {
 return;
 }
-void OSTC2cOperations::getAllHeader(unsigned char* pBuffer)
+void OSTC2cOperations::getAllHeader(unsigned char *pBuffer)
 {
 return;
 }
-void OSTC2cOperations::writeAllHeader(unsigned char* pBuffer)
+void OSTC2cOperations::writeAllHeader(unsigned char *pBuffer)
 {
 return;
 }
-void OSTC2cOperations::getAllSamples(unsigned char* pBuffer)
+void OSTC2cOperations::getAllSamples(unsigned char *pBuffer)
 {
 return;
 }
-void OSTC2cOperations::writeAllSamples(unsigned char* pBuffer)
+void OSTC2cOperations::writeAllSamples(unsigned char *pBuffer)
 {
 return;
 }
 //////////////////////////////////////////////////////////////////////////////

Mercurial > public > ostc_companion

comparison OSTC2cOperations.cpp @ 8:21ce6187d32e