--- a/OSTCFrogOperations.cpp	Mon Jan 12 13:49:16 2026 +0000
+++ b/OSTCFrogOperations.cpp	Mon Jan 12 13:51:17 2026 +0000
@@ -36,8 +36,8 @@
 
 #include "OSTCFrogOperations.h"
 
+#include "Utils/Exception.h"
 #include "Utils/Log.h"
-#include "Utils/Exception.h"
 
 #include "HexFile.h"
 #include "SettingsDialog.h"
@@ -48,30 +48,29 @@
 #include <QStringList>
 
 // Byte extration, compatible littleendian or bigendian.
-#define LOW(x)      ((unsigned char)((x) % 256))
-#define HIGH(x)     ((unsigned char)((x / (1<<8)) % 256))
-#define UPPER(x)    ((unsigned char)((x / (1<<16)) % 256))
-#define UP32(x)     ((unsigned char)((x / (1<<24)) % 256))
+#define LOW(x) ((unsigned char) ((x) % 256))
+#define HIGH(x) ((unsigned char) ((x / (1 << 8)) % 256))
+#define UPPER(x) ((unsigned char) ((x / (1 << 16)) % 256))
+#define UP32(x) ((unsigned char) ((x / (1 << 24)) % 256))
 
-#define IMAGE_ROUNDING  1024
-#define FIRMWARE_AREA   0x3E0000
-#define FIRMWARE_SIZE   0x01D000
+#define IMAGE_ROUNDING 1024
+#define FIRMWARE_AREA 0x3E0000
+#define FIRMWARE_SIZE 0x01D000
 
-extern QProgressBar* progress;
+extern QProgressBar *progress;
 
 //////////////////////////////////////////////////////////////////////////////
 
 OSTCFrogOperations::OSTCFrogOperations()
-  : _firmware(0),
-    _serialNumber(0),
-    _isOpen(false),
-    _commandMode(false)
-{
-}
+    : _firmware(0)
+    , _serialNumber(0)
+    , _isOpen(false)
+    , _commandMode(false)
+{}
 
 OSTCFrogOperations::~OSTCFrogOperations()
 {
-    if( _isOpen )
+    if (_isOpen)
         disconnect(true);
 }
 
@@ -82,6 +81,7 @@
 //////////////////////////////////////////////////////////////////////////////
 
 //QRegExp OSTCFrogOperations::portTemplate() const
+#if 0
 QRegularExpression OSTCFrogOperations::portTemplate() const
 {
 #if defined(Q_OS_MAC)
@@ -92,14 +92,25 @@
     // a list of connected stuff...
     return QRegExp("rfcomm.*", Qt::CaseInsensitive);
 #elif defined(Q_OS_WIN)
-//    return QRegExp("COM.*", Qt::CaseSensitive);
-    return QRegularExpression(
-        "COM([0-9]+)",
-        QRegularExpression::CaseInsensitiveOption
-        );
+    //    return QRegExp("COM.*", Qt::CaseSensitive);
+    return QRegularExpression("COM([0-9]+)", QRegularExpression::CaseInsensitiveOption);
 #endif
 }
-
+#endif
+QRegularExpression OSTCFrogOperations::portTemplate() const
+{
+#if defined(Q_OS_MAC)
+    // Mac-spezifischer regulärer Ausdruck
+    return QRegularExpression("tty[.]frog.*", QRegularExpression::CaseInsensitiveOption);
+#elif defined(Q_OS_LINUX)
+    // Linux-spezifischer regulärer Ausdruck für rfcomm
+    // Funktioniert für Debian, Ubuntu, und SUSE (wie von Google beschrieben)
+    return QRegularExpression("rfcomm.*", QRegularExpression::CaseInsensitiveOption);
+#elif defined(Q_OS_WIN)
+    // Windows-spezifischer regulärer Ausdruck für COM-Ports
+    return QRegularExpression("COM([0-9]+)", QRegularExpression::CaseInsensitiveOption);
+#endif
+}
 QStringList OSTCFrogOperations::listPorts() const
 {
     return listBluetoothPorts();
@@ -129,34 +140,34 @@
 HardwareOperations::CompanionFeatures OSTCFrogOperations::supported() const
 {
     // No ICON, no PARAMETER, no FIRMWARE, no DUMPSCREEN yet...
-    return CompanionFeatures(NAME|DATE);
+    return CompanionFeatures(NAME | DATE);
 }
 
 bool OSTCFrogOperations::connect()
 {
     try {
         //---- Open the serial port-------------------------------------------
-        LOG_TRACE( QString("Open port %1...").arg(Settings::port) );
+        LOG_TRACE(QString("Open port %1...").arg(Settings::port));
         _isOpen = false;
 
         //---- Execute the start protocol ------------------------------------
         static char animation[] = "/-\\|";
 
         int reply = 0;
-        for(int retry=0; retry < 30; ++retry) {
-            _serial.open( Settings::port, "Frog");
+        for (int retry = 0; retry < 30; ++retry) {
+            _serial.open(Settings::port, "Frog");
             _serial.sleep(100);
             _serial.purge();
             _serial.writeByte(0xBB);
             try {
                 reply = _serial.readByte();
-                if( reply == 0x4D )
+                if (reply == 0x4D)
                     break;
+            } catch (...) {
             }
-            catch(...) {}
-            LOG_TRACE( QString("Starting... %1").arg(animation[retry % sizeof animation]));
+            LOG_TRACE(QString("Starting... %1").arg(animation[retry % sizeof animation]));
         }
-        if( reply != 0x4D )
+        if (reply != 0x4D)
             LOG_THROW("Not started");
 
         //---- Enquire about Frog id -----------------------------------------
@@ -165,8 +176,7 @@
         //---- Everything is ok ----------------------------------------------
         _isOpen = true;
         return true;
-    }
-    catch(const Exception& e) {
+    } catch (const Exception &e) {
         _serial.close();
         LOG_THROW("Cannot connect " << Settings::port << ": " << e.what());
     }
@@ -181,7 +191,8 @@
 
 bool OSTCFrogOperations::disconnect(bool /*closing*/)
 {
-    if( !_isOpen ) return false;
+    if (!_isOpen)
+        return false;
 
     _serial.purge();
     _serial.writeByte(0xFF);
@@ -190,7 +201,7 @@
     _serial.purge();
     _serial.close();
 
-    _description.clear();       // cleanup for interface updateStatus()
+    _description.clear(); // cleanup for interface updateStatus()
     _isOpen = false;
 
     return true;
@@ -204,40 +215,40 @@
 
 void OSTCFrogOperations::beginCommands()
 {
-    Q_ASSERT( !_commandMode );
+    Q_ASSERT(!_commandMode);
     static char animation[] = "/-\\|";
-    for(int i=0;; ++i)
-    {
-        if( i == 100 ) // 20.0 sec loop ?
+    for (int i = 0;; ++i) {
+        if (i == 100) // 20.0 sec loop ?
             LOG_THROW("Bad reply to open command");
 
         _serial.sleep(100);
         _serial.purge();
-        _serial.writeByte(0xAA);        // Start byte
+        _serial.writeByte(0xAA); // Start byte
 
         int reply = 0;
         try {
             reply = _serial.readByte();
-        } catch(...) {}
-        if(  reply == 0x4B )
+        } catch (...) {
+        }
+        if (reply == 0x4B)
             goto Started;
 
-        LOG_TRACE(QString("Connecting %1")
-            .arg(animation[i%4]));
+        LOG_TRACE(QString("Connecting %1").arg(animation[i % 4]));
         _serial.sleep(200);
         continue;
 
-Started:
+    Started:
         unsigned char buffer[] = "\xAA\xAB\xAC";
         _serial.writeBlock(buffer, 3);
 
         try {
             unsigned char reply = _serial.readByte();
-            if( reply == 0x4C ) {
+            if (reply == 0x4C) {
                 _commandMode = true;
                 return;
             }
-        } catch(...) {}
+        } catch (...) {
+        }
 
         _serial.sleep(200);
     }
@@ -247,15 +258,15 @@
 
 void OSTCFrogOperations::endCommands()
 {
-    Q_ASSERT( _commandMode );
+    Q_ASSERT(_commandMode);
 
     _serial.sleep(100);
     _serial.purge();
-    _serial.writeByte(0xFF);                // Exit service mode
+    _serial.writeByte(0xFF); // Exit service mode
     _serial.sleep(10);
 
     unsigned char buffer = _serial.readByte();
-    if( buffer != 0xFF )
+    if (buffer != 0xFF)
         LOG_THROW("End failed");
 
     _commandMode = false;
@@ -266,42 +277,40 @@
 
 void OSTCFrogOperations::eraseRange(unsigned int addr, unsigned int size)
 {
-    Q_ASSERT( _commandMode );
+    Q_ASSERT(_commandMode);
 
     // Convert size to number of pages, rounded up.
     size = ((size + 4095) / 4096);
-    if( size < 256 || addr != 0x300000 )
-    {
+    if (size < 256 || addr != 0x300000) {
         unsigned char buffer[4];
         // Erase just the needed pages.
         buffer[0] = UPPER(addr);
         buffer[1] = HIGH(addr);
         buffer[2] = LOW(addr);
         buffer[3] = LOW(size);
-        _serial.writeByte(0x42);            // Command
+        _serial.writeByte(0x42); // Command
         _serial.sleep(10);
 
         _serial.writeBlock(buffer, 4);
         // Wait (120/4)ms by block of 4K, plus 3% VAT to be sure.
         _serial.sleep(40 + size * 31);
-    }
-    else
-    {
+    } else {
         // Erase the whole 512KB of icon memory...
         _serial.writeByte(0x41);
         _serial.sleep(3000);
     }
 
     try {
-        (void)_serial.readByte();
-    } catch(...) {}
+        (void) _serial.readByte();
+    } catch (...) {
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void OSTCFrogOperations::startWrite(unsigned int addr)
 {
-    Q_ASSERT( _commandMode );
+    Q_ASSERT(_commandMode);
 
     unsigned char buffer[3];
     buffer[0] = UPPER(addr);
@@ -319,23 +328,21 @@
 
 void OSTCFrogOperations::stopWrite()
 {
-    Q_ASSERT( _commandMode );
+    Q_ASSERT(_commandMode);
 
     _serial.flush();
     _serial.sleep(200); // Should be > 100ms.
 
     unsigned char reply = _serial.readByte();
-    if( reply != 0x4C )
+    if (reply != 0x4C)
         LOG_THROW("stopWrite");
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-void OSTCFrogOperations::readBytes(unsigned int addr,
-                                   unsigned char* ptr,
-                                   unsigned int size)
+void OSTCFrogOperations::readBytes(unsigned int addr, unsigned char *ptr, unsigned int size)
 {
-    Q_ASSERT( _commandMode );
+    Q_ASSERT(_commandMode);
 
     unsigned char buffer[6];
     buffer[0] = UPPER(addr);
@@ -352,11 +359,11 @@
     _serial.sleep(10);
 
     unsigned int len = _serial.readBlock(ptr, size);
-    if( len < size )
+    if (len < size)
         LOG_THROW("readBytes too short");
 
     unsigned char reply = _serial.readByte();
-    if( reply != 0x4C )
+    if (reply != 0x4C)
         LOG_THROW("readBytes");
 }
 
@@ -370,52 +377,52 @@
 {
     //---- get model
     HardwareDescriptor hw = hardwareDescriptor();
-    if( hw != HW_UNKNOWN_OSTC && hw != HW_Frog )
+    if (hw != HW_UNKNOWN_OSTC && hw != HW_Frog)
         LOG_THROW("Not a Frog.");
 
     //---- get identity
-    _serial.sleep(100);         // Make sure last command is finished.
+    _serial.sleep(100); // Make sure last command is finished.
     _serial.purge();
     _serial.writeByte('i'); // 0x63
 
-    unsigned char buffer[1+2+2+13+1] = {0};
+    unsigned char buffer[1 + 2 + 2 + 13 + 1] = {0};
     unsigned len = _serial.readBlock(buffer, sizeof buffer);
 
-    if( len != sizeof buffer || buffer[0] != 'i' || buffer[18] != 0x4D )
+    if (len != sizeof buffer || buffer[0] != 'i' || buffer[18] != 0x4D)
         LOG_THROW("get identity data");
 
-    _serialNumber = buffer[1] + buffer[2]*256;
-    _firmware     = buffer[3]*256 + buffer[4];
+    _serialNumber = buffer[1] + buffer[2] * 256;
+    _firmware = buffer[3] * 256 + buffer[4];
 
-    _description = QString("%1 #%2, v%3.%4, %5")
-            .arg(model())
-            .arg(_serialNumber, 4, 10, QChar('0'))
-            .arg(_firmware / 256).arg(_firmware % 256)
-            .arg( QString::fromLatin1((char*)buffer+5, 13)
-                    .replace(QChar('\0'), "")
-                    .trimmed() );
+    _description
+        = QString("%1 #%2, v%3.%4, %5")
+              .arg(model())
+              .arg(_serialNumber, 4, 10, QChar('0'))
+              .arg(_firmware / 256)
+              .arg(_firmware % 256)
+              .arg(QString::fromLatin1((char *) buffer + 5, 13).replace(QChar('\0'), "").trimmed());
 
     LOG_TRACE("Found " << _description);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-void OSTCFrogOperations::writeText(const QString& _msg)
+void OSTCFrogOperations::writeText(const QString &_msg)
 {
     // Pad to 15 chars:
     QByteArray ascii = (_msg + QString(15, QChar(' '))).left(15).toLatin1();
 
-    _serial.sleep(100);         // Make sure last command is finished.
+    _serial.sleep(100); // Make sure last command is finished.
     _serial.purge();
-    _serial.writeByte('n');     // 0x6E
+    _serial.writeByte('n'); // 0x6E
 
     unsigned char reply = _serial.readByte();
-    if( reply != 'n' )
+    if (reply != 'n')
         LOG_THROW("message start");
 
-    _serial.writeBlock((unsigned char *)ascii.constData(), 15);
+    _serial.writeBlock((unsigned char *) ascii.constData(), 15);
     reply = _serial.readByte();
-    if( reply != 0x4D )
+    if (reply != 0x4D)
         LOG_THROW("message end");
 }
 
@@ -431,17 +438,17 @@
     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");
 
-    _serial. writeBlock( buffer, sizeof buffer);
+    _serial.writeBlock(buffer, sizeof buffer);
     reply = _serial.readByte();
-    if( reply != 0x4D )
+    if (reply != 0x4D)
         LOG_THROW("sync time end");
 
     writeText("Set " + date.toString("MM/dd hh:mm"));
@@ -458,19 +465,19 @@
 
 void OSTCFrogOperations::setName(const QString &newName)
 {
-    QByteArray padded = (newName+QString(13, QChar(' '))).left(13).toLatin1();
+    QByteArray padded = (newName + QString(13, QChar(' '))).left(13).toLatin1();
 
-    _serial.sleep(100);         // Make sure last command is finished.
+    _serial.sleep(100); // Make sure last command is finished.
     _serial.purge();
-    _serial.writeByte('c');     // 0x63
+    _serial.writeByte('c'); // 0x63
 
     unsigned char reply = _serial.readByte();
-    if( reply != 'c' )
+    if (reply != 'c')
         LOG_THROW("set custom text");
 
-    _serial.writeBlock((unsigned char*)padded.constData(), 13);
+    _serial.writeBlock((unsigned char *) padded.constData(), 13);
     reply = _serial.readByte();
-    if( reply != 0x4D )
+    if (reply != 0x4D)
         LOG_THROW("custom text end");
 
     // Re-read new name:
@@ -480,7 +487,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
-void OSTCFrogOperations::setIcons(const QString &/*fileName*/)
+void OSTCFrogOperations::setIcons(const QString & /*fileName*/)
 {
     //    beginCommands();
     //    eraseRange(0x000000, 0x00000);
@@ -488,7 +495,7 @@
     //    stopWrite();
     //    endCommands();
 
-    LOG_THROW( "Set icons: Not yet implemented." );
+    LOG_THROW("Set icons: Not yet implemented.");
 }
 
 int OSTCFrogOperations::firmware() const
@@ -508,12 +515,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static unsigned char frogSecretKey[16] = {
-    111, 85, 190, 69,
-    108,254, 242, 19,
-    231, 49, 248,255,
-    233, 48, 176,241
-};
+static unsigned char frogSecretKey[16]
+    = {111, 85, 190, 69, 108, 254, 242, 19, 231, 49, 248, 255, 233, 48, 176, 241};
 
 void OSTCFrogOperations::loadFirmware(HexFile &hex, const QString &fileName) const
 {
@@ -545,18 +548,22 @@
 
         // Compute magic checksum's checksum.
         buffer[4] = 0x55;
-        buffer[4] ^= buffer[0]; buffer[4] =(buffer[4]<<1 | buffer[4]>>7);
-        buffer[4] ^= buffer[1]; buffer[4] =(buffer[4]<<1 | buffer[4]>>7);
-        buffer[4] ^= buffer[2]; buffer[4] =(buffer[4]<<1 | buffer[4]>>7);
-        buffer[4] ^= buffer[3]; buffer[4] =(buffer[4]<<1 | buffer[4]>>7);
+        buffer[4] ^= buffer[0];
+        buffer[4] = (buffer[4] << 1 | buffer[4] >> 7);
+        buffer[4] ^= buffer[1];
+        buffer[4] = (buffer[4] << 1 | buffer[4] >> 7);
+        buffer[4] ^= buffer[2];
+        buffer[4] = (buffer[4] << 1 | buffer[4] >> 7);
+        buffer[4] ^= buffer[3];
+        buffer[4] = (buffer[4] << 1 | buffer[4] >> 7);
 
-        _serial.sleep(100);         // Make sure last command is finished.
+        _serial.sleep(100); // Make sure last command is finished.
         _serial.purge();
         _serial.writeByte('P'); // 0x50
 
         unsigned char reply = _serial.readByte();
-        if( reply != 'P' )
-            LOG_THROW( "Programming start" );
+        if (reply != 'P')
+            LOG_THROW("Programming start");
 
         _serial.writeBlock(buffer, sizeof buffer);
         _serial.sleep(4000);
@@ -565,10 +572,8 @@
         //       with ot without reprogramming...
         _serial.close();
         _isOpen = false;
-    }
-    catch(const Exception& e) {
-        LOG_TRACE(QString("Cannot upgrade: <font color='red'>%1</font>")
-            .arg(e.what()));
+    } catch (const Exception &e) {
+        LOG_TRACE(QString("Cannot upgrade: <font color='red'>%1</font>").arg(e.what()));
 
         // Unknown state: so make a hard cleanup:
         _commandMode = false;