CHIRP

#!/usr/bin/env python

# This script requires Python 3.

# $ pip install pyserial

# $ python gm30ctl.py

import io

import struct

import argparse

import typing as t

from pathlib import Path

import serial

def send_ack(port):

    port.write(bytes([0x06]))

    port.flush()

def receive_ack(port):

    response = port.read(1)

    assert response == bytes([0x06])

def read_memory(port, address: int, size: int) -> bytes:

    # Request: 0x52 ADDRx2 0x00 SIZEx1

    request = bytearray([0x52, 0x00, 0x00, 0x00, 0x00])

    struct.pack_into('<HxB', request, 1, address, size)

    port.write(request)

    port.flush()

    # Response: 0x57 ADDRx2 0x00 SIZEx1 [DATAx1 .. DATAx1]

    expected_response_size = 5 + size

    response = port.read(expected_response_size)

    assert len(response) == expected_response_size

    assert response[0] == 0x57

    assert response[1:5] == request[1:5]

    send_ack(port)

    receive_ack(port)

    return response[5:]

def write_memory(port, data: bytes, address: int):

    # Request: 0x57 ADDRx2 0x00 SIZEx1 [DATAx1 .. DATAx2]

    request = bytearray([0x57, 0x00, 0x00, 0x00, 0x00])

    struct.pack_into('<HxB', request, 1, address, len(bytes))

    port.write(request)

    port.write(data)

    port.flush()

    # Response

    receive_ack(port)

def read_memory_bytes(port, addresses: t.List[int]) -> bytes:

    buffer = io.BytesIO()

    for address in addresses:

        buffer.write(read_memory(port, address, 0x01))

    buffer.seek(0)

    return buffer.read()

def read_memory_range(port, address: int, size: int, chunk_size: int = 0x40) -> bytes:

    buffer = io.BytesIO()

    read_address = address

    read_bytes_remaining = size

    while read_bytes_remaining > 0:

        read_size = min(chunk_size, read_bytes_remaining)

        buffer.write(read_memory(port, read_address, read_size))

        read_bytes_remaining -= read_size

        read_address += read_size

    buffer.seek(0)

    return buffer.read()

def write_memory_range(port, data: bytes, address: int, chunk_size: int = 0x40):

    write_counter = 0

    while write_counter < len(bytes):

        write_size = min(chunk_size, len(bytes) - write_counter)

        write_data = data[write_counter:write_counter + write_size]

        write_memory(port, address + write_counter, write_data)

        write_counter += write_size

def common_init(port):

    # PSEARCH

    port.write(b'PSEARCH')

    port.flush()

    receive_ack(port)

    response = port.read(7)

    assert response.decode() == 'P13GMRS'

    # XXX

    port.write(b'PASSSTA')

    port.flush()

    response = port.read(3)

    assert response[:1].decode() == 'P'

    assert response[1] == 0x00

    assert response[2] == 0x00

    # XXX

    port.write(b'SYSINFO')

    port.flush()

    receive_ack(port)

    # XXX

    port.write(bytes([0x56, 0x00, 0x00, 0x0A, 0x0D]))

    port.flush()

    response = port.read(3)

    assert response == bytes([0x56, 0x0D, 0x0A])

    response = port.read(10)

    print(' '.join([f"0x{b:x}" for b in response]))

    # assert response == bytes([

    #     0x0A,

    #     0x0D,

    #     0x00,

    #     0x00,

    #     0x00,

    #     0x11,

    #     0xCA,

    #     0x00,

    #     0x08,

    #     0x01])

    send_ack(port)

    receive_ack(port)

    # XXX

    port.write(bytes([0x56, 0x00, 0x10, 0x0A, 0x0D]))

    port.flush()

    response = port.read(3)

    assert response == bytes([0x56, 0x0D, 0x0A])

    response = port.read(10)

    print(' '.join([f"0x{b:x}" for b in response]))

    # assert response == bytes([

    #     0x0A,

    #     0x0D,

    #     0x00,

    #     0x00,

    #     0x00,

    #     0x11,

    #     0xCA,

    #     0x00,

    #     0x08,

    #     0x01])

    send_ack(port)

    receive_ack(port)

    # XXX

    port.write(bytes([0x56, 0x00, 0x20, 0x0A, 0x0D]))

    port.flush()

    response = port.read(3)

    assert response == bytes([0x56, 0x0D, 0x0A])

    response = port.read(10)

    print(' '.join([f"0x{b:x}" for b in response]))

    # assert response == bytes([

    #     0x0A,

    #     0x0D,

    #     0x00,

    #     0x00,

    #     0x00,

    #     0x11,

    #     0xCA,

    #     0x00,

    #     0x08,

    #     0x01])

    send_ack(port)

    receive_ack(port)

    # XXX

    port.write(bytes([0x56, 0x00, 0x00, 0x00, 0x0A]))

    port.flush()

    response = port.read(3)

    print(' '.join([f"0x{b:x}" for b in response]))

    # assert response == bytes([0x56, 0x0D, 0x0A])

    response = port.read(3)

    print(' '.join([f"0x{b:x}" for b in response]))

    # assert response == bytes([0x56, 0x0A, 0x08])

    response = port.read(5)

    print(' '.join([f"0x{b:x}" for b in response]))

    # assert response == bytes([0x00, 0x10, 0x00, 0x00, 0xFF])

    send_ack(port)

    receive_ack(port)

    # XXX

    port.write(bytes([0xFF, 0xFF, 0xFF, 0xFF, 0x0C]))

    port.flush()

    port.write(b'P13GMRS')

    port.flush()

    receive_ack(port)

    # XXX

    port.write(bytes([0x02]))

    port.flush()

    response = port.read(8)

    assert response == bytes([0xFF] * 8)

    send_ack(port)

    receive_ack(port)

    # XXX

    data = read_memory_bytes(port, [

        0x1FFF,

        0x2FFF,

        0x3FFF,

        0x4FFF,

        0x5FFF,

        0x6FFF,

        0x7FFF,

        0x8FFF,

        0x9FFF,

        0xAFFF,

        0xBFFF,

        0xCFFF,

        0xDFFF,

        0xEFFF,

        0xFFFF])

    with open('region_1FFF.bin', 'wb') as output_file:

        output_file.write(data)

def read(device_path: Path):

    with serial.Serial(

        port=str(device_path),

        baudrate=57600,

        bytesize=serial.EIGHTBITS,

        parity=serial.PARITY_NONE,

        stopbits=serial.STOPBITS_ONE,

        xonxoff=False,

        rtscts=True,

        dsrdtr=True

    ) as port:

        common_init(port)

        # XXX data file 0x2000, ???

        data = read_memory_range(port, 0x1000, 0xFC0, 0x40)

        with open('region_1000.bin', 'wb') as output_file:

            output_file.write(data)

        # XXX data file 0x3000 with some differences, ???

        data = read_memory_range(port, 0xF000, 0xFC0, 0x40)

        with open('region_F000.bin', 'wb') as output_file:

            output_file.write(data)

        # XXX data file 0x4000, channel names?

        data = read_memory_range(port, 0x3000, 0xFC0, 0x40)

        with open('region_3000.bin', 'wb') as output_file:

            output_file.write(data)

        # XXX data file 0x5000, general settings?

        data = read_memory_range(port, 0xB000, 0xFC0, 0x40)

        with open('region_B000.bin', 'wb') as output_file:

            output_file.write(data)

        # XXX data file 0x6000, ???

        data = read_memory_range(port, 0xD000, 0xFC0, 0x40)

        with open('region_D000.bin', 'wb') as output_file:

            output_file.write(data)

def write(device_path: Path):

    with serial.Serial(

        port=str(device_path),

        baudrate=57600,

        bytesize=serial.EIGHTBITS,

        parity=serial.PARITY_NONE,

        stopbits=serial.STOPBITS_ONE,

        xonxoff=False,

        rtscts=True,

        dsrdtr=True

    ) as port:

        common_init(port)

        # XXX data file 0x3000, ???

        with open('region_7000.bin', 'rb') as input_file:

            data = input_file.read()

        assert len(data) == 0xFC0

        write_memory_range(port, data, 0x7000, 0x40)

        # XXX data file 0x4000, channel names?

        with open('region_3000.bin', 'rb') as input_file:

            data = input_file.read()

        assert len(data) == 0xFC0

        write_memory_range(port, data, 0x3000, 0x40)

        # XXX data file offset 0x5000, general settings?

        with open('region_4000.bin', 'rb') as input_file:

            data = input_file.read()

        assert len(data) == 0xFC0

        write_memory_range(port, data, 0x4000, 0x40)

        # XXX data file offset 0x6000, ???

        with open('region_D000.bin', 'rb') as input_file:

            data = input_file.read()

        assert len(data) == 0xFC0

        write_memory_range(port, data, 0xD000, 0x40)

def main():

    parser = argparse.ArgumentParser()

    parser.add_argument(

        '-d', '--device',

        type=Path,

        default='/dev/ttyUSB0')

    subparsers = parser.add_subparsers()

    parser_read = subparsers.add_parser('read', help="read radio memory")

    parser_read.set_defaults(run=read)

    parser_write = subparsers.add_parser('write', help="write radio memory")

    parser_write.set_defaults(run=write)

    args = parser.parse_args()

    args.run(device_path=args.device)

if __name__ == '__main__':

    main()