HamBench

Appearance

Why Registry? ​

The Ham Radio Registry addresses the fragmentation and complexity of radio programming by providing a unified, extensible platform for discovering and managing radio configurations.

The Problem ​

1. Fragmented Ecosystem ​

Current radio programming solutions are scattered across:

  • Proprietary software from manufacturers
  • Community-developed tools
  • Platform-specific applications
  • Inconsistent APIs and data formats

2. Complex Integration ​

Developers face challenges:

  • Learning multiple radio protocols
  • Implementing custom codecs for each radio
  • Managing different data formats
  • Handling version compatibility issues

3. Limited Extensibility ​

Existing solutions often:

  • Lock users into specific platforms
  • Don't support new radio models easily
  • Require custom development for each radio
  • Lack standardized interfaces

The Solution ​

The Ham Radio Registry provides:

1. Unified Discovery ​

typescript
// Discover all available radio configurations
const registry = new RadioConfigRegistry();
const radios = await registry.discoverConfigurations();

// Find specific radio models
const baofengRadios = await registry.getConfigurationsByManufacturer('Baofeng');

2. Standardized Interfaces ​

typescript
// Consistent API across all radios
const codec = await registry.getCodec({ model: 'baofeng-uv5r', manufacturer: 'Baofeng' });
const program = codec.decode(memory);
const encodedMemory = codec.encode(program);

3. Extensible Architecture ​

radio-module-manufacturer/
├── configs/
├── src/shared/
│   ├── schemas/
│   └── memory-maps/
└── package.json

Benefits ​

For Developers ​

  • Reduced Complexity: Single API for all radios
  • Faster Development: Reusable components and patterns
  • Better Testing: Standardized test frameworks
  • Easier Maintenance: Consistent code structure

For Users ​

  • Universal Compatibility: Works with any supported radio
  • Better Software: More developers can create tools
  • Future-Proof: New radios automatically supported
  • Open Ecosystem: No vendor lock-in

For Manufacturers ​

  • Wider Adoption: More software supports their radios
  • Reduced Support: Standardized programming interfaces
  • Community Growth: Active developer ecosystem
  • Innovation: Third-party enhancements

Architecture Overview ​

The registry consists of several key components:

1. Configuration Discovery ​

Automatically discovers radio modules from installed packages or the desktop catalog:

typescript
const modules = await registry.listInstalledPlugins();
const configs = await registry.discoverConfigurations();

2. Shared Component Management ​

Manages reusable codecs, schemas, and protocols:

typescript
const schema = await sharedComponentManager.loadSchema('src/shared/schemas/channel-schema.json');
const memoryMap = await sharedComponentManager.loadMemoryMap('src/shared/memory-maps/uv5r-settings.json');

3. Memory-map codec ​

HamBench builds a codec from the module's JSON map. Modules do not ship a factory.

typescript
import { createMemoryMapCodec } from '@springfield/ham-radio-utils';

const codec = createMemoryMapCodec({
  radioModel: config.id.model,
  memoryMap,
  memoryConfig: config.memoryConfig,
  logger,
});

Use Cases ​

1. Radio Programming Software ​

typescript
// Universal radio programmer
class UniversalProgrammer {
  async programRadio(radioModel: string, program: RadioProgram) {
    const codec = await registry.getCodec(radioModel);
    const memory = codec.encode(program);
    await this.writeToRadio(memory);
  }
}

2. Configuration Management ​

typescript
// Backup and restore radio configurations
class ConfigManager {
  async backupRadio(radioModel: string) {
    const memory = await this.readFromRadio();
    const codec = await registry.getCodec(radioModel);
    const program = codec.decode(memory);
    await this.saveConfiguration(program);
  }
}

3. Radio Analysis Tools ​

typescript
// Analyze radio configurations
class RadioAnalyzer {
  async analyzeConfiguration(radioModel: string, memory: RadioMemory) {
    const codec = await registry.getCodec(radioModel);
    const program = codec.decode(memory);
    return this.generateReport(program);
  }
}

Getting Started ​

1. Install the Registry ​

bash
yarn add @springfield/ham-radio-registry

2. Install Radio Modules ​

Radio modules are JSON zips from GitHub Releases, not npm packages. The desktop app installs them from the official catalog.

3. Use the API ​

typescript
import { RadioConfigRegistry } from '@springfield/ham-radio-registry';

const registry = new RadioConfigRegistry();
const radios = await registry.discoverConfigurations();
console.log(`Found ${radios.length} radio configurations`);

Future Vision ​

The registry is designed to grow and evolve:

1. Expanded Radio Support ​

  • More manufacturers and models
  • Legacy radio support
  • Custom radio definitions

2. Enhanced Features ​

  • Cloud configuration storage
  • Configuration sharing
  • Advanced validation

3. Developer Tools ​

  • Configuration generators
  • Testing frameworks
  • Documentation tools

4. Integration Ecosystem ​

  • Desktop applications
  • Mobile apps
  • Web interfaces
  • CLI tools

Conclusion ​

The Ham Radio Registry transforms radio programming from a fragmented, complex process into a unified, extensible ecosystem. By providing standardized interfaces and reusable components, it enables developers to create better software while making radio programming more accessible to users.

Whether you're building radio programming software, managing configurations, or developing new radio modules, the registry provides the foundation for a more connected and innovative ham radio community.