You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1217 lines
40 KiB
1217 lines
40 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2021-2022 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Copyright (C) 2022 Peter Beckman <beckman@angryox.com> // |
|
// Copyright (C) 2023 Daniele Forsi <iu5hkx@gmail.com> // |
|
// // |
|
// 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 <QRegularExpression> |
|
#include <QStringList> |
|
#include <QDateTime> |
|
|
|
#include "aprs.h" |
|
#include "util/units.h" |
|
|
|
inline bool inRange(unsigned low, unsigned high, unsigned x) |
|
{ |
|
return (low <= x && x <= high); |
|
} |
|
|
|
// Required for Mic-E Decoding |
|
inline int charToIntAscii(QString&s, int idx) |
|
{ |
|
char c = s.toLatin1().at(idx); |
|
return int(c); |
|
} |
|
|
|
|
|
// See: http://www.aprs.org/doc/APRS101.PDF |
|
|
|
// Currently we only decode what we want to display on the map |
|
bool APRSPacket::decode(AX25Packet packet) |
|
{ |
|
// Check type, PID and length of packet |
|
if ((packet.m_type == "UI") && (packet.m_pid == "f0") && (packet.m_data.length() >= 1)) |
|
{ |
|
// Check destination address |
|
QRegularExpression re("^(AIR.*|ALL.*|AP.*|BEACON|CQ.*|GPS.*|DF.*|DGPS.*|DRILL.*|DX.*|ID.*|JAVA.*|MAIL.*|MICE.*|QST.*|QTH.*|RTCM.*|SKY.*|SPACE.*|SPC.*|SYM.*|TEL.*|TEST.*|TLM.*|WX.*|ZIP.*)"); |
|
QRegularExpression re_mice("^[A-LP-Z0-9]{3}[L-Z0-9]{3}.?$"); // Mic-E Encoded Destination, 6-7 bytes |
|
if (re.match(packet.m_to).hasMatch() || re_mice.match(packet.m_to).hasMatch()) |
|
{ |
|
m_from = packet.m_from; |
|
m_to = packet.m_to; |
|
m_via = packet.m_via; |
|
m_data = packet.m_data; |
|
|
|
// UTF-8 is supported: http://aprs.org/aprs12/utf-8.txt |
|
QString data = QString::fromUtf8(packet.m_data); |
|
|
|
if (packet.m_to.startsWith("GPS") || packet.m_to.startsWith("SPC") || packet.m_to.startsWith("SYM")) |
|
{ |
|
// FIXME: Trailing letters xyz specify a symbol |
|
} |
|
|
|
// Source address SSID can be used to specify a symbol |
|
|
|
// First byte of information field is data type ID |
|
char dataType = data[0].toLatin1(); |
|
int idx = 1; |
|
switch (dataType) |
|
{ |
|
case '!': // Position without timestamp or Ultimeter 2000 WX Station |
|
parsePosition(data, idx); |
|
if (m_symbolCode == '_') |
|
parseWeather(data, idx, false); |
|
else if (m_symbolCode == '@') |
|
parseStorm(data, idx); |
|
else |
|
{ |
|
parseDataExension(data, idx); |
|
parseComment(data, idx); |
|
} |
|
break; |
|
case '#': // Peet Bros U-II Weather Station |
|
case '$': // Raw GPS data or Ultimeter 2000 |
|
case '%': // Agrelo DFJr / MicroFinder |
|
break; |
|
case ')': // Item |
|
parseItem(data, idx); |
|
parsePosition(data, idx); |
|
parseDataExension(data, idx); |
|
parseComment(data, idx); |
|
break; |
|
case '*': // Peet Bros U-II Weather Station |
|
break; |
|
case '/': // Position with timestamp (no APRS messaging) |
|
parseTime(data, idx); |
|
parsePosition(data, idx); |
|
if (m_symbolCode == '_') |
|
parseWeather(data, idx, false); |
|
else if (m_symbolCode == '@') |
|
parseStorm(data, idx); |
|
else |
|
{ |
|
parseDataExension(data, idx); |
|
parseComment(data, idx); |
|
} |
|
break; |
|
case ':': // Message |
|
parseMessage(data, idx); |
|
break; |
|
case ';': // Object |
|
parseObject(data, idx); |
|
parseTime(data, idx); |
|
parsePosition(data, idx); |
|
if (m_symbolCode == '_') |
|
parseWeather(data, idx, false); |
|
else if (m_symbolCode == '@') |
|
parseStorm(data, idx); |
|
else |
|
{ |
|
parseDataExension(data, idx); |
|
parseComment(data, idx); |
|
} |
|
break; |
|
case '<': // Station Capabilities |
|
break; |
|
case '=': // Position without timestamp (with APRS messaging) |
|
parsePosition(data, idx); |
|
if (m_symbolCode == '_') |
|
parseWeather(data, idx, false); |
|
else if (m_symbolCode == '@') |
|
parseStorm(data, idx); |
|
else |
|
{ |
|
parseDataExension(data, idx); |
|
parseComment(data, idx); |
|
} |
|
break; |
|
case '>': // Status |
|
parseStatus(data, idx); |
|
break; |
|
case '?': // Query |
|
break; |
|
case '@': // Position with timestamp (with APRS messaging) |
|
parseTime(data, idx); |
|
parsePosition(data, idx); |
|
if (m_symbolCode == '_') |
|
parseWeather(data, idx, false); |
|
else if (m_symbolCode == '@') |
|
parseStorm(data, idx); |
|
else |
|
{ |
|
parseDataExension(data, idx); |
|
parseComment(data, idx); |
|
} |
|
break; |
|
case 'T': // Telemetry data |
|
parseTelemetry(data, idx); |
|
break; |
|
case '_': // Weather report (without position) |
|
parseTimeMDHM(data, idx); |
|
parseWeather(data, idx, true); |
|
break; |
|
case '`': // Mic-E Information Field Data (current) |
|
case '\'': // Mic-E Information Field Data (old) |
|
parseMicE(data, idx, m_to); |
|
break; |
|
case '{': // User-defined APRS packet format |
|
break; |
|
default: |
|
return false; |
|
} |
|
|
|
if (m_hasSymbol) |
|
{ |
|
int num = m_symbolCode - '!'; |
|
m_symbolImage = QString("aprs/aprs/aprs-symbols-24-%1-%2.png").arg(m_symbolTable == '/' ? 0 : 1).arg(num, 2, 10, QChar('0')); |
|
} |
|
|
|
return true; |
|
} else { |
|
qDebug() << "APRSPacket::decode: AX.25 Destination did not match known regexp " << m_to; |
|
} |
|
} else { |
|
qDebug() << "APRSPacket::decode: Not APRS: type=" << packet.m_type << " pid=" << packet.m_pid << " length=" << packet.m_data.length(); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
int APRSPacket::charToInt(QString&s, int idx) |
|
{ |
|
char c = s[idx].toLatin1(); |
|
return c == ' ' ? 0 : c - '0'; |
|
} |
|
|
|
bool APRSPacket::parseTime(QString& info, int& idx) |
|
{ |
|
if (info.length() < idx+7) |
|
return false; |
|
|
|
QDateTime currentDateTime; |
|
|
|
if (info[idx+6]=='h') |
|
{ |
|
// HMS format |
|
if (info[idx].isDigit() |
|
&& info[idx+1].isDigit() |
|
&& info[idx+2].isDigit() |
|
&& info[idx+3].isDigit() |
|
&& info[idx+4].isDigit() |
|
&& info[idx+5].isDigit()) |
|
{ |
|
int hour = charToInt(info, idx) * 10 + charToInt(info, idx+1); |
|
int min = charToInt(info, idx+2) * 10 + charToInt(info, idx+3); |
|
int sec = charToInt(info, idx+4) * 10 + charToInt(info, idx+5); |
|
|
|
if (hour > 23) |
|
return false; |
|
if (min > 59) |
|
return false; |
|
if (sec > 60) // Can have 60 seconds when there's a leap second |
|
return false; |
|
|
|
m_utc = true; |
|
m_timestamp = QDateTime(QDate::currentDate(), QTime(hour, min, sec)); |
|
m_hasTimestamp = true; |
|
|
|
idx += 7; |
|
return true; |
|
} |
|
else |
|
return false; |
|
} |
|
else if ((info[idx+6]=='z') || (info[idx+6]=='/')) |
|
{ |
|
// DHM format |
|
if (info[idx].isDigit() |
|
&& info[idx+1].isDigit() |
|
&& info[idx+2].isDigit() |
|
&& info[idx+3].isDigit() |
|
&& info[idx+4].isDigit() |
|
&& info[idx+5].isDigit()) |
|
{ |
|
int day = charToInt(info, idx) * 10 + charToInt(info, idx+1); |
|
int hour = charToInt(info, idx+2) * 10 + charToInt(info, idx+3); |
|
int min = charToInt(info, idx+4) * 10 + charToInt(info, idx+5); |
|
|
|
if (day > 31) |
|
return false; |
|
if (hour > 23) |
|
return false; |
|
if (min > 59) |
|
return false; |
|
|
|
m_utc = info[idx+6]=='z'; |
|
currentDateTime = m_utc ? QDateTime::currentDateTimeUtc() : QDateTime::currentDateTime(); |
|
m_timestamp = QDateTime(QDate(currentDateTime.date().year(), currentDateTime.date().month(), day), QTime(hour, min, 0)); |
|
m_hasTimestamp = true; |
|
|
|
idx += 7; |
|
return true; |
|
} |
|
else |
|
return false; |
|
} |
|
else |
|
return false; |
|
} |
|
|
|
// Time format used in weather reports without position |
|
bool APRSPacket::parseTimeMDHM(QString& info, int& idx) |
|
{ |
|
if (info.length() < idx+8) |
|
return false; |
|
|
|
if (info[idx].isDigit() |
|
&& info[idx+1].isDigit() |
|
&& info[idx+2].isDigit() |
|
&& info[idx+3].isDigit() |
|
&& info[idx+4].isDigit() |
|
&& info[idx+5].isDigit() |
|
&& info[idx+6].isDigit() |
|
&& info[idx+7].isDigit()) |
|
{ |
|
int month = charToInt(info, idx) * 10 + charToInt(info, idx+1); |
|
int day = charToInt(info, idx+2) * 10 + charToInt(info, idx+3); |
|
int hour = charToInt(info, idx+4) * 10 + charToInt(info, idx+5); |
|
int min = charToInt(info, idx+6) * 10 + charToInt(info, idx+7); |
|
|
|
if (month > 12) |
|
return false; |
|
if (day > 31) |
|
return false; |
|
if (hour > 23) |
|
return false; |
|
if (min > 59) |
|
return false; |
|
|
|
m_utc = true; |
|
QDateTime currentDateTime = QDateTime::currentDateTimeUtc(); |
|
m_timestamp = QDateTime(QDate(currentDateTime.date().year(), month, day), QTime(hour, min, 0)); |
|
m_hasTimestamp = true; |
|
|
|
return true; |
|
} |
|
else |
|
return false; |
|
} |
|
|
|
// Position ambigutiy can be specified by using spaces instead of digits in lats and longs |
|
bool APRSPacket::isLatLongChar(const QChar c) |
|
{ |
|
return (c.isDigit() || c == ' '); |
|
} |
|
|
|
bool APRSPacket::parsePosition(QString& info, int& idx) |
|
{ |
|
float latitude; |
|
float longitude; |
|
char table; |
|
char code; |
|
|
|
if (info.length() < idx+8+1+9+1) |
|
return false; |
|
|
|
// Latitude |
|
if (info[idx].isDigit() |
|
&& info[idx+1].isDigit() |
|
&& isLatLongChar(info[idx+2]) |
|
&& isLatLongChar(info[idx+3]) |
|
&& (info[idx+4]=='.') |
|
&& isLatLongChar(info[idx+5]) |
|
&& isLatLongChar(info[idx+6]) |
|
&& ((info[idx+7]=='N') || (info[idx+7]=='S'))) |
|
{ |
|
int deg = charToInt(info, idx) * 10 + charToInt(info, idx+1); |
|
int min = charToInt(info, idx+2) * 10 + charToInt(info, idx+3); |
|
int hundreths = charToInt(info, idx+5) * 10 + charToInt(info, idx+6); |
|
bool north = (info[idx+7]=='N'); |
|
if (deg > 90) |
|
return false; |
|
else if ((deg == 90) && ((min != 0) || (hundreths != 0))) |
|
return false; |
|
latitude = ((float)deg) + min/60.0 + hundreths/60.0/100.0; |
|
if (!north) |
|
latitude = -latitude; |
|
idx += 8; |
|
} |
|
else |
|
return false; |
|
|
|
// Symbol table identifier |
|
table = info[idx++].toLatin1(); |
|
|
|
// Longitude |
|
if (info[idx].isDigit() |
|
&& info[idx+1].isDigit() |
|
&& info[idx+2].isDigit() |
|
&& isLatLongChar(info[idx+3]) |
|
&& isLatLongChar(info[idx+4]) |
|
&& (info[idx+5]=='.') |
|
&& isLatLongChar(info[idx+6]) |
|
&& isLatLongChar(info[idx+7]) |
|
&& ((info[idx+8]=='E') || (info[idx+8]=='W'))) |
|
{ |
|
int deg = charToInt(info, idx) * 100 + charToInt(info, idx+1) * 10 + charToInt(info, idx+2); |
|
int min = charToInt(info, idx+3) * 10 + charToInt(info, idx+4); |
|
int hundreths = charToInt(info, idx+6) * 10 + charToInt(info, idx+7); |
|
bool east = (info[idx+8]=='E'); |
|
if (deg > 180) |
|
return false; |
|
else if ((deg == 180) && ((min != 0) || (hundreths != 0))) |
|
return false; |
|
longitude = ((float)deg) + min/60.0 + hundreths/60.0/100.0; |
|
if (!east) |
|
longitude = -longitude; |
|
idx += 9; |
|
} |
|
else |
|
return false; |
|
|
|
// Symbol table code |
|
code = info[idx++].toLatin1(); |
|
|
|
// Update state as we have a valid position |
|
m_latitude = latitude; |
|
m_longitude = longitude; |
|
m_hasPosition = true; |
|
m_symbolTable = table; |
|
m_symbolCode = code; |
|
m_hasSymbol = true; |
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseDataExension(QString& info, int& idx) |
|
{ |
|
int heightMap[] = {10, 20, 40, 80, 160, 320, 640, 1280, 2560, 5120}; |
|
QStringList directivityMap = {"Omni", "NE", "E", "SE", "S", "SW", "W", "NW", "N", ""}; |
|
|
|
int remainingLength = info.length() - idx; |
|
if (remainingLength < 7) |
|
return true; |
|
QString s = info.right(remainingLength); |
|
|
|
// Course and speed |
|
QRegularExpression courseSpeed("^([0-9]{3})\\/([0-9]{3})"); |
|
QRegularExpressionMatch match; |
|
match = courseSpeed.match(s); |
|
if (match.hasMatch()) |
|
{ |
|
m_course = match.capturedTexts()[1].toInt(); |
|
m_speed = match.capturedTexts()[2].toInt(); |
|
m_hasCourseAndSpeed = true; |
|
idx += 7; |
|
return true; |
|
} |
|
|
|
// Station radio details |
|
QRegularExpression phg("^PHG([0-9])([0-9])([0-9])([0-9])"); |
|
match = phg.match(s); |
|
if (match.hasMatch()) |
|
{ |
|
// Transmitter power |
|
int powerCode = match.capturedTexts()[1].toInt(); |
|
int powerMap[] = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}; |
|
m_powerWatts = powerMap[powerCode]; |
|
|
|
// Antenna height |
|
int heightCode = match.capturedTexts()[2].toInt(); |
|
m_antennaHeightFt = heightMap[heightCode]; |
|
|
|
// Antenna gain |
|
m_antennaGainDB = match.capturedTexts()[3].toInt(); |
|
|
|
// Antenna directivity |
|
int directivityCode = match.capturedTexts()[4].toInt(); |
|
m_antennaDirectivity = directivityMap[directivityCode]; |
|
|
|
m_hasStationDetails = true; |
|
|
|
idx += 7; |
|
return true; |
|
} |
|
|
|
// Radio range |
|
QRegularExpression rng("^RNG([0-9]{4})"); |
|
match = rng.match(s); |
|
if (match.hasMatch()) |
|
{ |
|
m_radioRangeMiles = match.capturedTexts()[1].toInt(); |
|
m_hasRadioRange = true; |
|
idx += 7; |
|
return true; |
|
} |
|
|
|
// Omni-DF strength |
|
QRegularExpression dfs("^DFS([0-9])([0-9])([0-9])([0-9])"); |
|
match = dfs.match(s); |
|
if (match.hasMatch()) |
|
{ |
|
// Strength S-points |
|
m_dfStrength = match.capturedTexts()[1].toInt(); |
|
|
|
// Antenna height |
|
int heightCode = match.capturedTexts()[2].toInt(); |
|
m_dfHeightFt = heightMap[heightCode]; |
|
|
|
// Antenna gain |
|
m_dfGainDB = match.capturedTexts()[3].toInt(); |
|
|
|
// Antenna directivity |
|
int directivityCode = match.capturedTexts()[4].toInt(); |
|
m_dfAntennaDirectivity = directivityMap[directivityCode]; |
|
|
|
m_hasDf = true; |
|
idx += 7; |
|
return true; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseComment(QString& info, int& idx) |
|
{ |
|
int commentLength = info.length() - idx; |
|
if (commentLength > 0) |
|
{ |
|
m_comment = info.right(commentLength); |
|
|
|
// Comment can contain altitude anywhere in it. Of the form /A=001234 in feet |
|
QRegularExpression re("\\/A=([0-9]{6})"); |
|
QRegularExpressionMatch match = re.match(m_comment); |
|
if (match.hasMatch()) |
|
{ |
|
m_altitudeFt = match.capturedTexts()[1].toInt(); |
|
m_hasAltitude = true; |
|
// Strip it out of comment if at start of string |
|
if (match.capturedStart(0) == 0) |
|
m_comment = m_comment.mid(9); |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseInt(QString& info, int& idx, int chars, int& value, bool& hasValue) |
|
{ |
|
int total = 0; |
|
bool negative = false; |
|
bool noValue = false; |
|
|
|
for (int i = 0; i < chars; i++) |
|
{ |
|
if (info[idx].isDigit()) |
|
{ |
|
total = total * 10; |
|
total += info[idx].toLatin1() - '0'; |
|
} |
|
else if ((i == 0) && (info[idx] == '-')) |
|
negative = true; |
|
else if ((info[idx] == '.') || (info[idx] == ' ')) |
|
noValue = true; |
|
else |
|
return false; |
|
idx++; |
|
} |
|
if (!noValue) |
|
{ |
|
if (negative) |
|
value = -total; |
|
else |
|
value = total; |
|
hasValue = true; |
|
} |
|
else |
|
hasValue = false; |
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseWeather(QString& info, int& idx, bool positionLess) |
|
{ |
|
if (!positionLess) |
|
{ |
|
if (!parseInt(info, idx, 3, m_windDirection, m_hasWindDirection)) |
|
return false; |
|
if (info[idx++] != '/') |
|
return false; |
|
if (!parseInt(info, idx, 3, m_windSpeed, m_hasWindSpeed)) |
|
return false; |
|
} |
|
|
|
// Weather data |
|
bool done = false; |
|
while (!done && (idx < info.length())) |
|
{ |
|
switch (info[idx++].toLatin1()) |
|
{ |
|
case 'c': // Wind direction |
|
if (!parseInt(info, idx, 3, m_windDirection, m_hasWindDirection)) |
|
return false; |
|
break; |
|
case 's': // Wind speed |
|
if (!parseInt(info, idx, 3, m_windSpeed, m_hasWindSpeed)) |
|
return false; |
|
break; |
|
case 'g': // Gust |
|
if (!parseInt(info, idx, 3, m_gust, m_hasGust)) |
|
return false; |
|
break; |
|
case 't': // Temp |
|
if (!parseInt(info, idx, 3, m_temp, m_hasTemp)) |
|
{ |
|
qDebug() << "Failed parsing temp: idx" << idx; |
|
return false; |
|
} |
|
break; |
|
case 'r': // Rain last hour |
|
if (!parseInt(info, idx, 3, m_rainLastHr, m_hasRainLastHr)) |
|
return false; |
|
break; |
|
case 'p': // Rain last 24 hours |
|
if (!parseInt(info, idx, 3, m_rainLast24Hrs, m_hasRainLast24Hrs)) |
|
return false; |
|
break; |
|
case 'P': // Rain since midnight |
|
if (!parseInt(info, idx, 3, m_rainSinceMidnight, m_hasRainSinceMidnight)) |
|
return false; |
|
break; |
|
case 'h': // Humidity |
|
if (!parseInt(info, idx, 2, m_humidity, m_hasHumidity)) |
|
return false; |
|
break; |
|
case 'b': // Barometric pressure |
|
if (!parseInt(info, idx, 5, m_barometricPressure, m_hasBarometricPressure)) |
|
return false; |
|
break; |
|
case 'L': // Luminosity <999 |
|
if (!parseInt(info, idx, 3, m_luminosity, m_hasLuminsoity)) |
|
return false; |
|
break; |
|
case 'l': // Luminosity >= 1000 |
|
if (!parseInt(info, idx, 3, m_luminosity, m_hasLuminsoity)) |
|
return false; |
|
m_luminosity += 1000; |
|
break; |
|
case 'S': // Snowfall |
|
if (!parseInt(info, idx, 3, m_snowfallLast24Hrs, m_hasSnowfallLast24Hrs)) |
|
return false; |
|
break; |
|
case '#': // Raw rain counter |
|
if (!parseInt(info, idx, 3, m_rawRainCounter, m_hasRawRainCounter)) |
|
return false; |
|
break; |
|
case 'X': // Radiation level |
|
if (!parseInt(info, idx, 3, m_radiationLevel, m_hasRadiationLevel)) |
|
return false; |
|
break; |
|
case 'F': // Floor water level |
|
if (!parseInt(info, idx, 4, m_floodLevel, m_hasFloodLevel)) |
|
return false; |
|
break; |
|
case 'V': // Battery volts |
|
if (!parseInt(info, idx, 3, m_batteryVolts, m_hasBatteryVolts)) |
|
return false; |
|
break; |
|
default: |
|
done = true; |
|
break; |
|
} |
|
} |
|
if (done) |
|
{ |
|
// APRS 1.1 spec says remaining fields are s/w and weather unit type |
|
// But few real-world packets actually seem to conform to the spec |
|
idx--; |
|
int remaining = info.length() - idx; |
|
m_weatherUnitType = info.right(remaining); |
|
idx += remaining; |
|
} |
|
|
|
m_hasWeather = true; |
|
return true; |
|
} |
|
|
|
|
|
bool APRSPacket::parseStorm(QString& info, int& idx) |
|
{ |
|
bool unused; |
|
|
|
if (!parseInt(info, idx, 3, m_stormDirection, unused)) |
|
return false; |
|
if (info[idx++] != '/') |
|
return false; |
|
if (!parseInt(info, idx, 3, m_stormSpeed, unused)) |
|
return false; |
|
if (info[idx++] != '/') |
|
return false; |
|
QString type = info.mid(idx, 2); |
|
idx += 2; |
|
if (type == "TS") |
|
m_stormType = "Tropical storm"; |
|
else if (type == "HC") |
|
m_stormType = "Hurrican"; |
|
else if (type == "TD") |
|
m_stormType = "Tropical depression"; |
|
else |
|
m_stormType = type; |
|
|
|
if (info[idx++] != '/') // Sustained wind speed |
|
return false; |
|
if (!parseInt(info, idx, 3, m_stormSustainedWindSpeed, unused)) |
|
return false; |
|
if (info[idx++] != '^') // Peak wind gusts |
|
return false; |
|
if (!parseInt(info, idx, 3, m_stormPeakWindGusts, unused)) |
|
return false; |
|
if (info[idx++] != '/') // Central pressure |
|
return false; |
|
if (!parseInt(info, idx, 4, m_stormCentralPresure, unused)) |
|
return false; |
|
if (info[idx++] != '>') // Radius hurrican winds |
|
return false; |
|
if (!parseInt(info, idx, 3, m_stormRadiusHurricanWinds, unused)) |
|
return false; |
|
if (info[idx++] != '&') // Radius tropical storm winds |
|
return false; |
|
if (!parseInt(info, idx, 3, m_stormRadiusTropicalStormWinds, unused)) |
|
return false; |
|
m_hasStormData = true; |
|
// Optional field |
|
if (info.length() >= idx + 4) |
|
{ |
|
if (info[idx] != '%') // Radius whole gail |
|
return true; |
|
idx++; |
|
if (!parseInt(info, idx, 3, m_stormRadiusWholeGail, m_hasStormRadiusWholeGail)) |
|
return false; |
|
} |
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseObject(QString& info, int& idx) |
|
{ |
|
if (info.length() < idx+10) |
|
return false; |
|
|
|
// Object names are 9 chars |
|
m_objectName = info.mid(idx, 9).trimmed(); |
|
idx += 9; |
|
|
|
if (info[idx] == '*') |
|
m_objectLive = true; |
|
else if (info[idx] == '_') |
|
m_objectKilled = true; |
|
else |
|
return false; |
|
idx++; |
|
|
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseItem(QString& info, int& idx) |
|
{ |
|
if (info.length() < idx+3) |
|
return false; |
|
|
|
// Item names are 3-9 chars long, excluding ! or _ |
|
m_objectName = ""; |
|
int i; |
|
for (i = 0; i < 10; i++) |
|
{ |
|
if (info.length() >= idx) |
|
{ |
|
QChar c = info[idx]; |
|
if (c == '!' || c == '_') |
|
break; |
|
else |
|
{ |
|
m_objectName.append(c); |
|
idx++; |
|
} |
|
} |
|
} |
|
if (i == 11) |
|
return false; |
|
if (info[idx] == '!') |
|
m_objectLive = true; |
|
else if (info[idx] == '_') |
|
m_objectKilled = true; |
|
idx++; |
|
|
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseStatus(QString& info, int& idx) |
|
{ |
|
QString remaining = info.mid(idx); |
|
|
|
QRegularExpression timestampRE("^([0-9]{6})z"); // DHM timestamp |
|
QRegularExpression maidenheadRE("^([A-Z]{2}[0-9]{2}[A-Z]{0,2})[/\\\\]."); // Maidenhead grid locator and symbol |
|
QRegularExpressionMatch matchTimestamp = timestampRE.match(remaining); |
|
QRegularExpressionMatch matchMaidenhead = maidenheadRE.match(remaining); |
|
|
|
if (matchTimestamp.hasMatch()) |
|
{ |
|
parseTime(info, idx); |
|
m_status = info.mid(idx); |
|
idx += m_status.length(); |
|
} |
|
else if (matchMaidenhead.hasMatch()) |
|
{ |
|
m_maidenhead = matchMaidenhead.capturedTexts()[1]; |
|
idx += m_maidenhead.length(); |
|
m_symbolTable = info[idx++].toLatin1(); |
|
m_symbolCode = info[idx++].toLatin1(); |
|
m_hasSymbol = true; |
|
if (info[idx] == ' ') |
|
{ |
|
idx++; |
|
m_status = info.mid(idx); |
|
idx += m_status.length(); |
|
} |
|
} |
|
else |
|
{ |
|
m_status = remaining; |
|
idx += m_status.length(); |
|
} |
|
m_hasStatus = true; |
|
|
|
// Check for beam heading and power in meteor scatter status reports |
|
int len = m_status.length(); |
|
if (len >= 3) |
|
{ |
|
if (m_status[len-3] == '^') |
|
{ |
|
bool error = false; |
|
char h = m_status[len-2].toLatin1(); |
|
char p = m_status[len-1].toLatin1(); |
|
|
|
if (isdigit(h)) |
|
m_beamHeading = (h - '0') * 10; |
|
else if (isupper(h)) |
|
m_beamHeading = (h - 'A') * 10 + 100; |
|
else |
|
error = true; |
|
|
|
switch (p) |
|
{ |
|
case '1': m_beamPower = 10; break; |
|
case '2': m_beamPower = 40; break; |
|
case '3': m_beamPower = 90; break; |
|
case '4': m_beamPower = 160; break; |
|
case '5': m_beamPower = 250; break; |
|
case '6': m_beamPower = 360; break; |
|
case '7': m_beamPower = 490; break; |
|
case '8': m_beamPower = 640; break; |
|
case '9': m_beamPower = 810; break; |
|
case ':': m_beamPower = 1000; break; |
|
case ';': m_beamPower = 1210; break; |
|
case '<': m_beamPower = 1440; break; |
|
case '=': m_beamPower = 1690; break; |
|
case '>': m_beamPower = 1960; break; |
|
case '?': m_beamPower = 2250; break; |
|
case '@': m_beamPower = 2560; break; |
|
case 'A': m_beamPower = 2890; break; |
|
case 'B': m_beamPower = 3240; break; |
|
case 'C': m_beamPower = 3610; break; |
|
case 'D': m_beamPower = 4000; break; |
|
case 'E': m_beamPower = 4410; break; |
|
case 'F': m_beamPower = 4840; break; |
|
case 'G': m_beamPower = 5290; break; |
|
case 'H': m_beamPower = 5760; break; |
|
case 'I': m_beamPower = 6250; break; |
|
case 'J': m_beamPower = 6760; break; |
|
case 'K': m_beamPower = 7290; break; |
|
default: error = true; break; |
|
} |
|
if (!error) |
|
{ |
|
m_hasBeam = true; |
|
m_status = m_status.left(len - 3); |
|
} |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseMessage(QString& info, int& idx) |
|
{ |
|
if (info.length() < idx+10) |
|
return false; |
|
|
|
// Addressee is fixed width |
|
if (info[idx+9] != ':') |
|
return false; |
|
m_addressee = info.mid(idx, 9).trimmed(); |
|
idx += 10; |
|
|
|
// Message |
|
m_message = info.mid(idx); |
|
idx += m_message.length(); |
|
|
|
// Check if telemetry parameter/unit names |
|
if (m_message.startsWith("PARM.")) |
|
{ |
|
bool done = false; |
|
QString s(""); |
|
int i = 5; |
|
while (!done) |
|
{ |
|
if (i >= m_message.length()) |
|
{ |
|
if (!s.isEmpty()) |
|
m_telemetryNames.append(s); |
|
done = true; |
|
} |
|
else if (m_message[i] == ',') |
|
{ |
|
if (!s.isEmpty()) |
|
m_telemetryNames.append(s); |
|
i++; |
|
s = ""; |
|
} |
|
else |
|
s.append(m_message[i++]); |
|
} |
|
} |
|
else if (m_message.startsWith("UNIT.")) |
|
{ |
|
bool done = false; |
|
QString s(""); |
|
int i = 5; |
|
while (!done) |
|
{ |
|
if (i >= m_message.length()) |
|
{ |
|
if (!s.isEmpty()) |
|
m_telemetryLabels.append(s); |
|
done = true; |
|
} |
|
else if (m_message[i] == ',') |
|
{ |
|
if (!s.isEmpty()) |
|
m_telemetryLabels.append(s); |
|
i++; |
|
s = ""; |
|
} |
|
else |
|
s.append(m_message[i++]); |
|
} |
|
} |
|
else if (m_message.startsWith("EQNS.")) |
|
{ |
|
bool done = false; |
|
QString s(""); |
|
int i = 5; |
|
QList <QString> telemetryCoefficients; |
|
while (!done) |
|
{ |
|
if (i >= m_message.length()) |
|
{ |
|
if (!s.isEmpty()) |
|
telemetryCoefficients.append(s); |
|
done = true; |
|
} |
|
else if (m_message[i] == ',') |
|
{ |
|
if (!s.isEmpty()) |
|
telemetryCoefficients.append(s); |
|
i++; |
|
s = ""; |
|
} |
|
else |
|
s.append(m_message[i++]); |
|
} |
|
m_hasTelemetryCoefficients = 0; |
|
for (int j = 0; j < telemetryCoefficients.length() / 3; j++) |
|
{ |
|
m_telemetryCoefficientsA[j] = telemetryCoefficients[j*3].toDouble(); |
|
m_telemetryCoefficientsB[j] = telemetryCoefficients[j*3+1].toDouble(); |
|
m_telemetryCoefficientsC[j] = telemetryCoefficients[j*3+2].toDouble(); |
|
m_hasTelemetryCoefficients++; |
|
} |
|
} |
|
else if (m_message.startsWith("BITS.")) |
|
{ |
|
QString s(""); |
|
int i = 5; |
|
for (int j = 0; j < 8; j++) |
|
{ |
|
if (i >= m_message.length()) |
|
m_telemetryBitSense[j] = m_message[i] == '1'; |
|
else |
|
m_telemetryBitSense[j] = true; |
|
i++; |
|
} |
|
m_hasTelemetryBitSense = true; |
|
m_telemetryProjectName = m_message.mid(i); |
|
i += m_telemetryProjectName.length(); |
|
} |
|
else |
|
{ |
|
// Check for message number |
|
QRegularExpression noRE("\\{([0-9]{1,5})$"); |
|
QRegularExpressionMatch match = noRE.match(m_message); |
|
if (match.hasMatch()) |
|
{ |
|
m_messageNo = match.capturedTexts()[1]; |
|
m_message = m_message.left(m_message.length() - m_messageNo.length() - 1); |
|
} |
|
} |
|
m_hasMessage = true; |
|
|
|
return true; |
|
} |
|
|
|
bool APRSPacket::parseTelemetry(QString& info, int& idx) |
|
{ |
|
if (info[idx] == '#') |
|
{ |
|
// Telemetry report |
|
idx++; |
|
if ((info[idx] == 'M') && (info[idx+1] == 'I') && (info[idx+2] == 'C')) |
|
idx += 3; |
|
else if (isdigit(info[idx].toLatin1()) && isdigit(info[idx+1].toLatin1()) && isdigit(info[idx+2].toLatin1())) |
|
{ |
|
m_seqNo = info.mid(idx, 3).toInt(); |
|
m_hasSeqNo = true; |
|
idx += 3; |
|
} |
|
else |
|
return false; |
|
|
|
if (info[idx] == ',') |
|
idx++; |
|
parseInt(info, idx, 3, m_a1, m_a1HasValue); |
|
if (info[idx++] != ',') |
|
return false; |
|
parseInt(info, idx, 3, m_a2, m_a2HasValue); |
|
if (info[idx++] != ',') |
|
return false; |
|
parseInt(info, idx, 3, m_a3, m_a3HasValue); |
|
if (info[idx++] != ',') |
|
return false; |
|
parseInt(info, idx, 3, m_a4, m_a4HasValue); |
|
if (info[idx++] != ',') |
|
return false; |
|
parseInt(info, idx, 3, m_a5, m_a5HasValue); |
|
if (info[idx++] != ',') |
|
return false; |
|
for (int i = 0; i < 8; i++) |
|
m_b[i] = info[idx++] == '1'; |
|
m_bHasValue = true; |
|
|
|
m_telemetryComment = info.mid(idx); |
|
idx += m_telemetryComment.length(); |
|
m_hasTelemetry = true; |
|
return true; |
|
} |
|
else |
|
return false; |
|
} |
|
|
|
// Mic-E Implementation by Peter Beckman KM4BBB github:ooglek |
|
bool APRSPacket::parseMicE(QString& info, int& idx, QString& dest) |
|
{ |
|
info = info.toLatin1(); |
|
// Mic-E Location data is encoded in the AX.25 Destination Address |
|
if (dest.length() < 6) { |
|
qDebug() << "APRSPacket::parseMicE: Destination invalid length " << dest; |
|
return false; |
|
} |
|
|
|
// Mic-E Information data is 8 bytes minimum, 13-14 with altitude |
|
if (info.length() < idx+8) { |
|
qDebug() << "APRSPacket::parseMicE: Information Data invalid length " << info; |
|
return false; |
|
} |
|
|
|
QString latDigits = ""; |
|
QString messageBits = ""; |
|
int messageType = 0; // 0 = Standard, 1 = Custom |
|
int longitudeOffset = 0; |
|
// Assume South & East, as North & West are encoded using consecutive Characters, easier and shorter to code |
|
float latitudeDirection = -1; // South |
|
float longitudeDirection = 1; // East |
|
|
|
QHash<QString, QString> messageTypeLookup = { |
|
{"111", "Off Duty"}, |
|
{"110", "En Route"}, |
|
{"101", "In Service"}, |
|
{"100", "Returning"}, |
|
{"011", "Committed"}, |
|
{"010", "Special"}, |
|
{"001", "Priority"}, |
|
{"000", "Emergency"} |
|
}; |
|
|
|
QRegularExpression re("^[A-LP-Z0-9]{3}[L-Z0-9]{3}.?$"); // 6-7 bytes |
|
if (re.match(dest).hasMatch()) { |
|
m_comment = "Mic-E"; |
|
for (int i = 0; i < 6; i++) { |
|
int charInt = charToIntAscii(dest, i); |
|
if (inRange(48, 57, charInt)) { |
|
latDigits.append(QString::number(charInt % 48)); |
|
} else if (inRange(65, 74, charInt)) { |
|
latDigits.append(QString::number(charInt % 65)); |
|
} else if (inRange(80, 89, charInt)) { |
|
latDigits.append(QString::number(charInt % 80)); |
|
} else { |
|
latDigits.append('0'); // Standard states "space" but we put a zero for math |
|
} |
|
|
|
// Message Type is encoded in 3 bits |
|
if (i < 3) { |
|
if (inRange(48, 57, charInt) || charInt == 76) { // 0-9 or L |
|
messageBits.append('0'); |
|
} else if (inRange(80, 90, charInt)) { // P-Z, Standard |
|
messageBits.append('1'); |
|
messageType = 0; |
|
} else if (inRange(65, 75, charInt)) { // A-K, Custom |
|
messageBits.append('1'); |
|
messageType = 1; |
|
} |
|
} |
|
|
|
// Latitude Direction |
|
if (i == 3 && inRange(80, 90, charInt)) { |
|
latitudeDirection = 1; // North |
|
} |
|
|
|
// Longitude Offset |
|
if (i == 4 && inRange(80, 90, charInt)) { |
|
longitudeOffset = 100; |
|
} |
|
|
|
// Longitude Direction |
|
if (i == 5 && inRange(80, 90, charInt)) { |
|
longitudeDirection = -1; // West |
|
} |
|
} |
|
|
|
if (messageTypeLookup.find(messageBits) != messageTypeLookup.end()) { |
|
m_status = messageTypeLookup[messageBits]; |
|
if (messageType == 1) { |
|
m_status.append(" (custom)"); |
|
} |
|
m_hasStatus = true; |
|
} |
|
m_latitude = (latDigits.mid(0, 2).toFloat() + latDigits.mid(2, 2).toFloat()/60.00 + latDigits.mid(4, 2).toFloat()/60.0/100.0) * latitudeDirection; |
|
m_hasPosition = true; |
|
} else { |
|
qDebug() << "APRSPacket::parseMicE: Destination invalid regexp match " << dest; |
|
return false; |
|
} |
|
|
|
// Mic-E Data is encoded in ASCII Characters |
|
if (inRange(38, 127, charToIntAscii(info, idx)) // 0: Longitude Degrees, 0-360 |
|
&& inRange(38, 97, charToIntAscii(info, idx+1)) // 1: Longitude Minutes, 0-59 |
|
&& inRange(28, 127, charToIntAscii(info, idx+2)) // 2: Longitude Hundreths of a minute, 0-99 |
|
&& inRange(28, 127, charToIntAscii(info, idx+3)) // 3: Speed (tens), 0-800 |
|
&& inRange(28, 125, charToIntAscii(info, idx+4)) // 4: Speed (ones), 0-9, and Course (hundreds), {0, 100, 200, 300} |
|
&& inRange(28, 127, charToIntAscii(info, idx+5)) // 5: Course, 0-99 degrees |
|
) |
|
{ |
|
// Longitude; Degrees plus offset encoded in the AX.25 Destination |
|
// Destination Byte 5, ASCII P through Z indicates an offset of +100 |
|
int deg = (charToIntAscii(info, idx) - 28) + longitudeOffset; |
|
if (inRange(180, 189, deg)) |
|
deg -= 80; |
|
if (inRange(190, 199, deg)) |
|
deg -= 190; |
|
|
|
int min = (charToIntAscii(info, idx+1) - 28) % 60; |
|
int hundreths = charToIntAscii(info, idx+2); |
|
|
|
// Course and Speed |
|
// Speed (SP+28, units of 10) can use two encodings: ASCII 28-47 and 108-127 are the same |
|
// Speed & Course (DC+28, Speed units of 1, Course units of 100 e.g. 0, 100, 200, 300) uses two encodings |
|
int speed = ((charToIntAscii(info, idx+3) - 28) * 10) % 800; // Speed in 10 kts units |
|
float decoded_speed_course = (float)(charToIntAscii(info, idx+4) - 28) / 10.0; |
|
speed += floor(decoded_speed_course); // Speed in 1 kt units, added to above |
|
int course = (((charToIntAscii(info, idx+4) - 28) % 10) * 100) % 400; |
|
course += charToIntAscii(info, idx+5) - 28; |
|
|
|
m_longitude = (((float)deg) + min/60.00 + hundreths/60.0/100.0) * longitudeDirection; |
|
m_hasPosition = true; |
|
m_course = course; |
|
m_speed = speed; |
|
m_hasCourseAndSpeed = true; |
|
} else { |
|
qDebug() << "APRSPacket::parseMicE: Information Data invalid ASCII range " << info; |
|
return false; |
|
} |
|
|
|
// 6: Symbol Code |
|
// 7: Symbol Table ID, / = standard, \ = alternate, "," = Telemetry |
|
if (inRange(33, 126, charToIntAscii(info, idx+6)) |
|
&& (charToIntAscii(info, idx+7) == 47 || charToIntAscii(info, idx+7) == 92) |
|
) |
|
{ |
|
m_symbolTable = info[idx+7].toLatin1(); |
|
m_symbolCode = info[idx+6].toLatin1(); |
|
m_hasSymbol = true; |
|
} |
|
|
|
// Altitude, encoded in Status Message in meters, converted to feet, above -10000 meters |
|
// e.g. "4T} -> Doublequote is 34, digit 4 is 52, Capital T is 84. Subtract 33 from each -> 1, 19, 51 |
|
// Multiply -> (1 * 91 * 91) + (19 * 91) + (51 * 1) - 10000 = 61 meters Mean Sea Level (MSL) |
|
// ASCII Integer Character Range is 33 to 127 |
|
float altitude = -10000; |
|
|
|
// 4-5 bytes, we only need the 3 to get altitude, e.g. "4T} |
|
// Some HTs prefix the altitude with ']' or '>', so we match that optionally but ignore it |
|
QRegularExpression re_mice_altitude("[\\]>]?(.{3})}"); |
|
QRegularExpressionMatch altitude_str = re_mice_altitude.match(info); |
|
if (altitude_str.hasMatch()) { |
|
QList<int> micEAltitudeMultipliers = {91 * 91, 91, 1}; |
|
|
|
for (int i = 0; i < 3; i++) { |
|
QString altmatch = altitude_str.captured(1); |
|
int charInt = charToIntAscii(altmatch, i); |
|
if (!inRange(33, 127, charInt)) { |
|
qDebug() << "APRSPacket::parseMicE: Invalid Altitude Byte Found pos:" << QString::number(i) << " ascii int:" << QString::number(charInt); |
|
break; |
|
} |
|
altitude += (float)(charInt - 33) * micEAltitudeMultipliers.at(i); |
|
} |
|
|
|
// Assume that the Mic-E transmission is Above Ground Level |
|
if (altitude >= 0) { |
|
m_altitudeFt = std::round(Units::metresToFeet(altitude)); |
|
m_hasAltitude = true; |
|
} |
|
} |
|
|
|
// Mic-E Text Format |
|
if (info.length() >= 9) { |
|
QString mice_status = info.mid(9); |
|
if (altitude_str.hasMatch() && mice_status.indexOf(altitude_str.captured(0)) != -1) { |
|
mice_status.replace(altitude_str.captured(0), ""); |
|
} |
|
|
|
m_comment += " " + mice_status; |
|
// TODO Implement the APRS 1.2 Mic-E Text Format http://www.aprs.org/aprs12/mic-e-types.txt |
|
// Consider the Kenwood leading characters |
|
} |
|
|
|
// TODO Implement Mic-E Telemetry Data -- need to modify regexp for the Symbol Table Identifier to include comma (,) |
|
|
|
return true; |
|
} |
|
|
|
|