Checkpoint

ui/src/protocols/aprs.ts

@@ -0,0 +1,745 @@
+import type { Address, Frame as IFrame, DecodedPayload, Timestamp as ITimestamp } from "./aprs.types"
+import { base91ToNumber } from "../libs/base91"
+
+export class Timestamp implements ITimestamp {
+  day?: number;
+  month?: number;
+  hours: number;
+  minutes: number;
+  seconds?: number;
+  format: 'DHM' | 'HMS' | 'MDHM';
+  zulu?: boolean;
+
+  constructor(
+    hours: number,
+    minutes: number,
+    format: 'DHM' | 'HMS' | 'MDHM',
+    options: {
+      day?: number;
+      month?: number;
+      seconds?: number;
+      zulu?: boolean;
+    } = {}
+  ) {
+    this.hours = hours;
+    this.minutes = minutes;
+    this.format = format;
+    this.day = options.day;
+    this.month = options.month;
+    this.seconds = options.seconds;
+    this.zulu = options.zulu;
+  }
+
+  /**
+   * Convert APRS timestamp to JavaScript Date object
+   * Note: APRS timestamps don't include year, so we use current year
+   * For DHM format, we find the most recent occurrence of that day
+   * For HMS format, we use current date
+   * For MDHM format, we use the specified month/day in current year
+   */
+  toDate(): Date {
+    const now = new Date();
+
+    if (this.format === 'DHM') {
+      // Day-Hour-Minute format (UTC)
+      // Find the most recent occurrence of this day
+      const currentYear = this.zulu ? now.getUTCFullYear() : now.getFullYear();
+      const currentMonth = this.zulu ? now.getUTCMonth() : now.getMonth();
+
+      let date: Date;
+      if (this.zulu) {
+        date = new Date(Date.UTC(currentYear, currentMonth, this.day!, this.hours, this.minutes, 0, 0));
+      } else {
+        date = new Date(currentYear, currentMonth, this.day!, this.hours, this.minutes, 0, 0);
+      }
+
+      // If the date is in the future, it's from last month
+      if (date > now) {
+        if (this.zulu) {
+          date = new Date(Date.UTC(currentYear, currentMonth - 1, this.day!, this.hours, this.minutes, 0, 0));
+        } else {
+          date = new Date(currentYear, currentMonth - 1, this.day!, this.hours, this.minutes, 0, 0);
+        }
+      }
+
+      return date;
+    } else if (this.format === 'HMS') {
+      // Hour-Minute-Second format (UTC)
+      // Use current date
+      if (this.zulu) {
+        const date = new Date();
+        date.setUTCHours(this.hours, this.minutes, this.seconds || 0, 0);
+
+        // If time is in the future, it's from yesterday
+        if (date > now) {
+          date.setUTCDate(date.getUTCDate() - 1);
+        }
+
+        return date;
+      } else {
+        const date = new Date();
+        date.setHours(this.hours, this.minutes, this.seconds || 0, 0);
+
+        if (date > now) {
+          date.setDate(date.getDate() - 1);
+        }
+
+        return date;
+      }
+    } else {
+      // MDHM format: Month-Day-Hour-Minute (local time)
+      const currentYear = now.getFullYear();
+      let date = new Date(currentYear, (this.month || 1) - 1, this.day!, this.hours, this.minutes, 0, 0);
+
+      // If date is in the future, it's from last year
+      if (date > now) {
+        date = new Date(currentYear - 1, (this.month || 1) - 1, this.day!, this.hours, this.minutes, 0, 0);
+      }
+
+      return date;
+    }
+  }
+}
+
+export const parseAddress = (addr: string): Address => {
+  const isRepeated = addr.endsWith('*');
+
+  const baseAddr = isRepeated ? addr.slice(0, -1) : addr;
+  const parts = baseAddr.split('-');
+  const call = parts[0];
+  const ssid = parts.length > 1 ? parts[1] : '';
+
+  return {call, ssid, isRepeated};
+}
+
+export class Frame implements IFrame {
+  source: Address;
+  destination: Address;
+  path: Address[];
+  payload: string;
+
+  constructor(source: Address, destination: Address, path: Address[], payload: string) {
+    this.source = source;
+    this.destination = destination;
+    this.path = path;
+    this.payload = payload;
+  }
+
+  /**
+   * Get the data type identifier (first character of payload)
+   */
+  getDataTypeIdentifier(): string {
+    return this.payload.charAt(0);
+  }
+
+  /**
+   * Decode the APRS payload based on its data type identifier
+   */
+  decode(): DecodedPayload | null {
+    if (!this.payload) {
+      return null;
+    }
+
+    const dataType = this.getDataTypeIdentifier();
+
+    // TODO: Implement full decoding logic for each payload type
+    switch (dataType) {
+      case '!': // Position without timestamp, no messaging
+      case '=': // Position without timestamp, with messaging
+      case '/': // Position with timestamp, no messaging
+      case '@': // Position with timestamp, with messaging
+        return this.decodePosition(dataType);
+
+      case '`': // Mic-E current
+      case "'": // Mic-E old
+        return this.decodeMicE(dataType);
+
+      case ':': // Message
+        return this.decodeMessage();
+
+      case ';': // Object
+        return this.decodeObject();
+
+      case ')': // Item
+        return this.decodeItem();
+
+      case '>': // Status
+        return this.decodeStatus();
+
+      case '?': // Query
+        return this.decodeQuery();
+
+      case 'T': // Telemetry
+        return this.decodeTelemetry();
+
+      case '_': // Weather without position
+        return this.decodeWeather();
+
+      case '$': // Raw GPS
+        return this.decodeRawGPS();
+
+      case '<': // Station capabilities
+        return this.decodeCapabilities();
+
+      case '{': // User-defined
+        return this.decodeUserDefined();
+
+      case '}': // Third-party
+        return this.decodeThirdParty();
+
+      default:
+        return null;
+    }
+  }
+
+  private decodePosition(dataType: string): DecodedPayload | null {
+    try {
+      const hasTimestamp = dataType === '/' || dataType === '@';
+      const messaging = dataType === '=' || dataType === '@';
+      let offset = 1; // Skip data type identifier
+
+      let timestamp: Timestamp | undefined = undefined;
+
+      // Parse timestamp if present (7 characters: DDHHMMz or HHMMSSh or MMDDHHMM)
+      if (hasTimestamp) {
+        if (this.payload.length < 8) return null;
+        const timeStr = this.payload.substring(offset, offset + 7);
+        timestamp = this.parseTimestamp(timeStr);
+        offset += 7;
+      }
+
+      if (this.payload.length < offset + 19) return null;
+
+      // Check if compressed format
+      const isCompressed = this.isCompressedPosition(this.payload.substring(offset));
+
+      let position: any;
+      let comment = '';
+
+      if (isCompressed) {
+        // Compressed format: /YYYYXXXX$csT
+        const compressed = this.parseCompressedPosition(this.payload.substring(offset));
+        if (!compressed) return null;
+
+        position = {
+          latitude: compressed.latitude,
+          longitude: compressed.longitude,
+          symbol: compressed.symbol,
+        };
+
+        if (compressed.altitude !== undefined) {
+          position.altitude = compressed.altitude;
+        }
+
+        offset += 13; // Compressed position is 13 chars
+        comment = this.payload.substring(offset);
+      } else {
+        // Uncompressed format: DDMMmmH/DDDMMmmH$
+        const uncompressed = this.parseUncompressedPosition(this.payload.substring(offset));
+        if (!uncompressed) return null;
+
+        position = {
+          latitude: uncompressed.latitude,
+          longitude: uncompressed.longitude,
+          symbol: uncompressed.symbol,
+        };
+
+        if (uncompressed.ambiguity !== undefined) {
+          position.ambiguity = uncompressed.ambiguity;
+        }
+
+        offset += 19; // Uncompressed position is 19 chars
+        comment = this.payload.substring(offset);
+      }
+
+      // Parse altitude from comment if present (format: /A=NNNNNN)
+      const altMatch = comment.match(/\/A=(\d{6})/);
+      if (altMatch) {
+        position.altitude = parseInt(altMatch[1], 10) * 0.3048; // feet to meters
+      }
+
+      if (comment) {
+        position.comment = comment;
+      }
+
+      return {
+        type: 'position',
+        timestamp,
+        position,
+        messaging,
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  private parseTimestamp(timeStr: string): Timestamp | undefined {
+    if (timeStr.length !== 7) return undefined;
+
+    const timeType = timeStr.charAt(6);
+
+    if (timeType === 'z') {
+      // DHM format: Day-Hour-Minute (UTC)
+      return new Timestamp(
+        parseInt(timeStr.substring(2, 4), 10),
+        parseInt(timeStr.substring(4, 6), 10),
+        'DHM',
+        {
+          day: parseInt(timeStr.substring(0, 2), 10),
+          zulu: true,
+        }
+      );
+    } else if (timeType === 'h') {
+      // HMS format: Hour-Minute-Second (UTC)
+      return new Timestamp(
+        parseInt(timeStr.substring(0, 2), 10),
+        parseInt(timeStr.substring(2, 4), 10),
+        'HMS',
+        {
+          seconds: parseInt(timeStr.substring(4, 6), 10),
+          zulu: true,
+        }
+      );
+    } else if (timeType === '/') {
+      // MDHM format: Month-Day-Hour-Minute (local)
+      return new Timestamp(
+        parseInt(timeStr.substring(4, 6), 10),
+        parseInt(timeStr.substring(6, 8), 10),
+        'MDHM',
+        {
+          month: parseInt(timeStr.substring(0, 2), 10),
+          day: parseInt(timeStr.substring(2, 4), 10),
+          zulu: false,
+        }
+      );
+    }
+
+    return undefined;
+  }
+
+  private isCompressedPosition(data: string): boolean {
+    if (data.length < 13) return false;
+
+    // Uncompressed format has / at position 8 (symbol table separator)
+    // Format: DDMMmmH/DDDMMmmH$ where / is at position 8
+    if (data.length >= 19 && data.charAt(8) === '/') {
+      return false; // It's uncompressed
+    }
+
+    // For compressed format, check if the position part looks like base-91 encoded data
+    // Compressed format: STYYYYXXXXcsT where ST is symbol table/code
+    // Base-91 chars are in range 33-124 (! to |)
+    const lat1 = data.charCodeAt(1);
+    const lat2 = data.charCodeAt(2);
+    const lon1 = data.charCodeAt(5);
+    const lon2 = data.charCodeAt(6);
+
+    return lat1 >= 33 && lat1 <= 124 &&
+           lat2 >= 33 && lat2 <= 124 &&
+           lon1 >= 33 && lon1 <= 124 &&
+           lon2 >= 33 && lon2 <= 124;
+  }
+
+  private parseCompressedPosition(data: string): { latitude: number; longitude: number; symbol: any; altitude?: number } | null {
+    if (data.length < 13) return null;
+
+    const symbolTable = data.charAt(0);
+    const symbolCode = data.charAt(9);
+
+    // Extract base-91 encoded position (4 characters each)
+    const latStr = data.substring(1, 5);
+    const lonStr = data.substring(5, 9);
+
+    try {
+      // Decode base-91 encoded latitude and longitude
+      const latBase91 = base91ToNumber(latStr);
+      const lonBase91 = base91ToNumber(lonStr);
+
+      // Convert to degrees
+      const latitude = 90 - (latBase91 / 380926);
+      const longitude = -180 + (lonBase91 / 190463);
+
+      const result: any = {
+        latitude,
+        longitude,
+        symbol: {
+          table: symbolTable,
+          code: symbolCode,
+        },
+      };
+
+      // Check for compressed altitude (csT format)
+      const cs = data.charAt(10);
+      const t = data.charCodeAt(11);
+
+      if (cs === ' ' && t >= 33 && t <= 124) {
+        // Compressed altitude: altitude = 1.002^(t-33) feet
+        const altFeet = Math.pow(1.002, t - 33);
+        result.altitude = altFeet * 0.3048; // Convert to meters
+      }
+
+      return result;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  private parseUncompressedPosition(data: string): { latitude: number; longitude: number; symbol: any; ambiguity?: number } | null {
+    if (data.length < 19) return null;
+
+    // Format: DDMMmmH/DDDMMmmH$ where H is hemisphere, $ is symbol code
+    // Positions: 0-7 (latitude), 8 (symbol table), 9-17 (longitude), 18 (symbol code)
+    // Spaces may replace rightmost digits for ambiguity/privacy
+
+    const latStr = data.substring(0, 8); // DDMMmmH (8 chars: 49 03.50 N)
+    const symbolTable = data.charAt(8);
+    const lonStr = data.substring(9, 18); // DDDMMmmH (9 chars: 072 01.75 W)
+    const symbolCode = data.charAt(18);
+
+    // Count and handle ambiguity (spaces in minutes part replace rightmost digits)
+    let ambiguity = 0;
+    const latSpaceCount = (latStr.match(/ /g) || []).length;
+    const lonSpaceCount = (lonStr.match(/ /g) || []).length;
+
+    if (latSpaceCount > 0 || lonSpaceCount > 0) {
+      // Use the maximum space count (they should be the same, but be defensive)
+      ambiguity = Math.max(latSpaceCount, lonSpaceCount);
+    }
+
+    // Replace spaces with zeros for parsing
+    const latStrNormalized = latStr.replace(/ /g, '0');
+    const lonStrNormalized = lonStr.replace(/ /g, '0');
+
+    // Parse latitude
+    const latDeg = parseInt(latStrNormalized.substring(0, 2), 10);
+    const latMin = parseFloat(latStrNormalized.substring(2, 7));
+    const latHem = latStrNormalized.charAt(7);
+
+    if (isNaN(latDeg) || isNaN(latMin)) return null;
+    if (latHem !== 'N' && latHem !== 'S') return null;
+
+    let latitude = latDeg + (latMin / 60);
+    if (latHem === 'S') latitude = -latitude;
+
+    // Parse longitude
+    const lonDeg = parseInt(lonStrNormalized.substring(0, 3), 10);
+    const lonMin = parseFloat(lonStrNormalized.substring(3, 8));
+    const lonHem = lonStrNormalized.charAt(8);
+
+    if (isNaN(lonDeg) || isNaN(lonMin)) return null;
+    if (lonHem !== 'E' && lonHem !== 'W') return null;
+
+    let longitude = lonDeg + (lonMin / 60);
+    if (lonHem === 'W') longitude = -longitude;
+
+    const result: any = {
+      latitude,
+      longitude,
+      symbol: {
+        table: symbolTable,
+        code: symbolCode,
+      },
+    };
+
+    if (ambiguity > 0) {
+      result.ambiguity = ambiguity;
+    }
+
+    return result;
+  }
+
+  private decodeMicE(dataType: string): DecodedPayload | null {
+    try {
+      // Mic-E encodes position in both destination address and information field
+      const dest = this.destination.call;
+
+      if (dest.length < 6) return null;
+      if (this.payload.length < 9) return null; // Need at least data type + 8 bytes
+
+      // Decode latitude from destination address (6 characters)
+      const latResult = this.decodeMicELatitude(dest);
+      if (!latResult) return null;
+
+      const { latitude, messageType, longitudeOffset, isWest, isStandard } = latResult;
+
+      // Parse information field (skip data type identifier at position 0)
+      let offset = 1;
+
+      // Longitude: 3 bytes (degrees, minutes, hundredths)
+      const lonDegRaw = this.payload.charCodeAt(offset) - 28;
+      const lonMinRaw = this.payload.charCodeAt(offset + 1) - 28;
+      const lonHunRaw = this.payload.charCodeAt(offset + 2) - 28;
+      offset += 3;
+
+      // Apply longitude offset and hemisphere
+      let lonDeg = lonDegRaw;
+      if (longitudeOffset) {
+        lonDeg += 100;
+      }
+      if (lonDeg >= 180 && lonDeg <= 189) {
+        lonDeg -= 80;
+      } else if (lonDeg >= 190 && lonDeg <= 199) {
+        lonDeg -= 190;
+      }
+
+      let longitude = lonDeg + (lonMinRaw / 60.0) + (lonHunRaw / 6000.0);
+      if (isWest) {
+        longitude = -longitude;
+      }
+
+      // Speed and course: 3 bytes
+      const sp = this.payload.charCodeAt(offset) - 28;
+      const dc = this.payload.charCodeAt(offset + 1) - 28;
+      const se = this.payload.charCodeAt(offset + 2) - 28;
+      offset += 3;
+
+      let speed = (sp * 10) + Math.floor(dc / 10); // Speed in knots
+      let course = ((dc % 10) * 100) + se; // Course in degrees
+
+      if (course >= 400) course -= 400;
+      if (speed >= 800) speed -= 800;
+
+      // Convert speed from knots to km/h
+      const speedKmh = speed * 1.852;
+
+      // Symbol code and table
+      if (this.payload.length < offset + 2) return null;
+      const symbolCode = this.payload.charAt(offset);
+      const symbolTable = this.payload.charAt(offset + 1);
+      offset += 2;
+
+      // Parse remaining data (altitude, comment, telemetry)
+      const remaining = this.payload.substring(offset);
+      let altitude: number | undefined = undefined;
+      let comment = remaining;
+
+      // Check for altitude in various formats
+      // Format 1: }xyz where xyz is altitude in base-91 (obsolete)
+      // Format 2: /A=NNNNNN where NNNNNN is altitude in feet
+      const altMatch = remaining.match(/\/A=(\d{6})/);
+      if (altMatch) {
+        altitude = parseInt(altMatch[1], 10) * 0.3048; // feet to meters
+      } else if (remaining.startsWith('}')) {
+        // Base-91 altitude (3 characters after })
+        if (remaining.length >= 4) {
+          try {
+            const altBase91 = remaining.substring(1, 4);
+            const altFeet = base91ToNumber(altBase91) - 10000;
+            altitude = altFeet * 0.3048; // feet to meters
+          } catch (e) {
+            // Ignore altitude parsing errors
+          }
+        }
+      }
+
+      const result: any = {
+        type: 'position',
+        position: {
+          latitude,
+          longitude,
+          symbol: {
+            table: symbolTable,
+            code: symbolCode,
+          },
+        },
+        messaging: true, // Mic-E is always messaging-capable
+        micE: {
+          messageType,
+          isStandard,
+        },
+      };
+
+      if (speed > 0) {
+        result.position.speed = speedKmh;
+      }
+
+      if (course > 0 && course < 360) {
+        result.position.course = course;
+      }
+
+      if (altitude !== undefined) {
+        result.position.altitude = altitude;
+      }
+
+      if (comment) {
+        result.position.comment = comment;
+      }
+
+      return result;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  private decodeMicELatitude(dest: string): {
+    latitude: number;
+    messageType: string;
+    longitudeOffset: boolean;
+    isWest: boolean;
+    isStandard: boolean;
+  } | null {
+    if (dest.length < 6) return null;
+
+    // Each destination character encodes a latitude digit and message bits
+    const digits: number[] = [];
+    const messageBits: number[] = [];
+
+    for (let i = 0; i < 6; i++) {
+      const char = dest.charAt(i);
+      const code = dest.charCodeAt(i);
+      let digit: number;
+      let msgBit: number;
+
+      if (code >= 48 && code <= 57) {
+        // '0'-'9'
+        digit = code - 48;
+        msgBit = 0;
+      } else if (code >= 65 && code <= 74) {
+        // 'A'-'J' (A=0, B=1, ... J=9)
+        digit = code - 65;
+        msgBit = 1;
+      } else if (code === 75) {
+        // 'K' means space (used for ambiguity)
+        digit = 0;
+        msgBit = 1;
+      } else if (code === 76) {
+        // 'L' means space
+        digit = 0;
+        msgBit = 0;
+      } else if (code >= 80 && code <= 89) {
+        // 'P'-'Y' custom message types (P=0, Q=1, R=2, ... Y=9)
+        digit = code - 80;
+        msgBit = 1;
+      } else if (code === 90) {
+        // 'Z' means space
+        digit = 0;
+        msgBit = 1;
+      } else {
+        return null; // Invalid character
+      }
+
+      digits.push(digit);
+      messageBits.push(msgBit);
+    }
+
+    // Decode latitude: format is DDMM.HH (degrees, minutes, hundredths)
+    const latDeg = digits[0] * 10 + digits[1];
+    const latMin = digits[2] * 10 + digits[3];
+    const latHun = digits[4] * 10 + digits[5];
+
+    let latitude = latDeg + (latMin / 60.0) + (latHun / 6000.0);
+
+    // Message bits determine hemisphere and other flags
+    // Bit 3 (messageBits[3]): 0 = North, 1 = South
+    // Bit 4 (messageBits[4]): 0 = West, 1 = East
+    // Bit 5 (messageBits[5]): 0 = longitude offset +0, 1 = longitude offset +100
+    const isNorth = messageBits[3] === 0;
+    const isWest = messageBits[4] === 0;
+    const longitudeOffset = messageBits[5] === 1;
+
+    if (!isNorth) {
+      latitude = -latitude;
+    }
+
+    // Decode message type from bits 0, 1, 2
+    const msgValue = messageBits[0] * 4 + messageBits[1] * 2 + messageBits[2];
+    const messageTypes = [
+      'M0: Off Duty',
+      'M1: En Route',
+      'M2: In Service',
+      'M3: Returning',
+      'M4: Committed',
+      'M5: Special',
+      'M6: Priority',
+      'M7: Emergency',
+    ];
+    const messageType = messageTypes[msgValue] || 'Unknown';
+
+    // Standard vs custom message indicator
+    const isStandard = messageBits[0] === 1;
+
+    return {
+      latitude,
+      messageType,
+      longitudeOffset,
+      isWest,
+      isStandard,
+    };
+  }
+
+  private decodeMessage(): DecodedPayload | null {
+    // TODO: Implement message decoding
+    return null;
+  }
+
+  private decodeObject(): DecodedPayload | null {
+    // TODO: Implement object decoding
+    return null;
+  }
+
+  private decodeItem(): DecodedPayload | null {
+    // TODO: Implement item decoding
+    return null;
+  }
+
+  private decodeStatus(): DecodedPayload | null {
+    // TODO: Implement status decoding
+    return null;
+  }
+
+  private decodeQuery(): DecodedPayload | null {
+    // TODO: Implement query decoding
+    return null;
+  }
+
+  private decodeTelemetry(): DecodedPayload | null {
+    // TODO: Implement telemetry decoding
+    return null;
+  }
+
+  private decodeWeather(): DecodedPayload | null {
+    // TODO: Implement weather decoding
+    return null;
+  }
+
+  private decodeRawGPS(): DecodedPayload | null {
+    // TODO: Implement raw GPS decoding
+    return null;
+  }
+
+  private decodeCapabilities(): DecodedPayload | null {
+    // TODO: Implement capabilities decoding
+    return null;
+  }
+
+  private decodeUserDefined(): DecodedPayload | null {
+    // TODO: Implement user-defined decoding
+    return null;
+  }
+
+  private decodeThirdParty(): DecodedPayload | null {
+    // TODO: Implement third-party decoding
+    return null;
+  }
+}
+
+export const parseFrame = (data: string): Frame => {
+  const routeSepIndex = data.indexOf(':');
+  if (routeSepIndex === -1) {
+    throw new Error('APRS: invalid frame, no route separator found');
+  }
+
+  const route = data.slice(0, routeSepIndex);
+  const payload = data.slice(routeSepIndex + 1);
+  const parts = route.split('>');
+  if (parts.length < 2) {
+    throw new Error('APRS: invalid addresses in route');
+  }
+
+  const source = parseAddress(parts[0]);
+  const destinationAndPath = parts[1].split(',');
+  const destination = parseAddress(destinationAndPath[0]);
+  const path = destinationAndPath.slice(1).map(addr => parseAddress(addr));
+
+  return new Frame(source, destination, path, payload);
+}