@springfield/ham-radio-utils 4.5.1 → 4.7.0

package/src/memory/memory-map-channels.ts

@@ -41,6 +41,90 @@ function radioToneToMapTone(tone: RadioTone | undefined): RadioMemoryMapToneValu
   return { mode: 'ctcss', value: Number(tone.tone) };
 }
 
+function noneTone(): RadioTone {
+  return { tone: 0, type: RadioToneType.CTCSS };
+}
+
+function isNoneTone(tone: RadioTone | undefined): boolean {
+  return !tone || !tone.tone;
+}
+
+function structHasField(struct: { fields: { id: string }[] } | undefined, fieldId: string): boolean {
+  return Boolean(struct?.fields.some((field) => field.id === fieldId));
+}
+
+function transmitFrequencyFromRecord(record: Record<string, RadioSettingValue>, bindings: NonNullable<RadioMemoryMap['channelBindings']>): number {
+  const receiveFrequency = Number(record[bindings.receiveFrequency] ?? 0);
+  const offsetOrTransmit = Number(record[bindings.transmitFrequency] ?? 0);
+
+  if (record.split === true) {
+    return offsetOrTransmit;
+  }
+
+  if (record.duplex === '+') {
+    return receiveFrequency + offsetOrTransmit;
+  }
+
+  if (record.duplex === '-') {
+    return receiveFrequency - offsetOrTransmit;
+  }
+
+  // Kenwood stores simplex as duplex "" and offset 0. Empty duplex is not an absolute TX frequency.
+  if (record.duplex === '') {
+    return receiveFrequency;
+  }
+
+  if (record.duplex === undefined) {
+    return bindings.transmitFrequency === bindings.receiveFrequency ? receiveFrequency : offsetOrTransmit;
+  }
+
+  return offsetOrTransmit;
+}
+
+function applyKenwoodToneMode(
+  record: Record<string, RadioSettingValue>,
+  bindings: NonNullable<RadioMemoryMap['channelBindings']>,
+): { receiveTone: RadioTone; transmitTone: RadioTone } {
+  const hasToneModeBits = 'tone_mode' in record || 'ctcss_mode' in record || 'dtcs_mode' in record;
+
+  if (!hasToneModeBits) {
+    return {
+      receiveTone: toneToRadioTone(record[bindings.receiveTone]),
+      transmitTone: toneToRadioTone(record[bindings.transmitTone]),
+    };
+  }
+
+  if (record.tone_mode === true) {
+    return { receiveTone: noneTone(), transmitTone: toneToRadioTone(record[bindings.transmitTone]) };
+  }
+
+  if (record.ctcss_mode === true) {
+    const tone = toneToRadioTone(record[bindings.receiveTone]);
+    return { receiveTone: tone, transmitTone: tone };
+  }
+
+  if (record.dtcs_mode === true) {
+    const tone = toneToRadioTone(record.dtcs_code);
+    return { receiveTone: tone, transmitTone: tone };
+  }
+
+  return { receiveTone: noneTone(), transmitTone: noneTone() };
+}
+
+function kenwoodUsedFlag(receiveFrequency: number, transmitFrequency: number): number {
+  const frequency = transmitFrequency || receiveFrequency;
+
+  if (frequency < 150_000_000) {
+    return 0;
+  }
+
+  if (frequency < 400_000_000) {
+    return 1;
+  }
+
+  return 2;
+}
+
 function asRecord(value: RadioSettingValue | undefined): Record<string, RadioSettingValue> | undefined {
   if (!value || typeof value !== 'object' || Array.isArray(value)) {
     return undefined;
@@ -64,31 +148,41 @@ export function bindingsToChannels(
 
   const records = settings[bindings.records];
   const names = bindings.names ? settings[bindings.names] : undefined;
+  const extras = bindings.extras ? settings[bindings.extras] : undefined;
   const recordItems = Array.isArray(records) ? records : [];
   const nameItems = Array.isArray(names) ? names : [];
+  const extraItems = Array.isArray(extras) ? extras : [];
   const nameField = bindings.nameField ?? 'name';
   const boundFieldIds = new Set([
     bindings.receiveFrequency,
     bindings.transmitFrequency,
     bindings.receiveTone,
     bindings.transmitTone,
+    nameField,
   ]);
 
   const channels: RadioProgrammedChannel[] = [];
 
   for (let index = 0; index < recordItems.length; index += 1) {
     const record = asRecord(recordItems[index]);
+    const extraRecord = asRecord(extraItems[index]);
+
+    if (bindings.extras && extraItems.length > 0 && extraRecord === undefined) {
+      continue;
+    }
 
     if (!record) {
       continue;
     }
 
     const nameRecord = asRecord(nameItems[index]);
-    const nameValue = nameRecord?.[nameField];
-    const name = typeof nameValue === 'string' ? nameValue : '';
+    const nameFromTable = typeof nameRecord?.[nameField] === 'string' ? nameRecord[nameField] : '';
+    const nameFromRecord = typeof record[nameField] === 'string' ? record[nameField] : '';
+    const name = nameFromTable || nameFromRecord;
 
     const receiveFrequency = Number(record[bindings.receiveFrequency] ?? 0);
-    const transmitFrequency = Number(record[bindings.transmitFrequency] ?? 0);
+    const transmitFrequency = transmitFrequencyFromRecord(record, bindings);
+    const tones = applyKenwoodToneMode(record, bindings);
 
     const channelSettings: RadioSettings = {};
 
@@ -100,6 +194,20 @@ export function bindingsToChannels(
       channelSettings[fieldId] = fieldValue;
     }
 
+    if (extraRecord) {
+      for (const [fieldId, fieldValue] of Object.entries(extraRecord)) {
+        if (fieldId.startsWith('_') || fieldId === 'used') {
+          continue;
+        }
+
+        channelSettings[fieldId] = fieldValue;
+      }
+
+      if (typeof extraRecord.lockout === 'boolean') {
+        channelSettings.skip = extraRecord.lockout ? 'S' : '';
+      }
+    }
+
     // Map Chirp lowpower index onto legacy transmitPower watts for UV-5R UI compatibility.
     if (typeof channelSettings.lowpower === 'number') {
       channelSettings.transmitPower = channelSettings.lowpower === 0 ? 5 : 1;
@@ -113,12 +221,16 @@ export function bindingsToChannels(
       channelSettings.skip = channelSettings.scan ? '' : 'S';
     }
 
+    if (typeof channelSettings.skip === 'boolean') {
+      channelSettings.skip = channelSettings.skip ? 'S' : '';
+    }
+
     const radioChannel: RadioChannel = {
       name,
       receiveFrequency: Frequency(receiveFrequency),
       transmitFrequency: Frequency(transmitFrequency),
-      receiveTone: toneToRadioTone(record[bindings.receiveTone]),
-      transmitTone: toneToRadioTone(record[bindings.transmitTone]),
+      receiveTone: tones.receiveTone,
+      transmitTone: tones.transmitTone,
     };
 
     channels.push({
@@ -149,6 +261,10 @@ export function settingsWithoutChannels(memoryMap: RadioMemoryMap, settings: Rad
     delete next[bindings.names];
   }
 
+  if (bindings.extras) {
+    delete next[bindings.extras];
+  }
+
   return next;
 }
 
@@ -164,11 +280,13 @@ export function programToChannelSettings(memoryMap: RadioMemoryMap, program: Rad
 
   const recordsStruct = memoryMap.structs.find((struct) => struct.id === bindings.records);
   const namesStruct = bindings.names ? memoryMap.structs.find((struct) => struct.id === bindings.names) : undefined;
+  const extrasStruct = bindings.extras ? memoryMap.structs.find((struct) => struct.id === bindings.extras) : undefined;
   const count = recordsStruct?.count ?? 0;
   const nameField = bindings.nameField ?? 'name';
 
   const records: RadioSettingValue[] = Array.from({ length: count }, () => null);
   const names: RadioSettingValue[] = Array.from({ length: count }, () => null);
+  const extras: RadioSettingValue[] = Array.from({ length: count }, () => null);
 
   for (const programmed of program.channels) {
     const index = programmed.channelNumber;
@@ -183,13 +301,67 @@ export function programToChannelSettings(memoryMap: RadioMemoryMap, program: Rad
 
     const channel = programmed.radioChannel;
     const channelSettings = programmed.settings ?? {};
+    const receiveFrequency = Number(channel.receiveFrequency);
+    const transmitFrequency = Number(channel.transmitFrequency);
+    let offset = transmitFrequency;
+    let duplex: RadioSettingValue = '';
+    let split = false;
+
+    if (transmitFrequency === receiveFrequency) {
+      offset = 0;
+      duplex = '';
+    } else if (transmitFrequency > receiveFrequency) {
+      offset = transmitFrequency - receiveFrequency;
+      duplex = '+';
+    } else {
+      offset = receiveFrequency - transmitFrequency;
+      duplex = '-';
+    }
+
+    if (channelSettings.split === true) {
+      split = true;
+      duplex = '';
+      offset = transmitFrequency;
+    }
+
+    const usesOffset =
+      'duplex' in channelSettings || extrasStruct || structHasField(recordsStruct, 'duplex');
+    const usesKenwoodToneBits =
+      'tone_mode' in channelSettings ||
+      'ctcss_mode' in channelSettings ||
+      extrasStruct ||
+      structHasField(recordsStruct, 'tone_mode') ||
+      structHasField(recordsStruct, 'ctcss_mode');
+
     const record: Record<string, RadioSettingValue> = {
-      [bindings.receiveFrequency]: channel.receiveFrequency,
-      [bindings.transmitFrequency]: channel.transmitFrequency,
+      [bindings.receiveFrequency]: receiveFrequency,
+      [bindings.transmitFrequency]: usesOffset ? offset : transmitFrequency,
       [bindings.receiveTone]: radioToneToMapTone(channel.receiveTone),
       [bindings.transmitTone]: radioToneToMapTone(channel.transmitTone),
     };
 
+    if (usesOffset) {
+      record.duplex = typeof channelSettings.duplex === 'string' ? channelSettings.duplex : duplex;
+      record.split = typeof channelSettings.split === 'boolean' ? channelSettings.split : split;
+      record.offset = offset;
+    }
+
+    if (usesKenwoodToneBits) {
+      record.tone_mode = false;
+      record.ctcss_mode = false;
+      record.dtcs_mode = false;
+      record.cross_mode = false;
+
+      if (channel.transmitTone?.type === RadioToneType.DCS || channel.receiveTone?.type === RadioToneType.DCS) {
+        record.dtcs_mode = true;
+        record.dtcs_code = radioToneToMapTone(channel.transmitTone?.type === RadioToneType.DCS ? channel.transmitTone : channel.receiveTone);
+      } else if (!isNoneTone(channel.receiveTone) && !isNoneTone(channel.transmitTone)) {
+        record.ctcss_mode = true;
+      } else if (!isNoneTone(channel.transmitTone)) {
+        record.tone_mode = true;
+      }
+    }
+
     for (const [key, value] of Object.entries(channelSettings)) {
       if (key === 'transmitPower') {
         record.lowpower = value === 5 || value === 4 || value === 0 ? 0 : 1;
@@ -198,11 +370,13 @@ export function programToChannelSettings(memoryMap: RadioMemoryMap, program: Rad
 
       if (key === 'mode') {
         record.wide = value === 'FM';
+        record.mode = value;
         continue;
       }
 
       if (key === 'skip') {
         record.scan = value !== 'S';
+        record.skip = value === 'S';
         continue;
       }
 
@@ -222,7 +396,20 @@ export function programToChannelSettings(memoryMap: RadioMemoryMap, program: Rad
     }
 
     records[index] = record;
-    names[index] = { [nameField]: channel.name ?? '' };
+
+    if (namesStruct) {
+      names[index] = { [nameField]: channel.name ?? '' };
+    } else {
+      record[nameField] = channel.name ?? '';
+    }
+
+    if (extrasStruct) {
+      extras[index] = {
+        used: kenwoodUsedFlag(receiveFrequency, transmitFrequency),
+        lockout: channelSettings.skip === 'S' || channelSettings.lockout === true,
+        group: typeof channelSettings.group === 'number' ? channelSettings.group : 0,
+      };
+    }
   }
 
   const bag: RadioSettings = { ...program.settings, [bindings.records]: records };
@@ -231,6 +418,10 @@ export function programToChannelSettings(memoryMap: RadioMemoryMap, program: Rad
     bag[bindings.names] = names;
   }
 
+  if (bindings.extras && extrasStruct) {
+    bag[bindings.extras] = extras;
+  }
+
   return bag;
 }
 

package/src/memory/memory-map-codec.ts

@@ -78,6 +78,52 @@ function writeByte(contents: Uint8Array, offset: number, value: number): void {
   contents[offset] = value & 0xff;
 }
 
+function decodeInteger(raw: number | number[]): number {
+  if (typeof raw === 'number') {
+    return raw;
+  }
+
+  let value = 0;
+
+  for (let index = 0; index < raw.length; index += 1) {
+    value += raw[index] * 256 ** index;
+  }
+
+  return value;
+}
+
+function encodeInteger(value: RadioSettingValue, byteLength: number): number[] {
+  let numeric = typeof value === 'number' ? value : 0;
+  const bytes: number[] = [];
+
+  for (let index = 0; index < byteLength; index += 1) {
+    bytes.push(numeric & 0xff);
+    numeric = Math.floor(numeric / 256);
+  }
+
+  return bytes;
+}
+
+/**
+ * Radio address of repeated-struct instance `index`, including Kenwood-style
+ * grouped stride (N records + pad bytes per clone block).
+ */
+export function structInstanceAddress(struct: RadioMemoryMapStruct, instanceIndex: number): number {
+  const seek = parseSeekAddress(struct.seek);
+  const stride = struct.stride ?? 0;
+  const groupSize = struct.groupSize;
+
+  if (!groupSize) {
+    return seek + instanceIndex * stride;
+  }
+
+  const groupPad = struct.groupPad ?? 0;
+  const groupIndex = Math.floor(instanceIndex / groupSize);
+  const indexInGroup = instanceIndex % groupSize;
+
+  return seek + groupIndex * (stride * groupSize + groupPad) + indexInGroup * stride;
+}
+
 function decodeRawValue(kind: RadioMemoryMapValueKind | undefined, raw: number | number[]): RadioSettingValue {
   if (!kind) {
     return typeof raw === 'number' ? raw : raw;
@@ -85,7 +131,7 @@ function decodeRawValue(kind: RadioMemoryMapValueKind | undefined, raw: number |
 
   switch (kind.kind) {
     case 'integer':
-      return typeof raw === 'number' ? raw : raw[0];
+      return decodeInteger(raw);
     case 'boolean':
       return (typeof raw === 'number' ? raw : raw[0]) !== 0;
     case 'enum': {
@@ -183,6 +229,16 @@ function decodeRawValue(kind: RadioMemoryMapValueKind | undefined, raw: number |
       const code = kind.values[index] ?? 0;
       return { mode: 'dcs', code, polarity };
     }
+    case 'ctcss-index': {
+      const index = decodeInteger(raw);
+      const tenths = kind.values[index] ?? kind.values[0] ?? 0;
+      return { mode: 'ctcss', value: tenths };
+    }
+    case 'dcs-index': {
+      const index = decodeInteger(raw);
+      const code = kind.values[index] ?? 0;
+      return { mode: 'dcs', code, polarity: 'N' };
+    }
     default: {
       const exhaustive: never = kind;
       return exhaustive;
@@ -203,8 +259,7 @@ function encodeRawValue(kind: RadioMemoryMapValueKind | undefined, value: RadioS
 
   switch (kind.kind) {
     case 'integer': {
-      bytes[0] = typeof value === 'number' ? value & 0xff : 0;
-      return bytes;
+      return encodeInteger(value, byteLength);
     }
     case 'boolean': {
       bytes[0] = value ? 1 : 0;
@@ -217,9 +272,10 @@ function encodeRawValue(kind: RadioMemoryMapValueKind | undefined, value: RadioS
     }
     case 'ascii': {
       const text = typeof value === 'string' ? value : '';
+      const pad = kind.pad ?? 0xff;
 
       for (let index = 0; index < byteLength; index += 1) {
-        bytes[index] = index < text.length ? (text.codePointAt(index) ?? 0xff) : 0xff;
+        bytes[index] = index < text.length ? (text.codePointAt(index) ?? pad) : pad;
       }
 
       return bytes;
@@ -309,6 +365,18 @@ function encodeRawValue(kind: RadioMemoryMapValueKind | undefined, value: RadioS
       bytes[1] = (rawValue >> 8) & 0xff;
       return bytes;
     }
+    case 'ctcss-index': {
+      const tone = value && typeof value === 'object' && !Array.isArray(value) ? (value as { mode?: string; value?: number }) : undefined;
+      const tenths = tone?.mode === 'ctcss' && typeof tone.value === 'number' ? tone.value : 0;
+      const index = kind.values.indexOf(tenths);
+      return encodeInteger(index >= 0 ? index : 0, byteLength);
+    }
+    case 'dcs-index': {
+      const tone = value && typeof value === 'object' && !Array.isArray(value) ? (value as { mode?: string; code?: number }) : undefined;
+      const code = tone?.mode === 'dcs' && typeof tone.code === 'number' ? tone.code : 0;
+      const index = kind.values.indexOf(code);
+      return encodeInteger(index >= 0 ? index : 0, byteLength);
+    }
     default: {
       const exhaustive: never = kind;
       return exhaustive;
@@ -317,6 +385,10 @@ function encodeRawValue(kind: RadioMemoryMapValueKind | undefined, value: RadioS
 }
 
 function fieldByteLength(field: RadioMemoryMapField): number {
+  if (field.type === 'u32') {
+    return 4;
+  }
+
   if (field.type === 'u16') {
     return 2;
   }
@@ -433,7 +505,7 @@ function decodeStruct(
   memoryConfig: RadioMemoryConfig,
   instanceIndex: number,
 ): Record<string, RadioSettingValue> {
-  const base = parseSeekAddress(struct.seek) + instanceIndex * (struct.stride ?? 0);
+  const base = structInstanceAddress(struct, instanceIndex);
   const result: Record<string, RadioSettingValue> = {};
   let radioAddress = base;
   let bitCursor: BitfieldCursor | undefined;
@@ -465,7 +537,7 @@ function decodeStruct(
       bytes.push(readByte(contents, bufferOffsetFor(radioAddress + index, memoryConfig, contents)));
     }
 
-    if (field.type === 'u16') {
+    if (field.type === 'u16' || field.type === 'u32') {
       if (!field.reserved) {
         result[field.id] = decodeRawValue(field.value ?? { kind: 'integer' }, bytes);
       }
@@ -486,7 +558,7 @@ function encodeStruct(
   memoryConfig: RadioMemoryConfig,
   instanceIndex: number,
 ): void {
-  const base = parseSeekAddress(struct.seek) + instanceIndex * (struct.stride ?? 0);
+  const base = structInstanceAddress(struct, instanceIndex);
   let radioAddress = base;
   let bitCursor: BitfieldCursor | undefined;
   let bitStartAddress = base;
@@ -525,18 +597,12 @@ function encodeStruct(
 
     const settingValue = values[field.id];
 
-    if (field.type === 'u16') {
-      const encoded = encodeRawValue(field.value ?? { kind: 'integer' }, settingValue ?? 0, 2);
-      let value = 0;
+    if (field.type === 'u16' || field.type === 'u32') {
+      const encoded = encodeRawValue(field.value ?? { kind: 'integer' }, settingValue ?? 0, length);
 
-      if (field.value?.kind === 'tone') {
-        value = (encoded[0] & 0xff) | ((encoded[1] & 0xff) << 8);
-      } else {
-        value = (encoded[0] ?? 0) & 0xffff;
+      for (let index = 0; index < length; index += 1) {
+        writeByte(contents, bufferOffsetFor(radioAddress + index, memoryConfig, contents), encoded[index] ?? 0);
       }
-
-      writeByte(contents, bufferOffsetFor(radioAddress, memoryConfig, contents), value & 0xff);
-      writeByte(contents, bufferOffsetFor(radioAddress + 1, memoryConfig, contents), (value >> 8) & 0xff);
     } else {
       const encoded = encodeRawValue(field.value, settingValue ?? (field.value?.kind === 'ascii' ? '' : 0), length);
 
@@ -563,7 +629,7 @@ function isStructInstanceEmpty(
     return false;
   }
 
-  const base = parseSeekAddress(struct.seek) + instanceIndex * (struct.stride ?? 0);
+  const base = structInstanceAddress(struct, instanceIndex);
   const firstByte = readByte(contents, bufferOffsetFor(base, memoryConfig, contents));
   return firstByte === struct.emptyWhen.equals;
 }
@@ -574,7 +640,7 @@ function clearStructInstance(
   memoryConfig: RadioMemoryConfig,
   instanceIndex: number,
 ): void {
-  const base = parseSeekAddress(struct.seek) + instanceIndex * (struct.stride ?? 0);
+  const base = structInstanceAddress(struct, instanceIndex);
   const length = struct.stride ?? 16;
 
   for (let index = 0; index < length; index += 1) {

package/src/memory/memory-map-radio-codec.ts

@@ -0,0 +1,96 @@
+import type {
+  RadioCodec,
+  RadioMemory,
+  RadioMemoryConfig,
+  RadioMemoryMap,
+  RadioModelId,
+  RadioProgram,
+} from '@springfield/ham-radio-api';
+import type { ILogLayer } from 'loglayer';
+import { decodeRadioProgram, encodeRadioProgram } from './memory-map-channels.js';
+
+/**
+ * Compute the sparse image size that covers every configured memory segment.
+ */
+export function memoryImageSize(memoryConfig: RadioMemoryConfig): number {
+  const ends = Object.values(memoryConfig.segments).map((segment) => segment.endAddress);
+  return Math.max(...ends) + 1;
+}
+
+/**
+ * Create a Chirp-like empty EEPROM image filled with 0xFF.
+ */
+export function createEmptyMemoryImage(totalSize: number): Uint8Array {
+  const memory = new Uint8Array(totalSize);
+  memory.fill(0xff);
+  return memory;
+}
+
+export interface MemoryMapRadioCodecOptions {
+  radioModel: RadioModelId;
+  memoryMap: RadioMemoryMap;
+  memoryConfig: RadioMemoryConfig;
+  logger?: ILogLayer;
+}
+
+/**
+ * Generic RadioCodec driven entirely by a JSON memory map + memoryConfig.
+ * Radio modules that ship DSL JSON do not need TypeScript codecs.
+ */
+export class MemoryMapRadioCodec implements RadioCodec {
+  private readonly radioModel: RadioModelId;
+  private readonly memoryMap: RadioMemoryMap;
+  private readonly memoryConfig: RadioMemoryConfig;
+  private readonly logger: ILogLayer | undefined;
+
+  constructor(options: MemoryMapRadioCodecOptions) {
+    this.radioModel = options.radioModel;
+    this.memoryMap = options.memoryMap;
+    this.memoryConfig = options.memoryConfig;
+    this.logger = options.logger;
+  }
+
+  decode(memory: RadioMemory): RadioProgram {
+    try {
+      return decodeRadioProgram(this.memoryMap, memory.contents, this.memoryConfig);
+    } catch (error) {
+      this.logger?.withError(error).warn('Failed to decode radio program from memory map');
+      return { channels: [], settings: {} };
+    }
+  }
+
+  encode(program: RadioProgram, memory: RadioMemory): RadioMemory {
+    const totalSize = memoryImageSize(this.memoryConfig);
+    const contents =
+      memory.contents.length > 0 ? new Uint8Array(memory.contents) : createEmptyMemoryImage(totalSize);
+
+    if (contents.length < totalSize) {
+      const expanded = createEmptyMemoryImage(totalSize);
+      expanded.set(contents);
+      try {
+        encodeRadioProgram(this.memoryMap, program, expanded, this.memoryConfig);
+      } catch (error) {
+        this.logger?.withError(error).warn('Failed to encode radio program into memory map');
+      }
+
+      this.logger?.debug(`Memory size: ${expanded.length} bytes`);
+      return { contents: expanded, radioModel: this.radioModel };
+    }
+
+    try {
+      encodeRadioProgram(this.memoryMap, program, contents, this.memoryConfig);
+    } catch (error) {
+      this.logger?.withError(error).warn('Failed to encode radio program into memory map');
+    }
+
+    this.logger?.debug(`Memory size: ${contents.length} bytes`);
+    return { contents, radioModel: this.radioModel };
+  }
+}
+
+/**
+ * Create a memory-map codec from hydrated radio config fields.
+ */
+export function createMemoryMapCodec(options: MemoryMapRadioCodecOptions): RadioCodec {
+  return new MemoryMapRadioCodec(options);
+}

package/src/memory/memory-map-ui.ts

@@ -55,6 +55,10 @@ export function collectMemoryMapUiFields(memoryMap: RadioMemoryMap): RadioMemory
     if (memoryMap.channelBindings.names) {
       channelStructIds.add(memoryMap.channelBindings.names);
     }
+
+    if (memoryMap.channelBindings.extras) {
+      channelStructIds.add(memoryMap.channelBindings.extras);
+    }
   }
 
   for (const struct of memoryMap.structs) {
@@ -105,6 +109,7 @@ export function collectChannelMemoryMapUiFields(memoryMap: RadioMemoryMap): Radi
   }
 
   const struct = memoryMap.structs.find((entry) => entry.id === bindings.records);
+  const extrasStruct = bindings.extras ? memoryMap.structs.find((entry) => entry.id === bindings.extras) : undefined;
 
   if (!struct) {
     return [];
@@ -113,18 +118,24 @@ export function collectChannelMemoryMapUiFields(memoryMap: RadioMemoryMap): Radi
   const boundIds = channelBoundFieldIds(memoryMap);
   const fields: RadioMemoryMapUiField[] = [];
 
-  for (const field of struct.fields) {
-    if (field.reserved || !field.ui || boundIds.has(field.id)) {
+  for (const source of [struct, extrasStruct]) {
+    if (!source) {
       continue;
     }
 
-    fields.push({
-      path: field.id,
-      structId: struct.id,
-      fieldId: field.id,
-      ui: field.ui,
-      value: field.value,
-    });
+    for (const field of source.fields) {
+      if (field.reserved || !field.ui || boundIds.has(field.id)) {
+        continue;
+      }
+
+      fields.push({
+        path: field.id,
+        structId: source.id,
+        fieldId: field.id,
+        ui: field.ui,
+        value: field.value,
+      });
+    }
   }
 
   return fields;