CHIRP

# Copyright 2012 Dan Smith <dsmith@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/>.

import os

import struct

import time

from chirp import chirp_common

from chirp import directory

from chirp import memmap

from chirp import bitwise

from chirp import errors

from chirp import util

from chirp.settings import RadioSetting, RadioSettingGroup, \

RadioSettingValueInteger, RadioSettingValueList, \

RadioSettingValueBoolean, RadioSettingValueString, \

RadioSettingValueFloat, InvalidValueError

#

# Chirp Driver for TYT TH-9000 VHF (2 meter) Model

# by David Fannin <dfannin@sushisoft.com>, KK6DF

#

# Version 0.4 (Experimental - Known Bugs and Issues)

# Use for development purposes only!

# Features working:

# - Download from Radio

# - Display Memories (only None, Tone, TSQL signalling supported)

# - Save image file

# - memory map decoded (about 90%)

# - Upload to radio

# - Modification of memories

# - feature settings

# - added Startup ID label

#

# Features not working:

# - DCS , Cross Signaling

# - Skip channels

#

# Global Parameters

#

MMAPSIZE = 16128

TONES = [62.5] + list(chirp_common.TONES)

TMODES = ['','Tone','DTCS']

DUPLEXES = ['','err','-','+'] # index 2 not used

MODES = ['WFM','FM','NFM'] # 25k, 20k,15k bw

TUNING_STEPS=[ 5.0, 6.25, 8.33, 10.0, 12.5, 15.0, 20.0, 25.0, 30.0, 50.0 ] # index 0-9

POWER_LEVELS=[chirp_common.PowerLevel("High", watts=65),

chirp_common.PowerLevel("Mid", watts=25),

chirp_common.PowerLevel("Low", watts=10)]

CROSS_MODES = chirp_common.CROSS_MODES

VALID_MODEL = ['TH-9000']

APO_LIST = [ "Off","30 min","1 hr","2 hrs" ]

BGCOLOR_LIST = ["Blue","Orange","Purple"]

BGBRIGHT_LIST = ["%s" % x for x in range(1,32)]

SQUELCH_LIST = ["Off"] + ["Level %s" % x for x in range(1,20)]

TIMEOUT_LIST = ["Off"] + ["%s min" % x for x in range(1,30)]

TXPWR_LIST = ["60W","25W"] # maximum power for Hi setting

TBSTFREQ_LIST = ["1750Hz","2100Hz","1000Hz","1450Hz"]

BEEP_LIST = ["Off","On"]

SETTING_LISTS = {

"auto_power_off": APO_LIST,

"bg_color" : BGCOLOR_LIST,

"bg_brightness" : BGBRIGHT_LIST,

"squelch" : SQUELCH_LIST,

"timeout_timer" : TIMEOUT_LIST,

"choose_tx_power": TXPWR_LIST,

"tbst_freq" : TBSTFREQ_LIST,

"voice_prompt" : BEEP_LIST

}

#

#

#

"""

Overall Memory Map:

Memory Map (Range 0x0100-3FF0, step 0x10):

Field Start End Size

(hex) (hex) (hex)

1 Channel Set Flag 0100 011F 20

2 Channel Skip Flag 0120 013F 20

3 Blank/Unknown 0140 01EF B0

4 Unknown 01F0 01FF 10

5 TX/RX Range 0200 020F 10

6 Bootup Passwd 0210 021F 10

7 Options, Radio 0220 023F 20

8 Unknown 0240 019F

8B Startup Label 03E0 03E7 07

9 Channel Bank 2000 38FF 1900

Channel 000 2000 201F 20

Channel 001 2020 202F 20

...

Channel 199 38E0 38FF 20

10 Blank/Unknown 3900 3FFF 6FF 14592 16383 1792

Total Map Size 16128 (2^8 = 16384)

"""

"""

TH9000/VHF memory map

section: 1 and 2: Channel Set/Skip Flags

Channel Set (starts 0x100) : Channel Set bit is value 0 if a memory location in the channel bank is active.

Channel Skip (starts 0x120): Channel Skip bit is value 0 if a memory location in the channel bank is active.

Both flag maps are a total 24 bytes in length, aligned on 32 byte records.

bit = 0 channel set/no skip, 1 is channel not set/skip

to index a channel:

cbyte = channel / 8 ;

cbit = channel % 8 ;

setflag = csetflag[cbyte].c[cbit] ;

skipflag = cskipflag[cbyte].c[cbit] ;

channel range is 0-199, range is 32 bytes (last 7 unknown)

"""

MEM_FORMAT = """

#seekto 0x0100;

struct {

bit c[8];

} csetflag[32];

struct {

u8 unknown0100[7];

} ropt0100;

#seekto 0x0120;

struct {

bit c[8];

} cskipflag[32];

struct {

u8 unknown0120[7];

} ropt0120;

"""

"""

TH9000/VHF memory map

section: 5 TX/RX Range

used to set the TX/RX range of the radio (e.g. 144-148Mhz for 2 meter)

possible to set range to 136-172Mhz for tx/rx

"""

MEM_FORMAT = MEM_FORMAT + """

#seekto 0x0200;

struct {

bbcd txrangelow[4];

bbcd txrangehi[4];

bbcd rxrangelow[4];

bbcd rxrangehi[4];

} freqrange;

"""

"""

TH9000/VHF memory map

section: 6 bootup_passwd

used to set bootup passwd (see boot_passwd checkbox option)

options - bootup password

bytes:bit type description

---------------------------------------------------------------------------

6 u8 bootup_passwd[6] bootup passwd, 6 chars, numberic chars 30-39 , see boot_passwd checkbox to set

10 u8 unknown;

"""

MEM_FORMAT = MEM_FORMAT + """

#seekto 0x0210;

struct {

u8 bootup_passwd[6];

u8 unknown2010[10];

} ropt0210;

"""

"""

TH9000/VHF memory map

section: 7 Radio Options

used to set a number of radio options

bytes:bit type description

---------------------------------------------------------------------------

1 u8 display_mode display mode, range 0-2, 0=freq,1=channel,2=name (selecting name affects vfo_mr)

1 u8 vfo_mr; vfo_mr , 0=vfo, mr=1

1 u8 unknown;

1 u8 squelch; squelch level, range 0-19, hex for menu

1 u8 unknown[2];

1 u8 channel_lock; if display_mode[channel] selected, then lock=1,no lock =0

1 u8 unknown;

1 u8 bg_brightness ; background brightness, range 0-21, hex, menu index

1 u8 unknown;

1 u8 bg_color ; bg color, menu index, blue 0 , orange 1, purple 2

1 u8 tbst_freq ; tbst freq , menu 0 = 1750Hz, 1=2100 , 2=1000 , 3=1450hz

1 u8 timeout_timer; timeout timer, hex, value = minutes, 0= no timeout

1 u8 unknown;

1 u8 auto_power_off; auto power off, range 0-3, off,30min, 1hr, 2hr, hex menu index

1 u8 voice_prompt; voice prompt, value 0,1 , Beep ON = 1, Beep Off = 2

description of function setup options, starting at 0x0230

bytes:bit type description

---------------------------------------------------------------------------

1 u8 // 0

:4 unknown:6

:1 elim_sql_tail:1 eliminate squelsh tail when no ctcss checkbox (1=checked)

:1 sql_key_function "squelch off" 1 , "squelch momentary off" 0 , menu index

2 u8 unknown[2] /1-2

1 u8 // 3

:4 unknown:4

:1 inhibit_init_ops:1 //bit 5

:1 unknownD:1

:1 inhibit_setup_bg_chk:1 //bit 7

:1 unknown:1

1 u8 tail_elim_type menu , (off=0,120=1,180=2), // 4

1 u8 choose_tx_power menu , (60w=0,25w=1) // 5

2 u8 unknown[2]; // 6-7

1 u8 bootup_passwd_flag checkbox 1=on, 0=off // 8

7 u8 unknown[7]; // 9-F

"""

MEM_FORMAT = MEM_FORMAT + """

#seekto 0x0220;

struct {

u8 display_mode;

u8 vfo_mr;

u8 unknown0220A;

u8 squelch;

u8 unknown0220B[2];

u8 channel_lock;

u8 unknown0220C;

u8 bg_brightness;

u8 unknown0220D;

u8 bg_color;

u8 tbst_freq;

u8 timeout_timer;

u8 unknown0220E;

u8 auto_power_off;

u8 voice_prompt;

u8 unknown0230A:6,

elim_sql_tail:1,

sql_key_function:1;

u8 unknown0230B[2];

u8 unknown0230C:4,

inhibit_init_ops:1,

unknown0230D:1,

inhibit_setup_bg_chk:1,

unknown0230E:1;

u8 tail_elim_type;

u8 choose_tx_power;

u8 unknown0230F[2];

u8 bootup_passwd_flag;

u8 unknown0230G[7];

} settings;

"""

"""

TH9000/VHF memory map

section: 8B Startup Label

bytes:bit type description

---------------------------------------------------------------------------

7 char start_label[7] label displayed at startup (usually your call sign)

"""

MEM_FORMAT = MEM_FORMAT + """

#seekto 0x03E0;

struct {

char startname[7];

} slabel;

"""

"""

TH9000/VHF memory map

section: 9 Channel Bank

description of channel bank (200 channels , range 0-199)

Each 32 Byte (0x20 hex) record:

bytes:bit type description

---------------------------------------------------------------------------

4 bbcd freq[4] receive frequency in packed binary coded decimal

4 bbcd offset[4] transmit offset in packed binary coded decimal (note: plus/minus direction set by 'duplex' field)

1 u8

:4 unknown:4

:4 tuning_step:4 tuning step, menu index value from 0-9

5,6.25,8.33,10,12.5,15,20,25,30,50

1 u8

:4 unknown:4 not yet decoded, used for DCS coding?

:2 channel_width:2 channel spacing, menu index value from 0-3

25,20,12.5

:1 reverse:1 reverse flag, 0=off, 1=on (reverses tx and rx freqs)

:1 txoff:1 transmitt off flag, 0=transmit , 1=do not transmit

1 u8

:1 talkaround:1 talkaround flag, 0=off, 1=on (bypasses repeater)

:1 compander:1 compander flag, 0=off, 1=on (turns on/off voice compander option)

:2 unknown:2

:2 power:2 tx power setting, value range 0-2, 0=hi,1=med,2=lo

:2 duplex:2 duplex settings, 0=simplex,2= minus(-) offset, 3= plus (+) offset (see offset field)

1 u8

:4 unknown:4

:2 rxtmode:2 rx tone mode, value range 0-2, 0=none, 1=CTCSS, 2=DCS (ctcss tone in field rxtone)

:2 txtmode:2 tx tone mode, value range 0-2, 0=none, 1=CTCSS, 3=DCS (ctcss tone in field txtone)

1 u8

:2 unknown:2

:6 txtone:6 tx ctcss tone, menu index

1 u8

:2 unknown:2

:6 rxtone:6 rx ctcss tone, menu index

1 u8 txcode ?, not used for ctcss

1 u8 rxcode ?, not used for ctcss

3 u8 unknown[3]

7 char name[7] 7 byte char string for channel name

1 u8

:6 unknown:6,

:2 busychannellockout:2 busy channel lockout option , 0=off, 1=repeater, 2=busy (lock out tx if channel busy)

4 u8 unknownI[4];

1 u8

:7 unknown:7

:1 scrambler:1 scrambler flag, 0=off, 1=on (turns on tyt scrambler option)

"""

MEM_FORMAT = MEM_FORMAT + """

#seekto 0x2000;

struct {

bbcd freq[4];

bbcd offset[4];

u8 unknown2000A:4,

tuning_step:4;

u8 unknown2000B:4,

channel_width:2,

reverse:1,

txoff:1;

u8 talkaround:1,

compander:1,

unknown2000C:2,

power:2,

duplex:2;

u8 unknown2000D:4,

rxtmode:2,

txtmode:2;

u8 unknown2000E:2,

txtone:6;

u8 unknown2000F:2,

rxtone:6;

u8 txcode;

u8 rxcode;

u8 unknown2000G[3];

char name[7];

u8 unknown2000H:6,

busychannellockout:2;

u8 unknown2000I[4];

u8 unknown2000J:7,

scrambler:1;

} memory[200] ;

"""

def _debug(string):

if "CHIRP_DEBUG" in os.environ or True:

print string

def _echo_write(radio, data):

try:

radio.pipe.write(data)

radio.pipe.read(len(data))

except Exception, e:

print "Error writing to radio: %s" % e

raise errors.RadioError("Unable to write to radio")

def _checksum(data):

cs = 0

for byte in data:

cs += ord(byte)

return cs % 256

def _read(radio, length):

try:

data = radio.pipe.read(length)

except Exception, e:

print "Error reading from radio: %s" % e

raise errors.RadioError("Unable to read from radio")

if len(data) != length:

print "Short read from radio (%i, expected %i)" % (len(data),

length)

print util.hexprint(data)

raise errors.RadioError("Short read from radio")

return data

def _ident(radio):

radio.pipe.setTimeout(1)

_echo_write(radio,"PROGRAM")

response = radio.pipe.read(3)

if response != "QX\06":

print "Response was :\n%s" % util.hexprint(response)

raise errors.RadioError("Unsupported model")

_echo_write(radio, "\x02")

response = radio.pipe.read(16)

_debug(util.hexprint(response))

if response[1:8] != "TH-9000":

print "Looking for:\n%s" % util.hexprint("TH-9000")

print "Response was:\n%s" % util.hexprint(response)

raise errors.RadioError("Unsupported model")

def _send(radio, cmd, addr, length, data=None):

frame = struct.pack(">cHb", cmd, addr, length)

if data:

frame += data

frame += chr(_checksum(frame[1:]))

frame += "\x06"

_echo_write(radio, frame)

_debug("Sent:\n%s" % util.hexprint(frame))

if data:

result = radio.pipe.read(1)

if result != "\x06":

print "Ack was: %s" % repr(result)

raise errors.RadioError("Radio did not accept block at %04x" % addr)

return

result = _read(radio, length + 6)

_debug("Got:\n%s" % util.hexprint(result))

header = result[0:4]

data = result[4:-2]

ack = result[-1]

if ack != "\x06":

print "Ack was: %s" % repr(ack)

raise errors.RadioError("Radio NAK'd block at %04x" % addr)

_cmd, _addr, _length = struct.unpack(">cHb", header)

if _addr != addr or _length != _length:

print "Expected/Received:"

print " Length: %02x/%02x" % (length, _length)

print " Addr: %04x/%04x" % (addr, _addr)

raise errors.RadioError("Radio send unexpected block")

cs = _checksum(result[1:-2])

if cs != ord(result[-2]):

print "Calculated: %02x" % cs

print "Actual: %02x" % ord(result[-2])

raise errors.RadioError("Block at 0x%04x failed checksum" % addr)

return data

def _finish(radio):

endframe = "\x45\x4E\x44"

_echo_write(radio, endframe)

result = radio.pipe.read(1)

if result != "\x06":

print "Got:\n%s" % util.hexprint(result)

raise errors.RadioError("Radio did not finish cleanly")

def do_download(radio):

_ident(radio)

_memobj = None

data = ""

for start,end in radio._ranges:

for addr in range(start,end,0x10):

block = _send(radio,'R',addr,0x10)

data += block

status = chirp_common.Status()

status.cur = len(data)

status.max = end

status.msg = "Downloading from radio"

radio.status_fn(status)

_finish(radio)

return memmap.MemoryMap(data)

def do_upload(radio):

_ident(radio)

for start,end in radio._ranges:

for addr in range(start,end,0x10):

if addr < 0x0100:

continue

block = radio._mmap[addr:addr+0x10]

_send(radio,'W',addr,len(block),block)

status = chirp_common.Status()

status.cur = addr

status.max = end

status.msg = "Uploading to Radio"

radio.status_fn(status)

_finish(radio)

@directory.register

class Th9000VHFRadio(chirp_common.CloneModeRadio):

"""TYT TH-9000 VHF"""

VENDOR = "TYT"

MODEL = "TH9000"

BAUD_RATE = 9600

_file_ident = "TH-9000"

_memsize = MMAPSIZE

_ranges = [(0x0000,0x4000)]

@classmethod

def get_prompts(cls):

rp = chirp_common.RadioPrompts()

rp.experimental = ("The TYT TH-9000 driver is an alpha version."

"Use only for testing and development"

"Proceed with Caution and backup your data"

"as you may lose it using this driver!")

return rp

def get_features(self):

rf = chirp_common.RadioFeatures()

rf.has_settings = True

rf.has_bank = False

rf.has_cross = True

rf.has_tuning_step = False

rf.has_rx_dtcs = True

rf.valid_skips = ["","S"]

rf.memory_bounds = (0, 199)

rf.valid_name_length = 7

rf.valid_characters = chirp_common.CHARSET_UPPER_NUMERIC + "-"

rf.valid_modes = MODES

rf.valid_tmodes = chirp_common.TONE_MODES

rf.valid_cross_modes = CROSS_MODES

rf.valid_power_levels = POWER_LEVELS

rf.valid_dtcs_codes = chirp_common.ALL_DTCS_CODES

rf.valid_bands = [(136000000, 174000000)]

return rf

# Do a download of the radio from the serial port

def sync_in(self):

self._mmap = do_download(self)

self.process_mmap()

# Do an upload of the radio to the serial port

def sync_out(self):

do_upload(self)

def process_mmap(self):

self._memobj = bitwise.parse(MEM_FORMAT, self._mmap)

# 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])

# not working

def _get_dcs_index(self, _mem,which):

base = getattr(_mem, '%scode' % which)

extra = getattr(_mem, '%sdcsextra' % which)

return (int(extra) << 8) | int(base)

def _set_dcs_index(self, _mem, which, index):

base = getattr(_mem, '%scode' % which)

extra = getattr(_mem, '%sdcsextra' % which)

base.set_value(index & 0xFF)

extra.set_value(index >> 8)

# 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]

# get flag info

cbyte = number / 8 ;

cbit = 7 - (number % 8) ;

setflag = self._memobj.csetflag[cbyte].c[cbit];

skipflag = self._memobj.cskipflag[cbyte].c[cbit];

mem = chirp_common.Memory()

mem.number = number # Set the memory number

if setflag == 1:

mem.empty = True

return mem

mem.freq = int(_mem.freq) * 100

mem.offset = int(_mem.offset) * 100

mem.name = str(_mem.name).rstrip() # Set the alpha tag

mem.duplex = DUPLEXES[_mem.duplex]

mem.mode = MODES[_mem.channel_width]

mem.power = POWER_LEVELS[_mem.power]

rxtone = txtone = None

rxmode = TMODES[_mem.rxtmode]

txmode = TMODES[_mem.txtmode]

rxpol = txpol = ""

# doesn't work

if rxmode == "Tone":

rxpol = ""

rxtone = TONES[_mem.rxtone]

elif rxmode == "DTCS":

rxpol = "N"

rxtone = chirp_common.ALL_DTCS_CODES[self._get_dcs_index(_mem,'rx')]

if txmode == "Tone":

txpol = ""

txtone = TONES[_mem.txtone]

elif txmode == "DTCS":

txpol = "N"

txtone = chirp_common.ALL_DTCS_CODES[self._get_dcs_index(_mem,'tx')]

chirp_common.split_tone_decode(mem,

(txmode, txtone, txpol),

(rxmode, rxtone, rxpol))

mem.skip = "S" if skipflag == 1 else ""

# We'll consider any blank (i.e. 0MHz frequency) to be empty

if mem.freq == 0:

mem.empty = True

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[mem.number]

cbyte = mem.number / 8

cbit = 7 - (mem.number % 8)

if mem.empty:

self._memobj.csetflag[cbyte].c[cbit] = 1

self._memobj.cskipflag[cbyte].c[cbit] = 1

return

self._memobj.csetflag[cbyte].c[cbit] = 0

self._memobj.cskipflag[cbyte].c[cbit] = 1 if (mem.skip == "S") else 0

_mem.set_raw("\x00" * 32)

_mem.freq = mem.freq / 100 # Convert to low-level frequency

_mem.offset = mem.offset / 100 # Convert to low-level frequency

_mem.name = mem.name.ljust(7)[:7] # Store the alpha tag

_mem.duplex = DUPLEXES.index(mem.duplex)

try:

_mem.channel_width = MODES.index(mem.mode)

except ValueError:

_mem.channel_width = 0

((txmode, txtone, txpol),

(rxmode, rxtone, rxpol)) = chirp_common.split_tone_encode(mem)

_mem.txtmode = TMODES.index(txmode)

_mem.rxtmode = TMODES.index(rxmode)

if txmode == "Tone":

_mem.txtone = TONES.index(txtone)

elif txmode == "DTCS":

self._set_dcs_index(_mem,'tx',chirp_common.ALL_DTCS_CODES.index(txtone))

if rxmode == "Tone":

_mem.rxtone = TONES.index(rxtone)

elif rxmode == "DTCS":

self._set_dcs_index(_mem, 'rx', chirp_common.ALL_DTCS_CODES.index(rxtone))

#_mem.txinv = txpol == "N"

#_mem.rxinv = rxpol == "N"

if mem.power:

_mem.power = POWER_LEVELS.index(mem.power)

else:

_mem.power = 0

def _get_settings(self):

_settings = self._memobj.settings

_freqrange = self._memobj.freqrange

_slabel = self._memobj.slabel

basic = RadioSettingGroup("basic","Global Settings")

freqrange = RadioSettingGroup("freqrange","Frequency Ranges")

top = RadioSettingGroup("top","All Settings",basic,freqrange)

def _filter(name):

filtered = ""

for char in str(name):

if char in chirp_common.CHARSET_ASCII:

filtered += char

else:

filtered += ""

return filtered

val = RadioSettingValueString(0,7,_filter(_slabel.startname))

rs = RadioSetting("startname","Startup Label",val)

basic.append(rs)

rs = RadioSetting("bg_color","LCD Color",

RadioSettingValueList(BGCOLOR_LIST, BGCOLOR_LIST[_settings.bg_color]))

basic.append(rs)

rs = RadioSetting("bg_brightness","LCD Brightness",

RadioSettingValueList(BGBRIGHT_LIST, BGBRIGHT_LIST[_settings.bg_brightness]))

basic.append(rs)

rs = RadioSetting("squelch","Squelch Level",

RadioSettingValueList(SQUELCH_LIST, SQUELCH_LIST[_settings.squelch]))

basic.append(rs)

rs = RadioSetting("timeout_timer","Timeout Timer (TOT)",

RadioSettingValueList(TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout_timer]))

basic.append(rs)

rs = RadioSetting("auto_power_off","Auto Power Off (APO)",

RadioSettingValueList(APO_LIST, APO_LIST[_settings.auto_power_off]))

basic.append(rs)

rs = RadioSetting("voice_prompt","Beep Prompt",

RadioSettingValueList(BEEP_LIST, BEEP_LIST[_settings.voice_prompt]))

basic.append(rs)

rs = RadioSetting("tbst_freq","Tone Burst Frequency",

RadioSettingValueList(TBSTFREQ_LIST, TBSTFREQ_LIST[_settings.tbst_freq]))

basic.append(rs)

rs = RadioSetting("choose_tx_power","Max Level of TX Power",

RadioSettingValueList(TXPWR_LIST, TXPWR_LIST[_settings.choose_tx_power]))

basic.append(rs)

rs = RadioSetting("txrangelow","TX Freq, Lower Limit (khz)", RadioSettingValueInteger(136000,144000, int(_freqrange.txrangelow)/10))

freqrange.append(rs)

rs = RadioSetting("txrangehi","TX Freq, Upper Limit (khz)", RadioSettingValueInteger(148000,174000,int(_freqrange.txrangehi)/10))

freqrange.append(rs)

rs = RadioSetting("rxrangelow","RX Freq, Lower Limit (khz)", RadioSettingValueInteger(136000,144000, int(_freqrange.rxrangelow)/10))

freqrange.append(rs)

rs = RadioSetting("rxrangehi","RX Freq, Upper Limit (khz)", RadioSettingValueInteger(148000,174000,int(_freqrange.rxrangehi)/10))

freqrange.append(rs)

return top

def get_settings(self):

try:

return self._get_settings()

except:

import traceback

print "failed to parse settings"

traceback.print_exc()

return None

def set_settings(self,settings):

_settings = self._memobj.settings

for element in settings:

if not isinstance(element,RadioSetting):

self.set_settings(element)

continue

else:

try:

name = element.get_name()

if name in ["txrangelow","txrangehi","rxrangelow","rxrangehi"]:

print "setting %s = %s" % (name,int(element.value)*10)

setattr(self._memobj.freqrange,name,int(element.value)*10)

continue

if name in ["startname"]:

print "setting %s = %s" % (name, element.value)

setattr(self._memobj.slabel,name,element.value)

continue

obj = _settings

setting = element.get_name()

if element.has_apply_callback():

print "using apply callback"

element.run_apply_callback()

else:

print "Setting %s = %s" % (setting, element.value)

setattr(obj, setting, element.value)

except Exception, e:

print element.get_name()

raise

@classmethod

def match_model(cls, filedata, filename):

return cls._file_ident in filedata[0x10:0x20]