@bytesnz

Jack Farley, Computer Engineer

I am currently working on two projects using structured binary messages: one is decoding messages from and sending messages to Tait Communications digital radios; the other is receiving binary data over Iridium short burst data (SBD) messages.

In the case of the Tait radios, the messages are read from the serial port of the radio as ASCII-hexadecimal-encoded MAP27 messages (the mobile access protocol for MPT-1327 radios) ended with a carriage return (CR).

Below are some example messages, with spaces added for readability and the carriage returned represented by 0x0d (its ASCII hexadecimal value).

a4 04 05 a0 00 00 0x0d
b2 06 9e ff 0x0d
b2 07 9e ff 0x0d
b2 06 9e ff 0x0d
c5 04 05 a0 00 00 0x0d
b5 41 55 00 00 0x0d
0b 04 05 a0 00 01 0x0d
0b 00 00 00 00 00 0x0d

My project for this data is to poll the radios for their GPS location and to log calls as they come in into an incident management system I am working on for my urban search and rescue team. The data will be read from radios in our communications caravan, decoded and inserted into an ArangoDB database. As the web app is written in SvelteKit and NodeJS, I thought I would continue the trend and write the serial listener and decoder in NodeJS as well.

The Iridium SBD project involves sending data from a microcontroller connected to an Iridium 9602 and receive them using DirectIP (where the SBD messages are forwarded to server over a TCP connection). The data will be a data format split over multiple SBD messages with packet header to ensure they are processed in the correct order.

I had a look around for binary decoding libraries, but couldn't find one that quite did everything I wanted, so I started creating a schema definition for the messages I would be receiving

const standardMAP27Structure = [
  { // First byte is the message type
    type: 'uint8',
    id: 'messageType',
    enums: [
      {
        value: 0x81,
        label: 'SST'
      }
    ]
  },
  { // Choose the rest of the bytes structure based on the message type
    type: 'map',
    key: 'messageType',
    structures: {
      0x81: [ // SST Message structure
        {
          bytes: 2,
          type: 'bits',
          parts: [
            {
              bits: 1
            },
            {
              bits: 7,
              id: 'PFIX1'
            }
          ]
        },
        {
          // TODO First 3 bits are fixed at 0 0 0
          type: 'bytes',
          bytes: 2,
          id: 'IDENT1'
        },
        {
          type: 'bits',
          parts: [
            {
              bits: 4,
              id: 'ADESC'
            },
            {
              bits: 4,
              id: 'LENGTH'
            }
          ]
        },
        {
          type: 'variable',
          length: 'LENGTH',
          id: 'address'
        },
        {
          type: 'bits',

This array notion allowed me to specify structures that changed based on values within the binary data. Once I had created the code (the binary-decoder library) to decode the binary based on the structure arrays, it gave the decoded data in a object.

{
  decodedMessage: {
    messageType: { value: 129, label: 'SST' },
    PFIX1: 4,
    IDENT1: 1448,
    ADESC: 0,
    LENGTH: 0,
    CODING: { value: 3, label: 'NMEA' },
    NLB: 7,
    encrypted: 0,
    northSouth: 0,
    EastWest: 1,
    Quality: 1,
    speed: 0,
    heading: 0,
    latDegrees: 41,
    latMinutes: 7,
    latFraction: 5263,
    longDegrees: 175,
    longMinutes: 4,
    longFraction: 6439,
    utcHours: 9,
    utcMinutes: 24,
    utcSeconds: 24
  },
  nextByte: 24
}

I was able to easily create a structure for the DirectIP messages as well.

/* @type {import('binary-decoder').MessageFormat} */
export default [
  {
    type: 'uint8',
    id: 'protocolVersion'
  },
  {
    type: 'uint16',
    id: 'messageLength'
  },
  {
    type: 'repeat',
    id: 'data',
    key: 'elementId',
    asObject: 'elementId',
    structure: [
      {
        type: 'uint8',
        id: 'elementId',
        enum: [
          {
            value: 1,
            label: 'MO Header IEI',
            key: 'moHeader'
          },
          {
            value: 2,
            label: 'MO Payload IEI',
            key: 'moPayload'
          },
          {
            value: 3,
            label: 'MO Location Information IEI',
            key: 'moLocation'
          },
          {
            value: 0x41,
            label: 'MT Header IEI',
            key: 'mtHeader'
          },
          {
            value: 0x42,
            label: 'MT Payload IEI',
            key: 'mtPayload'
          },
          {
            value: 0x44,
            label: 'MT Confirmation Message IEI',
            key: 'mtConfirmation'
          }
        ]
      },
...

(the full structure is in sbd.js)

I then wrapped it in a NodeJS Net Server, made it "emit" message events whenever it received a new message and hey presto a DirectIP receiver server.

The MAP27 protocol is a little more complex than the DirectIP messages, so I am still working on implementing it, but watch this space.