[chirp_devel] [PATCH] Add a template driver to assist with development of new drivers

[Dan Smith]

# HG changeset patch
# User Dan Smith <dsmith at danplanet.com>
# Date 1333164240 25200
# Node ID 13183690b930a8c3be0da123e181b82b1702307e
# Parent  a3d397d29b3cfd84e3e42d283c452a42fe30f22b
Add a template driver to assist with development of new drivers
Lumping into the 0.3.0 catch-all bug #93

diff -r a3d397d29b3c -r 13183690b930 chirp/template.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/chirp/template.py	Fri Mar 30 20:24:00 2012 -0700
@@ -0,0 +1,112 @@
+# Copyright 2012 Dan Smith <dsmith at danplanet.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from chirp import chirp_common, yaesu_clone, util, directory, memmap
+from chirp import bitwise
+
+# Here is where we define the memory map for the radio. Since
+# We often just know small bits of it, we can use #seekto to skip
+# around as needed.
+#
+# Our fake radio includes just a single array of ten memory objects,
+# With some very basic settings, a 32-bit unsigned integer for the
+# frequency (in Hertz) and an eight-character alpha tag
+#
+mem_format = """
+#seekto 0x0000;
+struct {
+  u32 freq;
+  char name[8];
+} memory[10];
+"""
+
+def do_download(radio):
+    # Get the serial port connection
+    serial = radio.pipe
+
+    # Our fake radio is just a simple download of 1000 bytes
+    # from the serial port. Do that one byte at a time and
+    # store them in the memory map
+    data = ""
+    for i in range(0, 1000):
+        data = serial.read(1)
+
+    return memmap.MemoryMap(data)
+
+def do_upload(radio):
+    # Get the serial port connection
+    serial = radio.pipe
+
+    # Our fake radio is just a simple upload of 1000 bytes
+    # to the serial port. Do that one byte at a time, reading
+    # from our memory map
+    for i in range(0, 1000):
+        serial.write(radio._mmap[i])
+
+# Uncomment this to actually register this radio in CHIRP
+# @directory.register
+class TemplateRadio(chirp_common.CloneModeRadio):
+    VENDOR = "Acme"    # Replace this with your vendor
+    MODEL = "Template" # Replace this with your model
+    BAUD_RATE = 9600   # Replace this with your baud rate
+
+    # Return information about this radio's features, including
+    # how many memories it has, what bands it supports, etc
+    def get_features(self):
+        rf = chirp_common.RadioFeatures()
+        rf.memory_bounds = (1, 10) # This radio supports memories 1-9
+        rf.valid_bands = [(144000000, 148000000), # Supports 2-meters
+                          (440000000, 450000000), # Supports 70-centimeters
+                          ]
+        return rf
+
+    # Do a download of the radio from the serial port
+    def sync_in(self):
+        self._mmap = do_download(self)
+        self._memobj = bitwise.parse(mem_format, self._mmap)
+
+    # Do an upload of the radio to the serial port
+    def sync_out(self):
+        do_upload(self)
+
+    # Return a raw representation of the memory object, which 
+    # is very helpful for development
+    def get_raw_memory(self, number):
+        return repr(self._memobj.memory[number])
+
+    # Extract a high-level memory object from the low-level memory map
+    # This is called to populate a memory in the UI
+    def get_memory(self, number):
+        # Get a low-level memory object mapped to the image
+        _mem = self._memobj.memory[number]
+
+        # Create a high-level memory object to return to the UI
+        mem = chirp_common.Memory()
+
+        mem.number = number       # Set the memory number
+        mem.freq = int(_mem.freq) # Convert your low-level frequency to Hertz
+        mem.name = "FooBar"       # Set the alpha tag
+
+        return mem
+
+    # Store details about a high-level memory to the memory map
+    # This is called when a user edits a memory in the UI
+    def set_memory(self, mem):
+        # Get a low-level memory object mapped to the image
+        _mem = self._memobj.memory[number]
+
+        _mem.freq = mem.freq      # Convert to low-level frequency representation
+        _mem.name = mem.name[:8]  # Store the alpha tag
+