@springfield/ham-radio-utils 4.1.1 → 4.2.0

package/src/schemas/radio-memory-map-schema.json

@@ -0,0 +1,151 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Radio Memory-Map DSL Schema",
+  "description": "Schema for defining radio EEPROM settings layout as JSON (Chirp MEM_FORMAT as data)",
+  "type": "object",
+  "required": ["structs"],
+  "properties": {
+    "version": {
+      "type": "string",
+      "description": "Optional map version"
+    },
+    "description": {
+      "type": "string"
+    },
+    "structs": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "#/definitions/struct"
+      }
+    }
+  },
+  "definitions": {
+    "seek": {
+      "oneOf": [
+        { "type": "integer", "minimum": 0 },
+        { "type": "string", "pattern": "^(0[xX][0-9a-fA-F]+|[0-9]+)$" }
+      ]
+    },
+    "ui": {
+      "type": "object",
+      "required": ["group", "label", "widget"],
+      "properties": {
+        "group": { "type": "string" },
+        "label": { "type": "string" },
+        "widget": {
+          "type": "string",
+          "enum": ["integer", "select", "switch", "text", "number"]
+        },
+        "description": { "type": "string" },
+        "writable": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "value": {
+      "oneOf": [
+        {
+          "type": "object",
+          "required": ["kind"],
+          "properties": {
+            "kind": { "const": "integer" },
+            "min": { "type": "number" },
+            "max": { "type": "number" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind"],
+          "properties": {
+            "kind": { "const": "boolean" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "values"],
+          "properties": {
+            "kind": { "const": "enum" },
+            "values": {
+              "type": "array",
+              "items": { "type": "string" },
+              "minItems": 1
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "length"],
+          "properties": {
+            "kind": { "const": "ascii" },
+            "length": { "type": "integer", "minimum": 1 }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "length"],
+          "properties": {
+            "kind": { "const": "digits" },
+            "length": { "type": "integer", "minimum": 1 },
+            "scale": { "type": "number" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "length"],
+          "properties": {
+            "kind": { "const": "dtmf" },
+            "length": { "type": "integer", "minimum": 1 },
+            "charset": { "type": "string" }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["kind", "length"],
+          "properties": {
+            "kind": { "const": "bbcd" },
+            "length": { "type": "integer", "minimum": 1 }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "field": {
+      "type": "object",
+      "required": ["id", "type"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "type": {
+          "type": "string",
+          "enum": ["u8", "u16", "bits", "char"]
+        },
+        "width": { "type": "integer", "minimum": 1, "maximum": 8 },
+        "reserved": { "type": "boolean" },
+        "value": { "$ref": "#/definitions/value" },
+        "ui": { "$ref": "#/definitions/ui" }
+      },
+      "additionalProperties": false
+    },
+    "struct": {
+      "type": "object",
+      "required": ["id", "seek", "fields"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "seek": { "$ref": "#/definitions/seek" },
+        "fields": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/field" }
+        },
+        "count": { "type": "integer", "minimum": 1 },
+        "stride": { "type": "integer", "minimum": 1 }
+      },
+      "additionalProperties": false
+    }
+  }
+}

package/src/utils/band-plan.ts

@@ -8,21 +8,36 @@ interface LicenseClass {
 }
 
 export class BandPlan {
-  private bands: SpectrumBand[];
-  private licenseClasses: Map<string, LicenseClass>;
+  private readonly bands: SpectrumBand[];
+  private readonly licenseClasses: Map<string, LicenseClass>;
+  private readonly frsLicenseClassId: string | undefined;
 
   constructor() {
     this.bands = bandsData as SpectrumBand[];
     this.licenseClasses = new Map((licenseClassesData as LicenseClass[]).map((licenseClass) => [licenseClass.id, licenseClass]));
+    this.frsLicenseClassId = [...this.licenseClasses.values()].find((licenseClass) => licenseClass.name === 'FRS')?.id;
   }
 
   /**
-   * Finds the spectrum band that contains the given frequency
+   * Finds the spectrum band that contains the given frequency.
+   *
+   * Channelized allocations (FRS, GMRS, weather) interleave in the same
+   * MHz range. An exact channel match is preferred over a surrounding
+   * band envelope so FRS interstitial frequencies are not treated as GMRS
+   * repeater inputs.
+   *
    * @param frequency The frequency in Hz to find the band for
    * @returns The spectrum band containing the frequency, or undefined if no band contains it
    */
   findBandByFrequency(frequency: number): SpectrumBand | undefined {
-    return this.bands.find((band) => frequency >= band.lowerFrequency && frequency <= band.upperFrequency);
+    const frequencyHz = Math.round(frequency);
+    const channelMatch = this.bands.find((band) => band.channels?.some((channel) => channel.frequency === frequencyHz));
+
+    if (channelMatch) {
+      return channelMatch;
+    }
+
+    return this.bands.find((band) => frequencyHz >= band.lowerFrequency && frequencyHz <= band.upperFrequency);
   }
 
   /**
@@ -38,7 +53,9 @@ export class BandPlan {
    * Returns whether the given license class may transmit on the frequency.
    *
    * Looks up the band that contains the frequency and checks that band's
-   * privileges list. Frequencies outside every known band return false.
+   * privileges list. FRS is a license-free service, so any band that
+   * includes the FRS privilege is allowed for every operator. Frequencies
+   * outside every known band return false.
    *
    * @param frequencyHz - Frequency in Hz
    * @param licenseClassId - Springfield license-class ID
@@ -51,6 +68,12 @@ export class BandPlan {
       return false;
     }
 
-    return (band.privileges as string[]).includes(licenseClassId);
+    const privileges = band.privileges as string[];
+
+    if (this.frsLicenseClassId && privileges.includes(this.frsLicenseClassId)) {
+      return true;
+    }
+
+    return privileges.includes(licenseClassId);
   }
 }

package/src/utils/schema-validator.ts

@@ -1,6 +1,7 @@
 import { Ajv } from 'ajv';
 import addFormats from 'ajv-formats';
 import radioProtocolSchema from '../schemas/radio-protocol-schema.json' with { type: 'json' };
+import radioMemoryMapSchema from '../schemas/radio-memory-map-schema.json' with { type: 'json' };
 
 export interface ValidationResult {
   valid: boolean;
@@ -24,8 +25,16 @@ export class SchemaValidator {
   }
 
   validateRadioProtocol(config: unknown): ValidationResult {
-    const validate = this.ajv.compile(radioProtocolSchema);
-    const valid = validate(config);
+    return this.validateAgainst(radioProtocolSchema, config);
+  }
+
+  validateMemoryMap(memoryMap: unknown): ValidationResult {
+    return this.validateAgainst(radioMemoryMapSchema, memoryMap);
+  }
+
+  private validateAgainst(schema: object, data: unknown): ValidationResult {
+    const validate = this.ajv.compile(schema);
+    const valid = validate(data);
 
     if (valid) {
       return { valid: true };