2023-01-08 18:03:29 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Copyright (C) 2023 Edouard Griffiths, F4EXB. //
|
|
|
|
// //
|
|
|
|
// This is the code from ft8mon: https://github.com/rtmrtmrtmrtm/ft8mon //
|
|
|
|
// written by Robert Morris, AB1HL //
|
|
|
|
// reformatted and adapted to Qt and SDRangel context //
|
|
|
|
// //
|
|
|
|
// This program is free software; you can redistribute it and/or modify //
|
|
|
|
// it under the terms of the GNU General Public License as published by //
|
|
|
|
// the Free Software Foundation as version 3 of the License, or //
|
|
|
|
// (at your option) any later version. //
|
|
|
|
// //
|
|
|
|
// This program is distributed in the hope that it will be useful, //
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
|
|
|
// GNU General Public License V3 for more details. //
|
|
|
|
// //
|
|
|
|
// You should have received a copy of the GNU General Public License //
|
|
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include <string>
|
|
|
|
#include <mutex>
|
|
|
|
#include <map>
|
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include "unpack.h"
|
|
|
|
#include "util.h"
|
|
|
|
|
|
|
|
namespace FT8 {
|
|
|
|
|
|
|
|
//
|
|
|
|
// turn bits into a 128-bit integer.
|
|
|
|
// most significant bit first.
|
|
|
|
//
|
|
|
|
__int128 un(int a77[], int start, int len)
|
|
|
|
{
|
|
|
|
__int128 x = 0;
|
|
|
|
|
|
|
|
assert(len < (int)sizeof(x) * 8 && start >= 0 && start + len <= 77);
|
|
|
|
for (int i = 0; i < len; i++)
|
|
|
|
{
|
|
|
|
x <<= 1;
|
|
|
|
x |= a77[start + i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::mutex hashes_mu;
|
|
|
|
std::map<int, std::string> hashes12;
|
|
|
|
std::map<int, std::string> hashes22;
|
|
|
|
|
|
|
|
int ihashcall(std::string call, int m)
|
|
|
|
{
|
|
|
|
while (call.size() > 0 && call[0] == ' ')
|
|
|
|
call.erase(0, 1);
|
|
|
|
while (call.size() > 0 && call[call.size() - 1] == ' ')
|
|
|
|
call.erase(call.end() - 1);
|
|
|
|
|
|
|
|
const char *chars = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ/";
|
|
|
|
|
|
|
|
while (call.size() < 11)
|
|
|
|
call += " ";
|
|
|
|
|
|
|
|
unsigned long long x = 0;
|
|
|
|
for (int i = 0; i < 11; i++)
|
|
|
|
{
|
|
|
|
int c = call[i];
|
|
|
|
const char *p = strchr(chars, c);
|
|
|
|
assert(p);
|
|
|
|
int j = p - chars;
|
|
|
|
x = 38 * x + j;
|
|
|
|
}
|
|
|
|
x = x * 47055833459LL;
|
|
|
|
x = x >> (64 - m);
|
|
|
|
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define NGBASE (180 * 180)
|
|
|
|
#define NTOKENS 2063592
|
|
|
|
#define MAX22 4194304
|
|
|
|
|
|
|
|
//
|
|
|
|
// turn 28 bits of packed call into the call
|
|
|
|
//
|
|
|
|
std::string unpackcall(int x)
|
|
|
|
{
|
|
|
|
char tmp[64];
|
|
|
|
|
|
|
|
const char *c1 = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
|
|
const char *c2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
|
|
const char *c3 = "0123456789";
|
|
|
|
const char *c4 = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
|
|
|
|
|
|
if (x == 0)
|
|
|
|
return "DE";
|
|
|
|
if (x == 1)
|
|
|
|
return "QRZ";
|
|
|
|
if (x == 2)
|
|
|
|
return "CQ";
|
|
|
|
if (x <= 1002)
|
|
|
|
{
|
|
|
|
sprintf(tmp, "CQ %d", x - 3);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
if (x <= 532443)
|
|
|
|
{
|
|
|
|
x -= 1003;
|
|
|
|
int ci1 = x / (27 * 27 * 27);
|
|
|
|
x %= 27 * 27 * 27;
|
|
|
|
int ci2 = x / (27 * 27);
|
|
|
|
x %= 27 * 27;
|
|
|
|
int ci3 = x / 27;
|
|
|
|
x %= 27;
|
|
|
|
int ci4 = x;
|
|
|
|
sprintf(tmp, "CQ %c%c%c%c", c4[ci1], c4[ci2], c4[ci3], c4[ci4]);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (x < NTOKENS)
|
|
|
|
{
|
|
|
|
return "<TOKEN>";
|
|
|
|
}
|
|
|
|
|
|
|
|
x -= NTOKENS;
|
|
|
|
|
|
|
|
if (x < MAX22)
|
|
|
|
{
|
|
|
|
// 22-bit hash...
|
|
|
|
std::string s;
|
|
|
|
hashes_mu.lock();
|
|
|
|
if (hashes22.count(x) > 0)
|
|
|
|
{
|
|
|
|
s = hashes22[x];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
s = "<...22>";
|
|
|
|
}
|
|
|
|
hashes_mu.unlock();
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
x -= MAX22;
|
|
|
|
|
|
|
|
char a[7];
|
|
|
|
|
|
|
|
a[5] = c4[x % 27];
|
|
|
|
x = x / 27;
|
|
|
|
a[4] = c4[x % 27];
|
|
|
|
x = x / 27;
|
|
|
|
a[3] = c4[x % 27];
|
|
|
|
x = x / 27;
|
|
|
|
a[2] = c3[x % 10];
|
|
|
|
x = x / 10;
|
|
|
|
a[1] = c2[x % 36];
|
|
|
|
x = x / 36;
|
|
|
|
a[0] = c1[x];
|
|
|
|
|
|
|
|
a[6] = '\0';
|
|
|
|
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
|
|
|
// unpack a 15-bit grid square &c.
|
|
|
|
// 77-bit version, from inspection of packjt77.f90.
|
|
|
|
// ir is the bit after the two 28+1-bit callee/caller.
|
|
|
|
// i3 is the message type, usually 1.
|
|
|
|
std::string unpackgrid(int ng, int ir, int i3)
|
|
|
|
{
|
|
|
|
(void) i3;
|
|
|
|
|
|
|
|
if (ng < NGBASE)
|
|
|
|
{
|
|
|
|
// maidenhead grid system:
|
|
|
|
// latitude from south pole to north pole.
|
|
|
|
// longitude eastward from anti-meridian.
|
|
|
|
// first: 20 degrees longitude.
|
|
|
|
// second: 10 degrees latitude.
|
|
|
|
// third: 2 degrees longitude.
|
|
|
|
// fourth: 1 degree latitude.
|
|
|
|
// so there are 18*18*10*10 possibilities.
|
|
|
|
int x1 = ng / (18 * 10 * 10);
|
|
|
|
ng %= 18 * 10 * 10;
|
|
|
|
int x2 = ng / (10 * 10);
|
|
|
|
ng %= 10 * 10;
|
|
|
|
int x3 = ng / 10;
|
|
|
|
ng %= 10;
|
|
|
|
int x4 = ng;
|
|
|
|
char tmp[5];
|
|
|
|
tmp[0] = 'A' + x1;
|
|
|
|
tmp[1] = 'A' + x2;
|
|
|
|
tmp[2] = '0' + x3;
|
|
|
|
tmp[3] = '0' + x4;
|
|
|
|
tmp[4] = '\0';
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
ng -= NGBASE;
|
|
|
|
|
|
|
|
if (ng == 1)
|
|
|
|
{
|
|
|
|
return " "; // ???
|
|
|
|
}
|
|
|
|
if (ng == 2)
|
|
|
|
{
|
|
|
|
return "RRR ";
|
|
|
|
}
|
|
|
|
if (ng == 3)
|
|
|
|
{
|
|
|
|
return "RR73";
|
|
|
|
}
|
|
|
|
if (ng == 4)
|
|
|
|
{
|
|
|
|
return "73 ";
|
|
|
|
}
|
|
|
|
|
|
|
|
int db = ng - 35;
|
|
|
|
char tmp[16];
|
|
|
|
if (db >= 0)
|
|
|
|
{
|
|
|
|
sprintf(tmp, "%s+%02d", ir ? "R" : "", db);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sprintf(tmp, "%s-%02d", ir ? "R" : "", 0 - db);
|
|
|
|
}
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void remember_call(std::string call)
|
|
|
|
{
|
|
|
|
hashes_mu.lock();
|
|
|
|
if (call.size() >= 3 && call[0] != '<')
|
|
|
|
{
|
|
|
|
hashes22[ihashcall(call, 22)] = call;
|
|
|
|
hashes12[ihashcall(call, 12)] = call;
|
|
|
|
}
|
|
|
|
hashes_mu.unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// i3 == 4
|
|
|
|
// a call that doesn't fit in 28 bits.
|
|
|
|
// 12 bits: hash of a previous call
|
|
|
|
// 58 bits: 11 characters
|
|
|
|
// 1 bit: swap
|
|
|
|
// 2 bits: 1 RRR, 2 RR73, 3 73
|
|
|
|
// 1 bit: 1 means CQ
|
2023-01-08 22:15:31 +00:00
|
|
|
std::string unpack_4(int a77[], std::string& call1str, std::string& call2str, std::string& locstr)
|
2023-01-08 18:03:29 +00:00
|
|
|
{
|
2023-01-08 22:15:31 +00:00
|
|
|
(void) locstr;
|
2023-01-08 18:03:29 +00:00
|
|
|
// 38 possible characters:
|
|
|
|
const char *chars = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ/";
|
|
|
|
long long n58 = un(a77, 12, 58);
|
|
|
|
char call[16];
|
2023-01-08 22:15:31 +00:00
|
|
|
|
2023-01-08 18:03:29 +00:00
|
|
|
for (int i = 0; i < 11; i++)
|
|
|
|
{
|
|
|
|
call[10 - i] = chars[n58 % 38];
|
|
|
|
n58 = n58 / 38;
|
|
|
|
}
|
2023-01-08 22:15:31 +00:00
|
|
|
|
2023-01-08 18:03:29 +00:00
|
|
|
call[11] = '\0';
|
|
|
|
|
|
|
|
remember_call(call);
|
|
|
|
|
2023-01-08 22:15:31 +00:00
|
|
|
if (un(a77, 73, 1) == 1) {
|
2023-01-08 18:03:29 +00:00
|
|
|
return std::string("CQ ") + call;
|
|
|
|
}
|
|
|
|
|
|
|
|
int x12 = un(a77, 0, 12);
|
|
|
|
// 12-bit hash
|
|
|
|
hashes_mu.lock();
|
|
|
|
std::string ocall;
|
2023-01-08 22:15:31 +00:00
|
|
|
|
|
|
|
if (hashes12.count(x12) > 0) {
|
2023-01-08 18:03:29 +00:00
|
|
|
ocall = hashes12[x12];
|
2023-01-08 22:15:31 +00:00
|
|
|
} else {
|
2023-01-08 18:03:29 +00:00
|
|
|
ocall = "<...12>";
|
|
|
|
}
|
2023-01-08 22:15:31 +00:00
|
|
|
|
2023-01-08 18:03:29 +00:00
|
|
|
hashes_mu.unlock();
|
|
|
|
|
|
|
|
int swap = un(a77, 70, 1);
|
|
|
|
std::string msg;
|
2023-01-08 22:15:31 +00:00
|
|
|
|
2023-01-08 18:03:29 +00:00
|
|
|
if (swap)
|
|
|
|
{
|
|
|
|
msg = std::string(call) + " " + ocall;
|
2023-01-08 22:15:31 +00:00
|
|
|
call1str = call;
|
|
|
|
call2str = ocall;
|
2023-01-08 18:03:29 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
msg = std::string(ocall) + " " + call;
|
2023-01-08 22:15:31 +00:00
|
|
|
call1str = ocall;
|
|
|
|
call2str = call;
|
2023-01-08 18:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int suffix = un(a77, 71, 2);
|
2023-01-08 22:15:31 +00:00
|
|
|
|
|
|
|
if (suffix == 1) {
|
2023-01-08 18:03:29 +00:00
|
|
|
msg += " RRR";
|
2023-01-08 22:15:31 +00:00
|
|
|
} else if (suffix == 2) {
|
2023-01-08 18:03:29 +00:00
|
|
|
msg += " RR73";
|
2023-01-08 22:15:31 +00:00
|
|
|
} else if (suffix == 3) {
|
2023-01-08 18:03:29 +00:00
|
|
|
msg += " 73";
|
|
|
|
}
|
|
|
|
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// i3=1
|
|
|
|
//
|
2023-01-08 22:15:31 +00:00
|
|
|
std::string unpack_1(int a77[], std::string& call1str, std::string& call2str, std::string& locstr)
|
2023-01-08 18:03:29 +00:00
|
|
|
{
|
|
|
|
// type 1:
|
|
|
|
// 28 call1
|
|
|
|
// 1 P/R
|
|
|
|
// 28 call2
|
|
|
|
// 1 P/R
|
|
|
|
// 1 ???
|
|
|
|
// 15 grid
|
|
|
|
// 3 type
|
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
int call1 = un(a77, i, 28);
|
|
|
|
i += 28;
|
|
|
|
int rover1 = a77[i];
|
|
|
|
i += 1;
|
|
|
|
int call2 = un(a77, i, 28);
|
|
|
|
i += 28;
|
|
|
|
int rover2 = a77[i];
|
|
|
|
i += 1;
|
|
|
|
int ir = a77[i];
|
|
|
|
i += 1;
|
|
|
|
int grid = un(a77, i, 15);
|
|
|
|
i += 15;
|
|
|
|
int i3 = un(a77, i, 3);
|
|
|
|
i += 3;
|
|
|
|
assert((i3 == 1 || i3 == 2) && i == 77);
|
|
|
|
|
2023-01-08 22:15:31 +00:00
|
|
|
call1str = trim(unpackcall(call1));
|
|
|
|
call2str = trim(unpackcall(call2));
|
|
|
|
locstr = unpackgrid(grid, ir, i3);
|
2023-01-08 18:03:29 +00:00
|
|
|
|
2023-01-08 22:15:31 +00:00
|
|
|
remember_call(call1str);
|
|
|
|
remember_call(call2str);
|
2023-01-08 18:03:29 +00:00
|
|
|
|
|
|
|
const char *pr = (i3 == 1 ? "/R" : "/P");
|
|
|
|
|
2023-01-08 22:15:31 +00:00
|
|
|
return call1str + (rover1 ? pr : "") + " " + call2str + (rover2 ? pr : "") + " " + locstr;
|
2023-01-08 18:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// free text
|
|
|
|
// 71 bits, 13 characters, each one of 42 choices.
|
|
|
|
// reversed.
|
|
|
|
// details from wsjt-x's packjt77.f90
|
2023-01-08 22:15:31 +00:00
|
|
|
std::string unpack_0_0(int a77[], std::string& call1str, std::string& call2str, std::string& locstr)
|
2023-01-08 18:03:29 +00:00
|
|
|
{
|
2023-01-08 22:15:31 +00:00
|
|
|
(void) call2str;
|
|
|
|
(void) locstr;
|
2023-01-08 18:03:29 +00:00
|
|
|
// the 42 possible characters.
|
|
|
|
const char *cc = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?";
|
|
|
|
__int128 x = un(a77, 0, 71);
|
|
|
|
std::string msg = "0123456789123";
|
|
|
|
for (int i = 0; i < 13; i++)
|
|
|
|
{
|
|
|
|
msg[13 - 1 - i] = cc[x % 42];
|
|
|
|
x = x / 42;
|
|
|
|
}
|
2023-01-08 22:15:31 +00:00
|
|
|
call1str = msg;
|
2023-01-08 18:03:29 +00:00
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ARRL RTTY Round-Up states/provinces
|
|
|
|
const char *ru_states[] = {
|
|
|
|
"AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA",
|
|
|
|
"HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD",
|
|
|
|
"MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ",
|
|
|
|
"NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC",
|
|
|
|
"SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY",
|
|
|
|
"NB", "NS", "QC", "ON", "MB", "SK", "AB", "BC", "NWT", "NF",
|
|
|
|
"LB", "NU", "YT", "PEI", "DC"};
|
|
|
|
|
|
|
|
// i3=3
|
|
|
|
// 3 TU; W9XYZ K1ABC R 579 MA 1 28 28 1 3 13 74 ARRL RTTY Roundup
|
|
|
|
// 1 TU
|
|
|
|
// 28 call1
|
|
|
|
// 28 call2
|
|
|
|
// 1 R
|
|
|
|
// 3 RST 529 to 599
|
|
|
|
// 13 state/province/serialnumber
|
2023-01-08 22:15:31 +00:00
|
|
|
std::string unpack_3(int a77[], std::string& call1str, std::string& call2str, std::string& locstr)
|
2023-01-08 18:03:29 +00:00
|
|
|
{
|
2023-01-08 22:15:31 +00:00
|
|
|
(void) locstr;
|
2023-01-08 18:03:29 +00:00
|
|
|
int i = 0;
|
|
|
|
int tu = a77[i];
|
|
|
|
i += 1;
|
|
|
|
int call1 = un(a77, i, 28);
|
|
|
|
i += 28;
|
|
|
|
int call2 = un(a77, i, 28);
|
|
|
|
i += 28;
|
|
|
|
int r = a77[i];
|
|
|
|
i += 1;
|
|
|
|
int rst = un(a77, i, 3);
|
|
|
|
i += 3;
|
|
|
|
int serial = un(a77, i, 13);
|
|
|
|
i += 13;
|
|
|
|
|
2023-01-08 22:15:31 +00:00
|
|
|
call1str = trim(unpackcall(call1));
|
|
|
|
call2str = trim(unpackcall(call2));
|
2023-01-08 18:03:29 +00:00
|
|
|
|
|
|
|
rst = 529 + 10 * rst;
|
|
|
|
|
|
|
|
int statei = serial - 8001;
|
|
|
|
std::string serialstr;
|
|
|
|
int nstates = sizeof(ru_states) / sizeof(ru_states[0]);
|
|
|
|
if (serial > 8000 && statei < nstates)
|
|
|
|
{
|
|
|
|
serialstr = ru_states[statei];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char tmp[32];
|
|
|
|
sprintf(tmp, "%04d", serial);
|
|
|
|
serialstr = tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string msg;
|
|
|
|
|
|
|
|
if (tu)
|
|
|
|
{
|
|
|
|
msg += "TU; ";
|
|
|
|
}
|
2023-01-08 22:15:31 +00:00
|
|
|
msg += call1str + " " + call2str + " ";
|
2023-01-08 18:03:29 +00:00
|
|
|
if (r)
|
|
|
|
{
|
|
|
|
msg += "R ";
|
|
|
|
}
|
|
|
|
{
|
|
|
|
char tmp[16];
|
|
|
|
sprintf(tmp, "%d ", rst);
|
|
|
|
msg += tmp;
|
|
|
|
}
|
|
|
|
msg += serialstr;
|
|
|
|
|
2023-01-08 22:15:31 +00:00
|
|
|
remember_call(call1str);
|
|
|
|
remember_call(call2str);
|
2023-01-08 18:03:29 +00:00
|
|
|
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ARRL Field Day sections
|
|
|
|
const char *sections[] = {
|
|
|
|
"AB ", "AK ", "AL ", "AR ", "AZ ", "BC ", "CO ", "CT ", "DE ", "EB ",
|
|
|
|
"EMA", "ENY", "EPA", "EWA", "GA ", "GTA", "IA ", "ID ", "IL ", "IN ",
|
|
|
|
"KS ", "KY ", "LA ", "LAX", "MAR", "MB ", "MDC", "ME ", "MI ", "MN ",
|
|
|
|
"MO ", "MS ", "MT ", "NC ", "ND ", "NE ", "NFL", "NH ", "NL ", "NLI",
|
|
|
|
"NM ", "NNJ", "NNY", "NT ", "NTX", "NV ", "OH ", "OK ", "ONE", "ONN",
|
|
|
|
"ONS", "OR ", "ORG", "PAC", "PR ", "QC ", "RI ", "SB ", "SC ", "SCV",
|
|
|
|
"SD ", "SDG", "SF ", "SFL", "SJV", "SK ", "SNJ", "STX", "SV ", "TN ",
|
|
|
|
"UT ", "VA ", "VI ", "VT ", "WCF", "WI ", "WMA", "WNY", "WPA", "WTX",
|
|
|
|
"WV ", "WWA", "WY ", "DX "};
|
|
|
|
|
|
|
|
// i3 = 0, n3 = 3 or 4: ARRL Field Day
|
|
|
|
// 0.3 WA9XYZ KA1ABC R 16A EMA 28 28 1 4 3 7 71 ARRL Field Day
|
|
|
|
// 0.4 WA9XYZ KA1ABC R 32A EMA 28 28 1 4 3 7 71 ARRL Field Day
|
2023-01-08 22:15:31 +00:00
|
|
|
std::string unpack_0_3(int a77[], int n3, std::string& call1str, std::string& call2str, std::string& locstr)
|
2023-01-08 18:03:29 +00:00
|
|
|
{
|
2023-01-08 22:15:31 +00:00
|
|
|
(void) locstr;
|
2023-01-08 18:03:29 +00:00
|
|
|
int i = 0;
|
|
|
|
int call1 = un(a77, i, 28);
|
|
|
|
i += 28;
|
|
|
|
int call2 = un(a77, i, 28);
|
|
|
|
i += 28;
|
|
|
|
int R = un(a77, i, 1);
|
|
|
|
i += 1;
|
|
|
|
int n_transmitters = un(a77, i, 4);
|
2023-01-08 22:15:31 +00:00
|
|
|
|
|
|
|
if (n3 == 4) {
|
2023-01-08 18:03:29 +00:00
|
|
|
n_transmitters += 16;
|
2023-01-08 22:15:31 +00:00
|
|
|
}
|
|
|
|
|
2023-01-08 18:03:29 +00:00
|
|
|
i += 4;
|
|
|
|
int clss = un(a77, i, 3); // class
|
|
|
|
i += 3;
|
|
|
|
int section = un(a77, i, 7); // ARRL section
|
|
|
|
i += 7;
|
|
|
|
|
|
|
|
std::string msg;
|
2023-01-08 22:15:31 +00:00
|
|
|
call1str = trim(unpackcall(call1));
|
|
|
|
msg += call1str;
|
2023-01-08 18:03:29 +00:00
|
|
|
msg += " ";
|
2023-01-08 22:15:31 +00:00
|
|
|
call2str = trim(unpackcall(call2));
|
|
|
|
msg += call2str;
|
2023-01-08 18:03:29 +00:00
|
|
|
msg += " ";
|
2023-01-08 22:15:31 +00:00
|
|
|
|
|
|
|
if (R) {
|
2023-01-08 18:03:29 +00:00
|
|
|
msg += "R ";
|
2023-01-08 22:15:31 +00:00
|
|
|
}
|
|
|
|
|
2023-01-08 18:03:29 +00:00
|
|
|
{
|
|
|
|
char tmp[16];
|
|
|
|
sprintf(tmp, "%d%c ", n_transmitters + 1, clss + 'A');
|
|
|
|
msg += tmp;
|
|
|
|
}
|
2023-01-08 22:15:31 +00:00
|
|
|
|
|
|
|
if (section - 1 >= 0 && section - 1 < (int)(sizeof(sections) / sizeof(sections[0]))) {
|
2023-01-08 18:03:29 +00:00
|
|
|
msg += sections[section - 1];
|
|
|
|
}
|
|
|
|
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// unpack an FT8 message.
|
|
|
|
// a77 is 91 bits -- 77 plus the 14-bit CRC.
|
|
|
|
// CRC and LDPC have already been checked.
|
|
|
|
// details from wsjt-x's packjt77.f90 and 77bit.txt.
|
|
|
|
//
|
2023-01-08 22:15:31 +00:00
|
|
|
std::string unpack(int a77[], std::string& call1, std::string& call2, std::string& loc)
|
2023-01-08 18:03:29 +00:00
|
|
|
{
|
|
|
|
int i3 = un(a77, 74, 3);
|
|
|
|
int n3 = un(a77, 71, 3);
|
|
|
|
|
|
|
|
if (i3 == 0 && n3 == 0)
|
|
|
|
{
|
|
|
|
// free text
|
2023-01-08 22:15:31 +00:00
|
|
|
return unpack_0_0(a77, call1, call2, loc);
|
2023-01-08 18:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (i3 == 0 && (n3 == 3 || n3 == 4))
|
|
|
|
{
|
|
|
|
// ARRL Field Day
|
2023-01-08 22:15:31 +00:00
|
|
|
return unpack_0_3(a77, n3, call1, call2, loc);
|
2023-01-08 18:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (i3 == 1 || i3 == 2)
|
|
|
|
{
|
|
|
|
// ordinary message
|
2023-01-08 22:15:31 +00:00
|
|
|
return unpack_1(a77, call1, call2, loc);
|
2023-01-08 18:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (i3 == 3)
|
|
|
|
{
|
|
|
|
// RTTY Round-Up
|
2023-01-08 22:15:31 +00:00
|
|
|
return unpack_3(a77, call1, call2, loc);
|
2023-01-08 18:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (i3 == 4)
|
|
|
|
{
|
|
|
|
// call that doesn't fit in 28 bits
|
2023-01-08 22:15:31 +00:00
|
|
|
return unpack_4(a77, call1, call2, loc);
|
2023-01-08 18:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
char tmp[64];
|
|
|
|
sprintf(tmp, "UNK i3=%d n3=%d", i3, n3);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace FT8
|