fix north americal RDS callsign decoding

decoder_modules/radio/src/rds.cpp

@@ -22,6 +22,98 @@ namespace rds {
         { BLOCK_TYPE_D,  0b0110110100 }
     };
 
+    std::map<uint16_t, const char*> THREE_LETTER_CALLS = {
+        { 0x99A5, "KBW" },
+        { 0x99A6, "KCY" },
+        { 0x9990, "KDB" },
+        { 0x99A7, "KDF" },
+        { 0x9950, "KEX" },
+        { 0x9951, "KFH" },
+        { 0x9952, "KFI" },
+        { 0x9953, "KGA" },
+        { 0x9991, "KGB" },
+        { 0x9954, "KGO" },
+        { 0x9955, "KGU" },
+        { 0x9956, "KGW" },
+        { 0x9957, "KGY" },
+        { 0x99AA, "KHQ" },
+        { 0x9958, "KID" },
+        { 0x9959, "KIT" },
+        { 0x995A, "KJR" },
+        { 0x995B, "KLO" },
+        { 0x995C, "KLZ" },
+        { 0x995D, "KMA" },
+        { 0x995E, "KMJ" },
+        { 0x995F, "KNX" },
+        { 0x9960, "KOA" },
+        { 0x99AB, "KOB" },
+        { 0x9992, "KOY" },
+        { 0x9993, "KPQ" },
+        { 0x9964, "KQV" },
+        { 0x9994, "KSD" },
+        { 0x9965, "KSL" },
+        { 0x9966, "KUJ" },
+        { 0x9995, "KUT" },
+        { 0x9967, "KVI" },
+        { 0x9968, "KWG" },
+        { 0x9996, "KXL" },
+        { 0x9997, "KXO" },
+        { 0x996B, "KYW" },
+        { 0x9999, "WBT" },
+        { 0x996D, "WBZ" },
+        { 0x996E, "WDZ" },
+        { 0x996F, "WEW" },
+        { 0x999A, "WGH" },
+        { 0x9971, "WGL" },
+        { 0x9972, "WGN" },
+        { 0x9973, "WGR" },
+        { 0x999B, "WGY" },
+        { 0x9975, "WHA" },
+        { 0x9976, "WHB" },
+        { 0x9977, "WHK" },
+        { 0x9978, "WHO" },
+        { 0x999C, "WHP" },
+        { 0x999D, "WIL" },
+        { 0x997A, "WIP" },
+        { 0x99B3, "WIS" },
+        { 0x997B, "WJR" },
+        { 0x99B4, "WJW" },
+        { 0x99B5, "WJZ" },
+        { 0x997C, "WKY" },
+        { 0x997D, "WLS" },
+        { 0x997E, "WLW" },
+        { 0x999E, "WMC" },
+        { 0x999F, "WMT" },
+        { 0x9981, "WOC" },
+        { 0x99A0, "WOI" },
+        { 0x9983, "WOL" },
+        { 0x9984, "WOR" },
+        { 0x99A1, "WOW" },
+        { 0x99B9, "WRC" },
+        { 0x99A2, "WRR" },
+        { 0x99A3, "WSB" },
+        { 0x99A4, "WSM" },
+        { 0x9988, "WWJ" },
+        { 0x9989, "WWL" }
+    };
+
+    std::map<uint16_t, const char*> NAT_LOC_LINKED_STATIONS = {
+        { 0xB01, "NPR-1" },
+        { 0xB02, "CBC - Radio One" },
+        { 0xB03, "CBC - Radio Two" },
+        { 0xB04, "Radio-Canada - Première Chaîne" },
+        { 0xB05, "Radio-Canada - Espace Musique" },
+        { 0xB06, "CBC" },
+        { 0xB07, "CBC" },
+        { 0xB08, "CBC" },
+        { 0xB09, "CBC" },
+        { 0xB0A, "NPR-2" },
+        { 0xB0B, "NPR-3" },
+        { 0xB0C, "NPR-4" },
+        { 0xB0D, "NPR-5" },
+        { 0xB0E, "NPR-6" }
+    };
+
     //                           9876543210
     const uint16_t LFSR_POLY = 0b0110111001;
     const uint16_t IN_POLY   = 0b1100011011;
@@ -146,7 +238,7 @@ namespace rds {
         countryCode = (blocks[BLOCK_TYPE_A] >> 22) & 0xF;
         programCoverage = (AreaCoverage)((blocks[BLOCK_TYPE_A] >> 18) & 0xF);
         programRefNumber = (blocks[BLOCK_TYPE_A] >> 10) & 0xFF;
-        decodeCallsign();
+        callsign = decodeCallsign(piCode);
 
         // Update timeout
         blockALastUpdate = std::chrono::high_resolution_clock::now();;
@@ -287,7 +379,7 @@ namespace rds {
         // Decode block B
         decodeBlockB();
 
-        //flog::debug("RDS Group {}{}", groupType, (groupVer == GROUP_VER_A) ? 'A':'B');
+        flog::debug("RDS Group {}{}", groupType, (groupVer == GROUP_VER_A) ? 'A':'B');
 
         // Decode depending on group type
         switch (groupType) {
@@ -305,14 +397,14 @@ namespace rds {
         }
     }
 
-    void Decoder::decodeCallsign() {
+    std::string Decoder::base26ToCall(uint16_t pi) {
         // Determin first better based on offset
-        bool w = (piCode >= 21672);
+        bool w = (pi >= 21672);
-        callsign =  w ? 'W' : 'K';
+        std::string callsign(w ? "W" : "K");
 
         // Base25 decode the rest
         std::string restStr;
-        int rest = piCode - (w ? 21672 : 4096);
+        int rest = pi - (w ? 21672 : 4096);
         while (rest) {
             restStr += 'A' + (rest % 26);
             rest /= 26;
@@ -322,6 +414,49 @@ namespace rds {
         for (int i = restStr.size() - 1; i >= 0; i--) {
             callsign += restStr[i];
         }
+
+        return callsign;
+    }
+
+    std::string Decoder::decodeCallsign(uint16_t pi) {
+        if ((pi >> 8) == 0xAF) {
+            // AFXY -> XY00
+            return base26ToCall((pi & 0xFF) << 8);
+        }
+        else if ((pi >> 12) == 0xA) {
+            // AXYZ -> X0YZ
+            return base26ToCall((((pi >> 8) & 0xF) << 12) | (pi & 0xFF));
+        }
+        else if (pi >= 0x9950 && pi <= 0x9EFF) {
+            // 3 letter callsigns
+            if (THREE_LETTER_CALLS.find(pi) != THREE_LETTER_CALLS.end()) {
+                return THREE_LETTER_CALLS[pi];
+            }
+            else {
+                return "Not Assigned";
+            }
+        }
+        else if (pi >= 0x1000 && pi <= 0x994F) {
+            // Normal encoding
+            if ((pi & 0xFF) == 0 || ((pi >> 8) & 0xF) == 0) {
+                return "Not Assigned";
+            }
+            else {
+                return base26ToCall(pi);
+            }
+        }
+        else if (pi >= 0xB000 && pi <= 0xEFFF) {
+            uint16_t _pi = ((pi >> 12) << 8) | (pi & 0xFF);
+            if (NAT_LOC_LINKED_STATIONS.find(_pi) != NAT_LOC_LINKED_STATIONS.end()) {
+                return NAT_LOC_LINKED_STATIONS[_pi];
+            }
+            else {
+                return "Not Assigned";
+            }
+        }
+        else {
+            return "Not Assigned";
+        }
     }
 
     bool Decoder::blockAValid() {

decoder_modules/radio/src/rds.h

@@ -246,7 +246,8 @@ namespace rds {
         void decodeGroup10();
         void decodeGroup();
 
-        void decodeCallsign();
+        static std::string base26ToCall(uint16_t pi);
+        static std::string decodeCallsign(uint16_t pi);
 
         bool blockAValid();
         bool blockBValid();