|
# Wouxun KG-Q10H Driver
|
|
# melvin.terechenok@gmail.com
|
|
#
|
|
# Based on the work of 2019 Pavel Milanes CO7WT <pavelmc@gmail.com>
|
|
# and Krystian Struzik <toner_82@tlen.pl>
|
|
# who figured out the crypt used and made possible the
|
|
# Wuoxun KG-UV8D Plus driver, in which this work is based.
|
|
#
|
|
# 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 3 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/>.
|
|
|
|
"""Wouxun KG-Q10H radio management module"""
|
|
|
|
import struct
|
|
import time
|
|
import logging
|
|
|
|
from chirp import util, chirp_common, bitwise, memmap, errors, directory
|
|
from chirp.settings import RadioSetting, RadioSettingGroup, \
|
|
RadioSettingValueBoolean, RadioSettingValueList, \
|
|
RadioSettingValueInteger, RadioSettingValueString, \
|
|
RadioSettingValueFloat, RadioSettingValueMap, RadioSettings, \
|
|
InvalidValueError#, RadioSettingValueRGB
|
|
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
CMD_ID = 128 # \x80
|
|
CMD_END = 129 # \x81
|
|
CMD_RD = 130 # \82
|
|
CMD_WR = 131 # \83
|
|
|
|
MEM_VALID = 158
|
|
|
|
# set up map of addresses to upload to known memory locations only
|
|
# Add new regions as new settings are discovered
|
|
# 1st entry is start address in hex
|
|
# 2nd entry is write size (number of bytes to transfer in decimal (64-MAX))
|
|
# 3rd entry is write count
|
|
# so 0x00, 64, 512 = start at 0x00 and write 64*512 bytes = 0 - 32768
|
|
|
|
# NOTE : It looks like the radio MUST have write
|
|
# sizes in values of 1,2,4,8,16,32 or 64 bytes if using
|
|
# a write count value of > 1.
|
|
# OTHERWISE - it appears the radio gets out of sync
|
|
# and the memory write is messed up
|
|
# for that section
|
|
|
|
Q10H_download_map_full = (
|
|
(0x00, 64, 512), # - Use for full Download testing
|
|
)
|
|
Q10H_mem_arrange_map = (
|
|
(0x0300, 0x0400),
|
|
(0x0200, 0x0300),
|
|
(0x0100, 0x0200),
|
|
(0x0000, 0x0100),
|
|
|
|
(0x0700, 0x0800),
|
|
(0x0600, 0x0700), # channel 1 data start
|
|
(0x0500, 0x0600),
|
|
(0x0400, 0x0500),
|
|
|
|
(0x0b00, 0x0c00),
|
|
(0x0a00, 0x0b00),
|
|
(0x0900, 0x0a00),
|
|
(0x0800, 0x0900),
|
|
|
|
(0x0f00, 0x1000),
|
|
(0x0e00, 0x0f00),
|
|
(0x0d00, 0x0e00),
|
|
(0x0c00, 0x0d00),
|
|
|
|
(0x1300, 0x1400),
|
|
(0x1200, 0x1300),
|
|
(0x1100, 0x1200),
|
|
(0x1000, 0x1100),
|
|
|
|
(0x1700, 0x1800),
|
|
(0x1600, 0x1700),
|
|
(0x1500, 0x1600),
|
|
(0x1400, 0x1500),
|
|
|
|
(0x1B00, 0x1c00),
|
|
(0x1a00, 0x1b00),
|
|
(0x1900, 0x1a00),
|
|
(0x1800, 0x1900),
|
|
|
|
(0x1f00, 0x2000),
|
|
(0x1e00, 0x1f00),
|
|
(0x1d00, 0x1e00),
|
|
(0x1c00, 0x1d00),
|
|
|
|
(0x2300, 0x2400),
|
|
(0x2200, 0x2300),
|
|
(0x2100, 0x2200),
|
|
(0x2000, 0x2100),
|
|
|
|
(0x2700, 0x2800),
|
|
(0x2600, 0x2700),
|
|
(0x2500, 0x2600),
|
|
(0x2400, 0x2500),
|
|
|
|
(0x2B00, 0x2C00),
|
|
(0x2a00, 0x2b00),
|
|
(0x2900, 0x2a00),
|
|
(0x2800, 0x2900),
|
|
|
|
(0x2f00, 0x3000),
|
|
(0x2e00, 0x2f00),
|
|
(0x2d00, 0x2e00),
|
|
(0x2c00, 0x2d00),
|
|
|
|
(0x3300, 0x3400),
|
|
(0x3200, 0x3300),
|
|
(0x3100, 0x3200),
|
|
(0x3000, 0x3100),
|
|
|
|
(0x3700, 0x3800),
|
|
(0x3600, 0x3700),
|
|
(0x3500, 0x3600),
|
|
(0x3400, 0x3500),
|
|
|
|
(0x3B00, 0x3C00),
|
|
(0x3a00, 0x3b00),
|
|
(0x3900, 0x3a00),
|
|
(0x3800, 0x3900),
|
|
|
|
(0x3f00, 0x4000),
|
|
(0x3e00, 0x3f00),
|
|
(0x3d00, 0x3e00),
|
|
(0x3c00, 0x3d00),
|
|
|
|
(0x4300, 0x4400),
|
|
(0x4200, 0x4300),
|
|
(0x4100, 0x4200),
|
|
(0x4000, 0x4100),
|
|
|
|
(0x4700, 0x4760),
|
|
|
|
(0x4760, 0x4800), # start of Ch names
|
|
(0x4600, 0x4700),
|
|
(0x4500, 0x4600),
|
|
(0x4400, 0x4500),
|
|
(0x4b00, 0x4c00),
|
|
(0x4a00, 0x4B00),
|
|
(0x4900, 0x4a00),
|
|
(0x4800, 0x4900),
|
|
(0x4f00, 0x5000),
|
|
(0x4E00, 0x4F00),
|
|
(0x4D00, 0x4E00),
|
|
(0x4C00, 0x4d00),
|
|
(0x5300, 0x5400),
|
|
(0x5200, 0x5300),
|
|
(0x5100, 0x5200),
|
|
(0x5000, 0x5100),
|
|
(0x5700, 0x5800),
|
|
(0x5600, 0x5700),
|
|
(0x5500, 0x5600),
|
|
(0x5400, 0x5500),
|
|
(0x5B00, 0x5C00),
|
|
(0x5A00, 0x5B00),
|
|
(0x5900, 0x5A00),
|
|
(0x5800, 0x5900),
|
|
(0x5F00, 0x6000),
|
|
(0x5E00, 0x5F00),
|
|
(0x5D00, 0x5E00),
|
|
(0x5C00, 0x5D00),
|
|
(0x6300, 0x6400),
|
|
(0x6200, 0x6300),
|
|
(0x6100, 0x6200),
|
|
(0x6000, 0x6100),
|
|
(0x6700, 0x6800),
|
|
(0x6600, 0x6700),
|
|
(0x6500, 0x6600),
|
|
(0x6400, 0x6500),
|
|
(0x6b00, 0x6c00),
|
|
(0x6a00, 0x6b00),
|
|
(0x6900, 0x6a00),
|
|
(0x6800, 0x6900),
|
|
(0x6F00, 0x7000),
|
|
(0x6e00, 0x6F00),
|
|
(0X6D00, 0X6E00),
|
|
(0X6C00, 0X6D00),
|
|
(0x7300, 0x7400),
|
|
(0x7200, 0x7300),
|
|
(0x7100, 0x7200),
|
|
(0x7000, 0x7040), # End of Ch Names
|
|
|
|
(0x7040, 0x7100), # start of ch valid
|
|
(0x7700, 0x7800),
|
|
(0x7600, 0x7700),
|
|
(0x7500, 0x7600),
|
|
(0x7400, 0x7440), # end of ch valid
|
|
|
|
(0x7440, 0x7500),
|
|
# (0x7800, 0x8000),
|
|
(0x7b00, 0x7c00),
|
|
(0x7a00, 0x7b00),
|
|
(0x7900, 0x7a00),
|
|
(0x7800, 0x7900),
|
|
(0x7f00, 0x9000),
|
|
(0x7e00, 0x7f00),
|
|
(0x7d00, 0x7e00),
|
|
(0x7c00, 0x7d00),
|
|
)
|
|
|
|
|
|
Q10H_mem_arrange_map_OLD = (
|
|
(0x0000, 0x0400),
|
|
(0x0600, 0x06E0),
|
|
(0x0700, 0x0800),
|
|
|
|
(0x06E0, 0x0700), # channel 1 data start
|
|
(0x0500, 0x0600),
|
|
(0x0400, 0x0500),
|
|
|
|
(0x0b00, 0x0c00),
|
|
(0x0a00, 0x0b00),
|
|
(0x0900, 0x0a00),
|
|
(0x0800, 0x0900),
|
|
|
|
(0x0f00, 0x1000),
|
|
(0x0e00, 0x0f00),
|
|
(0x0d00, 0x0e00),
|
|
(0x0c00, 0x0d00),
|
|
|
|
(0x1300, 0x1400),
|
|
(0x1200, 0x1300),
|
|
(0x1100, 0x1200),
|
|
(0x1000, 0x1100),
|
|
|
|
(0x1700, 0x1800),
|
|
(0x1600, 0x1700),
|
|
(0x1500, 0x1600),
|
|
(0x1400, 0x1500),
|
|
|
|
(0x1B00, 0x1c00),
|
|
(0x1a00, 0x1b00),
|
|
(0x1900, 0x1a00),
|
|
(0x1800, 0x1900),
|
|
|
|
(0x1f00, 0x2000),
|
|
(0x1e00, 0x1f00),
|
|
(0x1d00, 0x1e00),
|
|
(0x1c00, 0x1d00),
|
|
|
|
(0x2300, 0x2400),
|
|
(0x2200, 0x2300),
|
|
(0x2100, 0x2200),
|
|
(0x2000, 0x2100),
|
|
|
|
(0x2700, 0x2800),
|
|
(0x2600, 0x2700),
|
|
(0x2500, 0x2600),
|
|
(0x2400, 0x2500),
|
|
|
|
(0x2B00, 0x2C00),
|
|
(0x2a00, 0x2b00),
|
|
(0x2900, 0x2a00),
|
|
(0x2800, 0x2900),
|
|
|
|
(0x2f00, 0x3000),
|
|
(0x2e00, 0x2f00),
|
|
(0x2d00, 0x2e00),
|
|
(0x2c00, 0x2d00),
|
|
|
|
(0x3300, 0x3400),
|
|
(0x3200, 0x3300),
|
|
(0x3100, 0x3200),
|
|
(0x3000, 0x3100),
|
|
|
|
(0x3700, 0x3800),
|
|
(0x3600, 0x3700),
|
|
(0x3500, 0x3600),
|
|
(0x3400, 0x3500),
|
|
|
|
(0x3B00, 0x3C00),
|
|
(0x3a00, 0x3b00),
|
|
(0x3900, 0x3a00),
|
|
(0x3800, 0x3900),
|
|
|
|
(0x3f00, 0x4000),
|
|
(0x3e00, 0x3f00),
|
|
(0x3d00, 0x3e00),
|
|
(0x3c00, 0x3d00),
|
|
|
|
(0x4300, 0x4400),
|
|
(0x4200, 0x4300),
|
|
(0x4100, 0x4200),
|
|
(0x4000, 0x4100),
|
|
|
|
(0x4700, 0x4760),
|
|
|
|
(0x4760, 0x4800), # start of Ch names
|
|
(0x4600, 0x4700),
|
|
(0x4500, 0x4600),
|
|
(0x4400, 0x4500),
|
|
(0x4b00, 0x4c00),
|
|
(0x4a00, 0x4B00),
|
|
(0x4900, 0x4a00),
|
|
(0x4800, 0x4900),
|
|
(0x4f00, 0x5000),
|
|
(0x4E00, 0x4F00),
|
|
(0x4D00, 0x4E00),
|
|
(0x4C00, 0x4d00),
|
|
(0x5300, 0x5400),
|
|
(0x5200, 0x5300),
|
|
(0x5100, 0x5200),
|
|
(0x5000, 0x5100),
|
|
(0x5700, 0x5800),
|
|
(0x5600, 0x5700),
|
|
(0x5500, 0x5600),
|
|
(0x5400, 0x5500),
|
|
(0x5B00, 0x5C00),
|
|
(0x5A00, 0x5B00),
|
|
(0x5900, 0x5A00),
|
|
(0x5800, 0x5900),
|
|
(0x5F00, 0x6000),
|
|
(0x5E00, 0x5F00),
|
|
(0x5D00, 0x5E00),
|
|
(0x5C00, 0x5D00),
|
|
(0x6300, 0x6400),
|
|
(0x6200, 0x6300),
|
|
(0x6100, 0x6200),
|
|
(0x6000, 0x6100),
|
|
(0x6700, 0x6800),
|
|
(0x6600, 0x6700),
|
|
(0x6500, 0x6600),
|
|
(0x6400, 0x6500),
|
|
(0x6b00, 0x6c00),
|
|
(0x6a00, 0x6b00),
|
|
(0x6900, 0x6a00),
|
|
(0x6800, 0x6900),
|
|
(0x6F00, 0x7000),
|
|
(0x6e00, 0x6F00),
|
|
(0X6D00, 0X6E00),
|
|
(0X6C00, 0X6D00),
|
|
(0x7300, 0x7400),
|
|
(0x7200, 0x7300),
|
|
(0x7100, 0x7200),
|
|
(0x7000, 0x7040), # End of Ch Names
|
|
|
|
(0x7040, 0x7100), # start of ch valid
|
|
(0x7700, 0x7800),
|
|
(0x7600, 0x7700),
|
|
(0x7500, 0x7600),
|
|
(0x7400, 0x7440), # end of ch valid
|
|
|
|
(0x7440, 0x7500),
|
|
# (0x7800, 0x8000),
|
|
(0x7b00, 0x7c00),
|
|
(0x7a00, 0x7b00),
|
|
(0x7900, 0x7a00),
|
|
(0x7800, 0x7900),
|
|
(0x7f00, 0x9000),
|
|
(0x7e00, 0x7f00),
|
|
(0x7d00, 0x7e00),
|
|
(0x7c00, 0x7d00),
|
|
)
|
|
|
|
Q10H_upload_map = (
|
|
# This map serves 2 purposes-
|
|
# To limit the Upload to Radio Writes to known settings only
|
|
# And also to send the rearranged Chirp Memory data back to the radio
|
|
# using the proper radio addresses.
|
|
# Radio Radio Chirp Chirp Blk cnt
|
|
# start end start end sz
|
|
# (0x0000, 0x0400, 0x0000, 0x0400, 64, 16),
|
|
# (0x0600, 0x06E0, 0x0400, 0x04E0, 32, 7),
|
|
# (0x0002, 0x0022, 0x0302, 0x0322, 32, 1), # Tx Limits
|
|
# (0x00a6, 0x00fe, 0x00a6, 0x00fe, 8, 11), # Rx Limits
|
|
# (0x030a, 0x030a, 0x030a, 0x030a, 1, 1), # Factory Locked Mode
|
|
# (0x0640, 0x06c0, 0x0440, 0x04c0, 32, 7), # VFO settings
|
|
# (0x0700, 0x0800, 0x04E0, 0x05E0, 64, 4), # settings
|
|
# (0x06E0, 0x0700, 0x05E0, 0x0600, 32, 1), # channel 1 data start
|
|
(0x0300, 0x0400, 0x0000, 0x0100, 64, 4),
|
|
(0x0200, 0x0300, 0x0100, 0x0200, 64, 4),
|
|
(0x0100, 0x0200, 0x0200, 0x0300, 64, 4),
|
|
(0x0000, 0x0100, 0x0300, 0x0400, 64, 4),
|
|
(0x0700, 0x0800, 0x0400, 0x0500, 64, 4),
|
|
(0x0600, 0x0700, 0x0500, 0x0600, 64, 4),
|
|
(0x0500, 0x0600, 0x0600, 0x0700, 64, 4),
|
|
(0x0400, 0x0500, 0x0700, 0x0800, 64, 4),
|
|
(0x0b00, 0x0c00, 0x0800, 0x0900, 64, 4),
|
|
(0x0a00, 0x0b00, 0x0900, 0x0A00, 64, 4),
|
|
(0x0900, 0x0a00, 0x0A00, 0x0B00, 64, 4),
|
|
(0x0800, 0x0900, 0x0B00, 0x0C00, 64, 4),
|
|
(0x0f00, 0x1000, 0x0C00, 0x0D00, 64, 4),
|
|
(0x0e00, 0x0f00, 0x0D00, 0x0E00, 64, 4),
|
|
(0x0d00, 0x0e00, 0x0E00, 0x0F00, 64, 4),
|
|
(0x0c00, 0x0d00, 0x0F00, 0x1000, 64, 4),
|
|
(0x1300, 0x1400, 0x1000, 0x1100, 64, 4),
|
|
(0x1200, 0x1300, 0x1100, 0x1200, 64, 4),
|
|
(0x1100, 0x1200, 0x1200, 0x1300, 64, 4),
|
|
(0x1000, 0x1100, 0x1300, 0x1400, 64, 4),
|
|
(0x1700, 0x1800, 0x1400, 0x1500, 64, 4),
|
|
(0x1600, 0x1700, 0x1500, 0x1600, 64, 4),
|
|
(0x1500, 0x1600, 0x1600, 0x1700, 64, 4),
|
|
(0x1400, 0x1500, 0x1700, 0x1800, 64, 4),
|
|
(0x1B00, 0x1c00, 0x1800, 0x1900, 64, 4),
|
|
(0x1a00, 0x1b00, 0x1900, 0x1A00, 64, 4),
|
|
(0x1900, 0x1a00, 0x1A00, 0x1B00, 64, 4),
|
|
(0x1800, 0x1900, 0x1B00, 0x1C00, 64, 4),
|
|
(0x1f00, 0x2000, 0x1C00, 0x1D00, 64, 4),
|
|
(0x1e00, 0x1f00, 0x1D00, 0x1E00, 64, 4),
|
|
(0x1d00, 0x1e00, 0x1E00, 0x1F00, 64, 4),
|
|
(0x1c00, 0x1d00, 0x1F00, 0x2000, 64, 4),
|
|
(0x2300, 0x2400, 0x2000, 0x2100, 64, 4),
|
|
(0x2200, 0x2300, 0x2100, 0x2200, 64, 4),
|
|
(0x2100, 0x2200, 0x2200, 0x2300, 64, 4),
|
|
(0x2000, 0x2100, 0x2300, 0x2400, 64, 4),
|
|
(0x2700, 0x2800, 0x2400, 0x2500, 64, 4),
|
|
(0x2600, 0x2700, 0x2500, 0x2600, 64, 4),
|
|
(0x2500, 0x2600, 0x2600, 0x2700, 64, 4),
|
|
(0x2400, 0x2500, 0x2700, 0x2800, 64, 4),
|
|
(0x2B00, 0x2C00, 0x2800, 0x2900, 64, 4),
|
|
(0x2a00, 0x2b00, 0x2900, 0x2A00, 64, 4),
|
|
(0x2900, 0x2a00, 0x2A00, 0x2B00, 64, 4),
|
|
(0x2800, 0x2900, 0x2B00, 0x2C00, 64, 4),
|
|
(0x2f00, 0x3000, 0x2C00, 0x2D00, 64, 4),
|
|
(0x2e00, 0x2f00, 0x2D00, 0x2E00, 64, 4),
|
|
(0x2d00, 0x2e00, 0x2E00, 0x2F00, 64, 4),
|
|
(0x2c00, 0x2d00, 0x2F00, 0x3000, 64, 4),
|
|
(0x3300, 0x3400, 0x3000, 0x3100, 64, 4),
|
|
(0x3200, 0x3300, 0x3100, 0x3200, 64, 4),
|
|
(0x3100, 0x3200, 0x3200, 0x3300, 64, 4),
|
|
(0x3000, 0x3100, 0x3300, 0x3400, 64, 4),
|
|
(0x3700, 0x3800, 0x3400, 0x3500, 64, 4),
|
|
(0x3600, 0x3700, 0x3500, 0x3600, 64, 4),
|
|
(0x3500, 0x3600, 0x3600, 0x3700, 64, 4),
|
|
(0x3400, 0x3500, 0x3700, 0x3800, 64, 4),
|
|
(0x3B00, 0x3C00, 0x3800, 0x3900, 64, 4),
|
|
(0x3a00, 0x3b00, 0x3900, 0x3A00, 64, 4),
|
|
(0x3900, 0x3a00, 0x3A00, 0x3B00, 64, 4),
|
|
(0x3800, 0x3900, 0x3B00, 0x3C00, 64, 4),
|
|
(0x3f00, 0x4000, 0x3C00, 0x3D00, 64, 4),
|
|
(0x3e00, 0x3f00, 0x3D00, 0x3E00, 64, 4),
|
|
(0x3d00, 0x3e00, 0x3E00, 0x3F00, 64, 4),
|
|
(0x3c00, 0x3d00, 0x3F00, 0x4000, 64, 4),
|
|
(0x4300, 0x4400, 0x4000, 0x4100, 64, 4),
|
|
(0x4200, 0x4300, 0x4100, 0x4200, 64, 4),
|
|
(0x4100, 0x4200, 0x4200, 0x4300, 64, 4),
|
|
(0x4000, 0x4100, 0x4300, 0x4400, 64, 4),
|
|
(0x4700, 0x4760, 0x4400, 0x4460, 32, 3), # End of Ch Data
|
|
(0x4760, 0x4800, 0x4460, 0x4500, 32, 5), # start of Ch names
|
|
(0x4600, 0x4700, 0x4500, 0x4600, 64, 4),
|
|
(0x4500, 0x4600, 0x4600, 0x4700, 64, 4),
|
|
(0x4400, 0x4500, 0x4700, 0x4800, 64, 4),
|
|
(0x4b00, 0x4c00, 0x4800, 0x4900, 64, 4),
|
|
(0x4a00, 0x4B00, 0x4900, 0x4A00, 64, 4),
|
|
(0x4900, 0x4a00, 0x4A00, 0x4B00, 64, 4),
|
|
(0x4800, 0x4900, 0x4B00, 0x4C00, 64, 4),
|
|
(0x4f00, 0x5000, 0x4C00, 0x4D00, 64, 4),
|
|
(0x4E00, 0x4F00, 0x4D00, 0x4E00, 64, 4),
|
|
(0x4D00, 0x4E00, 0x4E00, 0x4F00, 64, 4),
|
|
(0x4C00, 0x4d00, 0x4F00, 0x5000, 64, 4),
|
|
(0x5300, 0x5400, 0x5000, 0x5100, 64, 4),
|
|
(0x5200, 0x5300, 0x5100, 0x5200, 64, 4),
|
|
(0x5100, 0x5200, 0x5200, 0x5300, 64, 4),
|
|
(0x5000, 0x5100, 0x5300, 0x5400, 64, 4),
|
|
(0x5700, 0x5800, 0x5400, 0x5500, 64, 4),
|
|
(0x5600, 0x5700, 0x5500, 0x5600, 64, 4),
|
|
(0x5500, 0x5600, 0x5600, 0x5700, 64, 4),
|
|
(0x5400, 0x5500, 0x5700, 0x5800, 64, 4),
|
|
(0x5B00, 0x5C00, 0x5800, 0x5900, 64, 4),
|
|
(0x5A00, 0x5B00, 0x5900, 0x5A00, 64, 4),
|
|
(0x5900, 0x5A00, 0x5A00, 0x5B00, 64, 4),
|
|
(0x5800, 0x5900, 0x5B00, 0x5C00, 64, 4),
|
|
(0x5F00, 0x6000, 0x5C00, 0x5D00, 64, 4),
|
|
(0x5E00, 0x5F00, 0x5D00, 0x5E00, 64, 4),
|
|
(0x5D00, 0x5E00, 0x5E00, 0x5F00, 64, 4),
|
|
(0x5C00, 0x5D00, 0x5F00, 0x6000, 64, 4),
|
|
(0x6300, 0x6400, 0x6000, 0x6100, 64, 4),
|
|
(0x6200, 0x6300, 0x6100, 0x6200, 64, 4),
|
|
(0x6100, 0x6200, 0x6200, 0x6300, 64, 4),
|
|
(0x6000, 0x6100, 0x6300, 0x6400, 64, 4),
|
|
(0x6700, 0x6800, 0x6400, 0x6500, 64, 4),
|
|
(0x6600, 0x6700, 0x6500, 0x6600, 64, 4),
|
|
(0x6500, 0x6600, 0x6600, 0x6700, 64, 4),
|
|
(0x6400, 0x6500, 0x6700, 0x6800, 64, 4),
|
|
(0x6b00, 0x6c00, 0x6800, 0x6900, 64, 4),
|
|
(0x6a00, 0x6b00, 0x6900, 0x6A00, 64, 4),
|
|
(0x6900, 0x6a00, 0x6A00, 0x6B00, 64, 4),
|
|
(0x6800, 0x6900, 0x6B00, 0x6C00, 64, 4),
|
|
(0x6F00, 0x7000, 0x6C00, 0x6D00, 64, 4),
|
|
(0x6e00, 0x6F00, 0x6D00, 0x6E00, 64, 4),
|
|
(0x6D00, 0x6E00, 0x6E00, 0x6F00, 64, 4),
|
|
(0x6C00, 0x6D00, 0x6F00, 0x7000, 64, 4),
|
|
(0x7300, 0x7400, 0x7000, 0x7100, 64, 4),
|
|
(0x7200, 0x7300, 0x7100, 0x7200, 64, 4),
|
|
(0x7100, 0x7200, 0x7200, 0x7300, 64, 4),
|
|
(0x7000, 0x7040, 0x7300, 0x7340, 64, 1), # End of Ch Names
|
|
(0x7040, 0x7100, 0x7340, 0x7400, 64, 3), # start of ch valid
|
|
(0x7700, 0x7800, 0x7400, 0x7500, 64, 4),
|
|
(0x7600, 0x7700, 0x7500, 0x7600, 64, 4),
|
|
(0x7500, 0x7600, 0x7600, 0x7700, 64, 4),
|
|
(0x7400, 0x7440, 0x7700, 0x7740, 64, 1), # end of ch valid
|
|
(0x7440, 0x74e0, 0x7740, 0x77e0, 32, 5), # scan groups
|
|
(0x74e0, 0x74e8, 0x77e0, 0x77e8, 8, 1), # VFO Scan range
|
|
(0x7bB0, 0x7c00, 0x78B0, 0x7900, 16, 5), # FM presets / Call ID Start
|
|
(0x7a00, 0x7b00, 0x7900, 0x7A00, 64, 4),
|
|
(0x7900, 0x7a00, 0x7A00, 0x7B00, 64, 4),
|
|
(0x7800, 0x7900, 0x7B00, 0x7C00, 64, 4), # Call ID end / Call Name Start
|
|
(0x7f00, 0x8000, 0x7C00, 0x7D00, 64, 4),
|
|
(0x7e00, 0x7f00, 0x7D00, 0x7E00, 64, 4),
|
|
(0x7d00, 0x7e00, 0x7E00, 0x7F00, 64, 4),
|
|
(0x7c00, 0x7d00, 0x7F00, 0x8000, 64, 4), # Call Name End
|
|
)
|
|
|
|
Q10H_upload_map_nolims = (
|
|
# This map serves 2 purposes-
|
|
# To limit the Upload to Radio Writes to known settings only
|
|
# And also to send the rearranged Chirp Memory data back to the radio
|
|
# using the proper radio addresses.
|
|
# Radio Radio Chirp Chirp Blk cnt
|
|
# start end start end sz
|
|
# (0x0300, 0x0400, 0x0000, 0x0100, 64, 4),
|
|
# (0x0200, 0x0300, 0x0100, 0x0200, 64, 4),
|
|
# (0x0100, 0x0200, 0x0200, 0x0300, 64, 4),
|
|
(0x030A, 0x030A, 0x000a, 0x000a, 1, 1), # Unlock
|
|
(0x0040, 0x0100, 0x0340, 0x0400, 64, 3), # settings
|
|
(0x0700, 0x0800, 0x0400, 0x0500, 64, 4), # channel data
|
|
(0x0600, 0x0700, 0x0500, 0x0600, 64, 4),
|
|
(0x0500, 0x0600, 0x0600, 0x0700, 64, 4),
|
|
(0x0400, 0x0500, 0x0700, 0x0800, 64, 4),
|
|
(0x0b00, 0x0c00, 0x0800, 0x0900, 64, 4),
|
|
(0x0a00, 0x0b00, 0x0900, 0x0A00, 64, 4),
|
|
(0x0900, 0x0a00, 0x0A00, 0x0B00, 64, 4),
|
|
(0x0800, 0x0900, 0x0B00, 0x0C00, 64, 4),
|
|
(0x0f00, 0x1000, 0x0C00, 0x0D00, 64, 4),
|
|
(0x0e00, 0x0f00, 0x0D00, 0x0E00, 64, 4),
|
|
(0x0d00, 0x0e00, 0x0E00, 0x0F00, 64, 4),
|
|
(0x0c00, 0x0d00, 0x0F00, 0x1000, 64, 4),
|
|
(0x1300, 0x1400, 0x1000, 0x1100, 64, 4),
|
|
(0x1200, 0x1300, 0x1100, 0x1200, 64, 4),
|
|
(0x1100, 0x1200, 0x1200, 0x1300, 64, 4),
|
|
(0x1000, 0x1100, 0x1300, 0x1400, 64, 4),
|
|
(0x1700, 0x1800, 0x1400, 0x1500, 64, 4),
|
|
(0x1600, 0x1700, 0x1500, 0x1600, 64, 4),
|
|
(0x1500, 0x1600, 0x1600, 0x1700, 64, 4),
|
|
(0x1400, 0x1500, 0x1700, 0x1800, 64, 4),
|
|
(0x1B00, 0x1c00, 0x1800, 0x1900, 64, 4),
|
|
(0x1a00, 0x1b00, 0x1900, 0x1A00, 64, 4),
|
|
(0x1900, 0x1a00, 0x1A00, 0x1B00, 64, 4),
|
|
(0x1800, 0x1900, 0x1B00, 0x1C00, 64, 4),
|
|
(0x1f00, 0x2000, 0x1C00, 0x1D00, 64, 4),
|
|
(0x1e00, 0x1f00, 0x1D00, 0x1E00, 64, 4),
|
|
(0x1d00, 0x1e00, 0x1E00, 0x1F00, 64, 4),
|
|
(0x1c00, 0x1d00, 0x1F00, 0x2000, 64, 4),
|
|
(0x2300, 0x2400, 0x2000, 0x2100, 64, 4),
|
|
(0x2200, 0x2300, 0x2100, 0x2200, 64, 4),
|
|
(0x2100, 0x2200, 0x2200, 0x2300, 64, 4),
|
|
(0x2000, 0x2100, 0x2300, 0x2400, 64, 4),
|
|
(0x2700, 0x2800, 0x2400, 0x2500, 64, 4),
|
|
(0x2600, 0x2700, 0x2500, 0x2600, 64, 4),
|
|
(0x2500, 0x2600, 0x2600, 0x2700, 64, 4),
|
|
(0x2400, 0x2500, 0x2700, 0x2800, 64, 4),
|
|
(0x2B00, 0x2C00, 0x2800, 0x2900, 64, 4),
|
|
(0x2a00, 0x2b00, 0x2900, 0x2A00, 64, 4),
|
|
(0x2900, 0x2a00, 0x2A00, 0x2B00, 64, 4),
|
|
(0x2800, 0x2900, 0x2B00, 0x2C00, 64, 4),
|
|
(0x2f00, 0x3000, 0x2C00, 0x2D00, 64, 4),
|
|
(0x2e00, 0x2f00, 0x2D00, 0x2E00, 64, 4),
|
|
(0x2d00, 0x2e00, 0x2E00, 0x2F00, 64, 4),
|
|
(0x2c00, 0x2d00, 0x2F00, 0x3000, 64, 4),
|
|
(0x3300, 0x3400, 0x3000, 0x3100, 64, 4),
|
|
(0x3200, 0x3300, 0x3100, 0x3200, 64, 4),
|
|
(0x3100, 0x3200, 0x3200, 0x3300, 64, 4),
|
|
(0x3000, 0x3100, 0x3300, 0x3400, 64, 4),
|
|
(0x3700, 0x3800, 0x3400, 0x3500, 64, 4),
|
|
(0x3600, 0x3700, 0x3500, 0x3600, 64, 4),
|
|
(0x3500, 0x3600, 0x3600, 0x3700, 64, 4),
|
|
(0x3400, 0x3500, 0x3700, 0x3800, 64, 4),
|
|
(0x3B00, 0x3C00, 0x3800, 0x3900, 64, 4),
|
|
(0x3a00, 0x3b00, 0x3900, 0x3A00, 64, 4),
|
|
(0x3900, 0x3a00, 0x3A00, 0x3B00, 64, 4),
|
|
(0x3800, 0x3900, 0x3B00, 0x3C00, 64, 4),
|
|
(0x3f00, 0x4000, 0x3C00, 0x3D00, 64, 4),
|
|
(0x3e00, 0x3f00, 0x3D00, 0x3E00, 64, 4),
|
|
(0x3d00, 0x3e00, 0x3E00, 0x3F00, 64, 4),
|
|
(0x3c00, 0x3d00, 0x3F00, 0x4000, 64, 4),
|
|
(0x4300, 0x4400, 0x4000, 0x4100, 64, 4),
|
|
(0x4200, 0x4300, 0x4100, 0x4200, 64, 4),
|
|
(0x4100, 0x4200, 0x4200, 0x4300, 64, 4),
|
|
(0x4000, 0x4100, 0x4300, 0x4400, 64, 4),
|
|
(0x4700, 0x4760, 0x4400, 0x4460, 32, 3), # End of Ch Data
|
|
(0x4760, 0x4800, 0x4460, 0x4500, 32, 5), # start of Ch names
|
|
(0x4600, 0x4700, 0x4500, 0x4600, 64, 4),
|
|
(0x4500, 0x4600, 0x4600, 0x4700, 64, 4),
|
|
(0x4400, 0x4500, 0x4700, 0x4800, 64, 4),
|
|
(0x4b00, 0x4c00, 0x4800, 0x4900, 64, 4),
|
|
(0x4a00, 0x4B00, 0x4900, 0x4A00, 64, 4),
|
|
(0x4900, 0x4a00, 0x4A00, 0x4B00, 64, 4),
|
|
(0x4800, 0x4900, 0x4B00, 0x4C00, 64, 4),
|
|
(0x4f00, 0x5000, 0x4C00, 0x4D00, 64, 4),
|
|
(0x4E00, 0x4F00, 0x4D00, 0x4E00, 64, 4),
|
|
(0x4D00, 0x4E00, 0x4E00, 0x4F00, 64, 4),
|
|
(0x4C00, 0x4d00, 0x4F00, 0x5000, 64, 4),
|
|
(0x5300, 0x5400, 0x5000, 0x5100, 64, 4),
|
|
(0x5200, 0x5300, 0x5100, 0x5200, 64, 4),
|
|
(0x5100, 0x5200, 0x5200, 0x5300, 64, 4),
|
|
(0x5000, 0x5100, 0x5300, 0x5400, 64, 4),
|
|
(0x5700, 0x5800, 0x5400, 0x5500, 64, 4),
|
|
(0x5600, 0x5700, 0x5500, 0x5600, 64, 4),
|
|
(0x5500, 0x5600, 0x5600, 0x5700, 64, 4),
|
|
(0x5400, 0x5500, 0x5700, 0x5800, 64, 4),
|
|
(0x5B00, 0x5C00, 0x5800, 0x5900, 64, 4),
|
|
(0x5A00, 0x5B00, 0x5900, 0x5A00, 64, 4),
|
|
(0x5900, 0x5A00, 0x5A00, 0x5B00, 64, 4),
|
|
(0x5800, 0x5900, 0x5B00, 0x5C00, 64, 4),
|
|
(0x5F00, 0x6000, 0x5C00, 0x5D00, 64, 4),
|
|
(0x5E00, 0x5F00, 0x5D00, 0x5E00, 64, 4),
|
|
(0x5D00, 0x5E00, 0x5E00, 0x5F00, 64, 4),
|
|
(0x5C00, 0x5D00, 0x5F00, 0x6000, 64, 4),
|
|
(0x6300, 0x6400, 0x6000, 0x6100, 64, 4),
|
|
(0x6200, 0x6300, 0x6100, 0x6200, 64, 4),
|
|
(0x6100, 0x6200, 0x6200, 0x6300, 64, 4),
|
|
(0x6000, 0x6100, 0x6300, 0x6400, 64, 4),
|
|
(0x6700, 0x6800, 0x6400, 0x6500, 64, 4),
|
|
(0x6600, 0x6700, 0x6500, 0x6600, 64, 4),
|
|
(0x6500, 0x6600, 0x6600, 0x6700, 64, 4),
|
|
(0x6400, 0x6500, 0x6700, 0x6800, 64, 4),
|
|
(0x6b00, 0x6c00, 0x6800, 0x6900, 64, 4),
|
|
(0x6a00, 0x6b00, 0x6900, 0x6A00, 64, 4),
|
|
(0x6900, 0x6a00, 0x6A00, 0x6B00, 64, 4),
|
|
(0x6800, 0x6900, 0x6B00, 0x6C00, 64, 4),
|
|
(0x6F00, 0x7000, 0x6C00, 0x6D00, 64, 4),
|
|
(0x6e00, 0x6F00, 0x6D00, 0x6E00, 64, 4),
|
|
(0x6D00, 0x6E00, 0x6E00, 0x6F00, 64, 4),
|
|
(0x6C00, 0x6D00, 0x6F00, 0x7000, 64, 4),
|
|
(0x7300, 0x7400, 0x7000, 0x7100, 64, 4),
|
|
(0x7200, 0x7300, 0x7100, 0x7200, 64, 4),
|
|
(0x7100, 0x7200, 0x7200, 0x7300, 64, 4),
|
|
(0x7000, 0x7040, 0x7300, 0x7340, 64, 1), # End of Ch Names
|
|
(0x7040, 0x7100, 0x7340, 0x7400, 64, 3), # start of ch valid
|
|
(0x7700, 0x7800, 0x7400, 0x7500, 64, 4),
|
|
(0x7600, 0x7700, 0x7500, 0x7600, 64, 4),
|
|
(0x7500, 0x7600, 0x7600, 0x7700, 64, 4),
|
|
(0x7400, 0x7440, 0x7700, 0x7740, 64, 1), # end of ch valid
|
|
(0x7440, 0x74e0, 0x7740, 0x77e0, 32, 5), # scan groups
|
|
(0x74e0, 0x74e8, 0x77e0, 0x77e8, 8, 1), # VFO Scan range
|
|
(0x7bB0, 0x7c00, 0x78B0, 0x7900, 16, 5), # FM presets / Call ID Start
|
|
(0x7a00, 0x7b00, 0x7900, 0x7A00, 64, 4),
|
|
(0x7900, 0x7a00, 0x7A00, 0x7B00, 64, 4),
|
|
(0x7800, 0x7900, 0x7B00, 0x7C00, 64, 4), # Call ID end / Call Name Start
|
|
(0x7f00, 0x8000, 0x7C00, 0x7D00, 64, 4),
|
|
(0x7e00, 0x7f00, 0x7D00, 0x7E00, 64, 4),
|
|
(0x7d00, 0x7e00, 0x7E00, 0x7F00, 64, 4),
|
|
(0x7c00, 0x7d00, 0x7F00, 0x8000, 64, 4), # Call Name End
|
|
)
|
|
|
|
Q10G_upload_map_nolims = (
|
|
# This map serves 2 purposes-
|
|
# To limit the Upload to Radio Writes to known settings only
|
|
# And also to send the rearranged Chirp Memory data back to the radio
|
|
# using the proper radio addresses.
|
|
# Radio Radio Chirp Chirp Blk cnt
|
|
# start end start end sz
|
|
# (0x0300, 0x0400, 0x0000, 0x0100, 64, 4),
|
|
# (0x0200, 0x0300, 0x0100, 0x0200, 64, 4),
|
|
# (0x0100, 0x0200, 0x0200, 0x0300, 64, 4),
|
|
# (0x030A, 0x030A, 0x000a, 0x000a, 1, 1), # Unlock
|
|
(0x0040, 0x0100, 0x0340, 0x0400, 64, 3), # settings
|
|
(0x0700, 0x0800, 0x0400, 0x0500, 64, 4), # channel data
|
|
(0x0600, 0x0700, 0x0500, 0x0600, 64, 4),
|
|
(0x0500, 0x0600, 0x0600, 0x0700, 64, 4),
|
|
(0x0400, 0x0500, 0x0700, 0x0800, 64, 4),
|
|
(0x0b00, 0x0c00, 0x0800, 0x0900, 64, 4),
|
|
(0x0a00, 0x0b00, 0x0900, 0x0A00, 64, 4),
|
|
(0x0900, 0x0a00, 0x0A00, 0x0B00, 64, 4),
|
|
(0x0800, 0x0900, 0x0B00, 0x0C00, 64, 4),
|
|
(0x0f00, 0x1000, 0x0C00, 0x0D00, 64, 4),
|
|
(0x0e00, 0x0f00, 0x0D00, 0x0E00, 64, 4),
|
|
(0x0d00, 0x0e00, 0x0E00, 0x0F00, 64, 4),
|
|
(0x0c00, 0x0d00, 0x0F00, 0x1000, 64, 4),
|
|
(0x1300, 0x1400, 0x1000, 0x1100, 64, 4),
|
|
(0x1200, 0x1300, 0x1100, 0x1200, 64, 4),
|
|
(0x1100, 0x1200, 0x1200, 0x1300, 64, 4),
|
|
(0x1000, 0x1100, 0x1300, 0x1400, 64, 4),
|
|
(0x1700, 0x1800, 0x1400, 0x1500, 64, 4),
|
|
(0x1600, 0x1700, 0x1500, 0x1600, 64, 4),
|
|
(0x1500, 0x1600, 0x1600, 0x1700, 64, 4),
|
|
(0x1400, 0x1500, 0x1700, 0x1800, 64, 4),
|
|
(0x1B00, 0x1c00, 0x1800, 0x1900, 64, 4),
|
|
(0x1a00, 0x1b00, 0x1900, 0x1A00, 64, 4),
|
|
(0x1900, 0x1a00, 0x1A00, 0x1B00, 64, 4),
|
|
(0x1800, 0x1900, 0x1B00, 0x1C00, 64, 4),
|
|
(0x1f00, 0x2000, 0x1C00, 0x1D00, 64, 4),
|
|
(0x1e00, 0x1f00, 0x1D00, 0x1E00, 64, 4),
|
|
(0x1d00, 0x1e00, 0x1E00, 0x1F00, 64, 4),
|
|
(0x1c00, 0x1d00, 0x1F00, 0x2000, 64, 4),
|
|
(0x2300, 0x2400, 0x2000, 0x2100, 64, 4),
|
|
(0x2200, 0x2300, 0x2100, 0x2200, 64, 4),
|
|
(0x2100, 0x2200, 0x2200, 0x2300, 64, 4),
|
|
(0x2000, 0x2100, 0x2300, 0x2400, 64, 4),
|
|
(0x2700, 0x2800, 0x2400, 0x2500, 64, 4),
|
|
(0x2600, 0x2700, 0x2500, 0x2600, 64, 4),
|
|
(0x2500, 0x2600, 0x2600, 0x2700, 64, 4),
|
|
(0x2400, 0x2500, 0x2700, 0x2800, 64, 4),
|
|
(0x2B00, 0x2C00, 0x2800, 0x2900, 64, 4),
|
|
(0x2a00, 0x2b00, 0x2900, 0x2A00, 64, 4),
|
|
(0x2900, 0x2a00, 0x2A00, 0x2B00, 64, 4),
|
|
(0x2800, 0x2900, 0x2B00, 0x2C00, 64, 4),
|
|
(0x2f00, 0x3000, 0x2C00, 0x2D00, 64, 4),
|
|
(0x2e00, 0x2f00, 0x2D00, 0x2E00, 64, 4),
|
|
(0x2d00, 0x2e00, 0x2E00, 0x2F00, 64, 4),
|
|
(0x2c00, 0x2d00, 0x2F00, 0x3000, 64, 4),
|
|
(0x3300, 0x3400, 0x3000, 0x3100, 64, 4),
|
|
(0x3200, 0x3300, 0x3100, 0x3200, 64, 4),
|
|
(0x3100, 0x3200, 0x3200, 0x3300, 64, 4),
|
|
(0x3000, 0x3100, 0x3300, 0x3400, 64, 4),
|
|
(0x3700, 0x3800, 0x3400, 0x3500, 64, 4),
|
|
(0x3600, 0x3700, 0x3500, 0x3600, 64, 4),
|
|
(0x3500, 0x3600, 0x3600, 0x3700, 64, 4),
|
|
(0x3400, 0x3500, 0x3700, 0x3800, 64, 4),
|
|
(0x3B00, 0x3C00, 0x3800, 0x3900, 64, 4),
|
|
(0x3a00, 0x3b00, 0x3900, 0x3A00, 64, 4),
|
|
(0x3900, 0x3a00, 0x3A00, 0x3B00, 64, 4),
|
|
(0x3800, 0x3900, 0x3B00, 0x3C00, 64, 4),
|
|
(0x3f00, 0x4000, 0x3C00, 0x3D00, 64, 4),
|
|
(0x3e00, 0x3f00, 0x3D00, 0x3E00, 64, 4),
|
|
(0x3d00, 0x3e00, 0x3E00, 0x3F00, 64, 4),
|
|
(0x3c00, 0x3d00, 0x3F00, 0x4000, 64, 4),
|
|
(0x4300, 0x4400, 0x4000, 0x4100, 64, 4),
|
|
(0x4200, 0x4300, 0x4100, 0x4200, 64, 4),
|
|
(0x4100, 0x4200, 0x4200, 0x4300, 64, 4),
|
|
(0x4000, 0x4100, 0x4300, 0x4400, 64, 4),
|
|
(0x4700, 0x4760, 0x4400, 0x4460, 32, 3), # End of Ch Data
|
|
(0x4760, 0x4800, 0x4460, 0x4500, 32, 5), # start of Ch names
|
|
(0x4600, 0x4700, 0x4500, 0x4600, 64, 4),
|
|
(0x4500, 0x4600, 0x4600, 0x4700, 64, 4),
|
|
(0x4400, 0x4500, 0x4700, 0x4800, 64, 4),
|
|
(0x4b00, 0x4c00, 0x4800, 0x4900, 64, 4),
|
|
(0x4a00, 0x4B00, 0x4900, 0x4A00, 64, 4),
|
|
(0x4900, 0x4a00, 0x4A00, 0x4B00, 64, 4),
|
|
(0x4800, 0x4900, 0x4B00, 0x4C00, 64, 4),
|
|
(0x4f00, 0x5000, 0x4C00, 0x4D00, 64, 4),
|
|
(0x4E00, 0x4F00, 0x4D00, 0x4E00, 64, 4),
|
|
(0x4D00, 0x4E00, 0x4E00, 0x4F00, 64, 4),
|
|
(0x4C00, 0x4d00, 0x4F00, 0x5000, 64, 4),
|
|
(0x5300, 0x5400, 0x5000, 0x5100, 64, 4),
|
|
(0x5200, 0x5300, 0x5100, 0x5200, 64, 4),
|
|
(0x5100, 0x5200, 0x5200, 0x5300, 64, 4),
|
|
(0x5000, 0x5100, 0x5300, 0x5400, 64, 4),
|
|
(0x5700, 0x5800, 0x5400, 0x5500, 64, 4),
|
|
(0x5600, 0x5700, 0x5500, 0x5600, 64, 4),
|
|
(0x5500, 0x5600, 0x5600, 0x5700, 64, 4),
|
|
(0x5400, 0x5500, 0x5700, 0x5800, 64, 4),
|
|
(0x5B00, 0x5C00, 0x5800, 0x5900, 64, 4),
|
|
(0x5A00, 0x5B00, 0x5900, 0x5A00, 64, 4),
|
|
(0x5900, 0x5A00, 0x5A00, 0x5B00, 64, 4),
|
|
(0x5800, 0x5900, 0x5B00, 0x5C00, 64, 4),
|
|
(0x5F00, 0x6000, 0x5C00, 0x5D00, 64, 4),
|
|
(0x5E00, 0x5F00, 0x5D00, 0x5E00, 64, 4),
|
|
(0x5D00, 0x5E00, 0x5E00, 0x5F00, 64, 4),
|
|
(0x5C00, 0x5D00, 0x5F00, 0x6000, 64, 4),
|
|
(0x6300, 0x6400, 0x6000, 0x6100, 64, 4),
|
|
(0x6200, 0x6300, 0x6100, 0x6200, 64, 4),
|
|
(0x6100, 0x6200, 0x6200, 0x6300, 64, 4),
|
|
(0x6000, 0x6100, 0x6300, 0x6400, 64, 4),
|
|
(0x6700, 0x6800, 0x6400, 0x6500, 64, 4),
|
|
(0x6600, 0x6700, 0x6500, 0x6600, 64, 4),
|
|
(0x6500, 0x6600, 0x6600, 0x6700, 64, 4),
|
|
(0x6400, 0x6500, 0x6700, 0x6800, 64, 4),
|
|
(0x6b00, 0x6c00, 0x6800, 0x6900, 64, 4),
|
|
(0x6a00, 0x6b00, 0x6900, 0x6A00, 64, 4),
|
|
(0x6900, 0x6a00, 0x6A00, 0x6B00, 64, 4),
|
|
(0x6800, 0x6900, 0x6B00, 0x6C00, 64, 4),
|
|
(0x6F00, 0x7000, 0x6C00, 0x6D00, 64, 4),
|
|
(0x6e00, 0x6F00, 0x6D00, 0x6E00, 64, 4),
|
|
(0x6D00, 0x6E00, 0x6E00, 0x6F00, 64, 4),
|
|
(0x6C00, 0x6D00, 0x6F00, 0x7000, 64, 4),
|
|
(0x7300, 0x7400, 0x7000, 0x7100, 64, 4),
|
|
(0x7200, 0x7300, 0x7100, 0x7200, 64, 4),
|
|
(0x7100, 0x7200, 0x7200, 0x7300, 64, 4),
|
|
(0x7000, 0x7040, 0x7300, 0x7340, 64, 1), # End of Ch Names
|
|
(0x7040, 0x7100, 0x7340, 0x7400, 64, 3), # start of ch valid
|
|
(0x7700, 0x7800, 0x7400, 0x7500, 64, 4),
|
|
(0x7600, 0x7700, 0x7500, 0x7600, 64, 4),
|
|
(0x7500, 0x7600, 0x7600, 0x7700, 64, 4),
|
|
(0x7400, 0x7440, 0x7700, 0x7740, 64, 1), # end of ch valid
|
|
(0x7440, 0x74e0, 0x7740, 0x77e0, 32, 5), # scan groups
|
|
(0x74e0, 0x74e8, 0x77e0, 0x77e8, 8, 1), # VFO Scan range
|
|
(0x7bB0, 0x7c00, 0x78B0, 0x7900, 16, 5), # FM presets / Call ID Start
|
|
(0x7a00, 0x7b00, 0x7900, 0x7A00, 64, 4),
|
|
(0x7900, 0x7a00, 0x7A00, 0x7B00, 64, 4),
|
|
(0x7800, 0x7900, 0x7B00, 0x7C00, 64, 4), # Call ID end / Call Name Start
|
|
(0x7f00, 0x8000, 0x7C00, 0x7D00, 64, 4),
|
|
(0x7e00, 0x7f00, 0x7D00, 0x7E00, 64, 4),
|
|
(0x7d00, 0x7e00, 0x7E00, 0x7F00, 64, 4),
|
|
(0x7c00, 0x7d00, 0x7F00, 0x8000, 64, 4), # Call Name End
|
|
)
|
|
|
|
|
|
Q10H_upload_map_OLD = (
|
|
# OLD MAP before rearranging 0-400 - EVENTUALLY DELETE
|
|
# This map serves 2 purposes-
|
|
# To limit the Upload to Radio Writes to known settings only
|
|
# And also to send the rearranged Chirp Memory data back to the radio
|
|
# using the proper radio addresses.
|
|
# Radio Radio Chirp Chirp Blk cnt
|
|
# start end start end sz
|
|
# (0x0000, 0x0400, 0x0000, 0x0400, 64, 16),
|
|
# (0x0600, 0x06E0, 0x0400, 0x04E0, 32, 7),
|
|
(0x0002, 0x0022, 0x0002, 0x0022, 32, 1), # Tx Limits
|
|
(0x00a6, 0x00fe, 0x00a6, 0x00fe, 8, 11), # Rx Limits
|
|
(0x030a, 0x030a, 0x030a, 0x030a, 1, 1), # Factory Locked Mode
|
|
(0x0640, 0x06c0, 0x0440, 0x04c0, 32, 7), # VFO settings
|
|
(0x0700, 0x0800, 0x04E0, 0x05E0, 64, 4), # settings
|
|
(0x06E0, 0x0700, 0x05E0, 0x0600, 32, 1), # channel 1 data start
|
|
(0x0500, 0x0600, 0x0600, 0x0700, 64, 4),
|
|
(0x0400, 0x0500, 0x0700, 0x0800, 64, 4),
|
|
(0x0b00, 0x0c00, 0x0800, 0x0900, 64, 4),
|
|
(0x0a00, 0x0b00, 0x0900, 0x0A00, 64, 4),
|
|
(0x0900, 0x0a00, 0x0A00, 0x0B00, 64, 4),
|
|
(0x0800, 0x0900, 0x0B00, 0x0C00, 64, 4),
|
|
(0x0f00, 0x1000, 0x0C00, 0x0D00, 64, 4),
|
|
(0x0e00, 0x0f00, 0x0D00, 0x0E00, 64, 4),
|
|
(0x0d00, 0x0e00, 0x0E00, 0x0F00, 64, 4),
|
|
(0x0c00, 0x0d00, 0x0F00, 0x1000, 64, 4),
|
|
(0x1300, 0x1400, 0x1000, 0x1100, 64, 4),
|
|
(0x1200, 0x1300, 0x1100, 0x1200, 64, 4),
|
|
(0x1100, 0x1200, 0x1200, 0x1300, 64, 4),
|
|
(0x1000, 0x1100, 0x1300, 0x1400, 64, 4),
|
|
(0x1700, 0x1800, 0x1400, 0x1500, 64, 4),
|
|
(0x1600, 0x1700, 0x1500, 0x1600, 64, 4),
|
|
(0x1500, 0x1600, 0x1600, 0x1700, 64, 4),
|
|
(0x1400, 0x1500, 0x1700, 0x1800, 64, 4),
|
|
(0x1B00, 0x1c00, 0x1800, 0x1900, 64, 4),
|
|
(0x1a00, 0x1b00, 0x1900, 0x1A00, 64, 4),
|
|
(0x1900, 0x1a00, 0x1A00, 0x1B00, 64, 4),
|
|
(0x1800, 0x1900, 0x1B00, 0x1C00, 64, 4),
|
|
(0x1f00, 0x2000, 0x1C00, 0x1D00, 64, 4),
|
|
(0x1e00, 0x1f00, 0x1D00, 0x1E00, 64, 4),
|
|
(0x1d00, 0x1e00, 0x1E00, 0x1F00, 64, 4),
|
|
(0x1c00, 0x1d00, 0x1F00, 0x2000, 64, 4),
|
|
(0x2300, 0x2400, 0x2000, 0x2100, 64, 4),
|
|
(0x2200, 0x2300, 0x2100, 0x2200, 64, 4),
|
|
(0x2100, 0x2200, 0x2200, 0x2300, 64, 4),
|
|
(0x2000, 0x2100, 0x2300, 0x2400, 64, 4),
|
|
(0x2700, 0x2800, 0x2400, 0x2500, 64, 4),
|
|
(0x2600, 0x2700, 0x2500, 0x2600, 64, 4),
|
|
(0x2500, 0x2600, 0x2600, 0x2700, 64, 4),
|
|
(0x2400, 0x2500, 0x2700, 0x2800, 64, 4),
|
|
(0x2B00, 0x2C00, 0x2800, 0x2900, 64, 4),
|
|
(0x2a00, 0x2b00, 0x2900, 0x2A00, 64, 4),
|
|
(0x2900, 0x2a00, 0x2A00, 0x2B00, 64, 4),
|
|
(0x2800, 0x2900, 0x2B00, 0x2C00, 64, 4),
|
|
(0x2f00, 0x3000, 0x2C00, 0x2D00, 64, 4),
|
|
(0x2e00, 0x2f00, 0x2D00, 0x2E00, 64, 4),
|
|
(0x2d00, 0x2e00, 0x2E00, 0x2F00, 64, 4),
|
|
(0x2c00, 0x2d00, 0x2F00, 0x3000, 64, 4),
|
|
(0x3300, 0x3400, 0x3000, 0x3100, 64, 4),
|
|
(0x3200, 0x3300, 0x3100, 0x3200, 64, 4),
|
|
(0x3100, 0x3200, 0x3200, 0x3300, 64, 4),
|
|
(0x3000, 0x3100, 0x3300, 0x3400, 64, 4),
|
|
(0x3700, 0x3800, 0x3400, 0x3500, 64, 4),
|
|
(0x3600, 0x3700, 0x3500, 0x3600, 64, 4),
|
|
(0x3500, 0x3600, 0x3600, 0x3700, 64, 4),
|
|
(0x3400, 0x3500, 0x3700, 0x3800, 64, 4),
|
|
(0x3B00, 0x3C00, 0x3800, 0x3900, 64, 4),
|
|
(0x3a00, 0x3b00, 0x3900, 0x3A00, 64, 4),
|
|
(0x3900, 0x3a00, 0x3A00, 0x3B00, 64, 4),
|
|
(0x3800, 0x3900, 0x3B00, 0x3C00, 64, 4),
|
|
(0x3f00, 0x4000, 0x3C00, 0x3D00, 64, 4),
|
|
(0x3e00, 0x3f00, 0x3D00, 0x3E00, 64, 4),
|
|
(0x3d00, 0x3e00, 0x3E00, 0x3F00, 64, 4),
|
|
(0x3c00, 0x3d00, 0x3F00, 0x4000, 64, 4),
|
|
(0x4300, 0x4400, 0x4000, 0x4100, 64, 4),
|
|
(0x4200, 0x4300, 0x4100, 0x4200, 64, 4),
|
|
(0x4100, 0x4200, 0x4200, 0x4300, 64, 4),
|
|
(0x4000, 0x4100, 0x4300, 0x4400, 64, 4),
|
|
(0x4700, 0x4760, 0x4400, 0x4460, 32, 3), # End of Ch Data
|
|
(0x4760, 0x4800, 0x4460, 0x4500, 32, 5), # start of Ch names
|
|
(0x4600, 0x4700, 0x4500, 0x4600, 64, 4),
|
|
(0x4500, 0x4600, 0x4600, 0x4700, 64, 4),
|
|
(0x4400, 0x4500, 0x4700, 0x4800, 64, 4),
|
|
(0x4b00, 0x4c00, 0x4800, 0x4900, 64, 4),
|
|
(0x4a00, 0x4B00, 0x4900, 0x4A00, 64, 4),
|
|
(0x4900, 0x4a00, 0x4A00, 0x4B00, 64, 4),
|
|
(0x4800, 0x4900, 0x4B00, 0x4C00, 64, 4),
|
|
(0x4f00, 0x5000, 0x4C00, 0x4D00, 64, 4),
|
|
(0x4E00, 0x4F00, 0x4D00, 0x4E00, 64, 4),
|
|
(0x4D00, 0x4E00, 0x4E00, 0x4F00, 64, 4),
|
|
(0x4C00, 0x4d00, 0x4F00, 0x5000, 64, 4),
|
|
(0x5300, 0x5400, 0x5000, 0x5100, 64, 4),
|
|
(0x5200, 0x5300, 0x5100, 0x5200, 64, 4),
|
|
(0x5100, 0x5200, 0x5200, 0x5300, 64, 4),
|
|
(0x5000, 0x5100, 0x5300, 0x5400, 64, 4),
|
|
(0x5700, 0x5800, 0x5400, 0x5500, 64, 4),
|
|
(0x5600, 0x5700, 0x5500, 0x5600, 64, 4),
|
|
(0x5500, 0x5600, 0x5600, 0x5700, 64, 4),
|
|
(0x5400, 0x5500, 0x5700, 0x5800, 64, 4),
|
|
(0x5B00, 0x5C00, 0x5800, 0x5900, 64, 4),
|
|
(0x5A00, 0x5B00, 0x5900, 0x5A00, 64, 4),
|
|
(0x5900, 0x5A00, 0x5A00, 0x5B00, 64, 4),
|
|
(0x5800, 0x5900, 0x5B00, 0x5C00, 64, 4),
|
|
(0x5F00, 0x6000, 0x5C00, 0x5D00, 64, 4),
|
|
(0x5E00, 0x5F00, 0x5D00, 0x5E00, 64, 4),
|
|
(0x5D00, 0x5E00, 0x5E00, 0x5F00, 64, 4),
|
|
(0x5C00, 0x5D00, 0x5F00, 0x6000, 64, 4),
|
|
(0x6300, 0x6400, 0x6000, 0x6100, 64, 4),
|
|
(0x6200, 0x6300, 0x6100, 0x6200, 64, 4),
|
|
(0x6100, 0x6200, 0x6200, 0x6300, 64, 4),
|
|
(0x6000, 0x6100, 0x6300, 0x6400, 64, 4),
|
|
(0x6700, 0x6800, 0x6400, 0x6500, 64, 4),
|
|
(0x6600, 0x6700, 0x6500, 0x6600, 64, 4),
|
|
(0x6500, 0x6600, 0x6600, 0x6700, 64, 4),
|
|
(0x6400, 0x6500, 0x6700, 0x6800, 64, 4),
|
|
(0x6b00, 0x6c00, 0x6800, 0x6900, 64, 4),
|
|
(0x6a00, 0x6b00, 0x6900, 0x6A00, 64, 4),
|
|
(0x6900, 0x6a00, 0x6A00, 0x6B00, 64, 4),
|
|
(0x6800, 0x6900, 0x6B00, 0x6C00, 64, 4),
|
|
(0x6F00, 0x7000, 0x6C00, 0x6D00, 64, 4),
|
|
(0x6e00, 0x6F00, 0x6D00, 0x6E00, 64, 4),
|
|
(0x6D00, 0x6E00, 0x6E00, 0x6F00, 64, 4),
|
|
(0x6C00, 0x6D00, 0x6F00, 0x7000, 64, 4),
|
|
(0x7300, 0x7400, 0x7000, 0x7100, 64, 4),
|
|
(0x7200, 0x7300, 0x7100, 0x7200, 64, 4),
|
|
(0x7100, 0x7200, 0x7200, 0x7300, 64, 4),
|
|
(0x7000, 0x7040, 0x7300, 0x7340, 64, 1), # End of Ch Names
|
|
(0x7040, 0x7100, 0x7340, 0x7400, 64, 3), # start of ch valid
|
|
(0x7700, 0x7800, 0x7400, 0x7500, 64, 4),
|
|
(0x7600, 0x7700, 0x7500, 0x7600, 64, 4),
|
|
(0x7500, 0x7600, 0x7600, 0x7700, 64, 4),
|
|
(0x7400, 0x7440, 0x7700, 0x7740, 64, 1), # end of ch valid
|
|
# (0x7440, 0x7500, 0x7740, 0x7800, 64, 3),
|
|
(0x7440, 0x74e0, 0x7740, 0x77e0, 32, 5), # scan groups
|
|
(0x74e0, 0x74e8, 0x77e0, 0x77e8, 8, 1), # VFO Scan range
|
|
# (0x7800, 0x8000, 0x7800, 0x8000, 64, 32),
|
|
(0x7bB0, 0x7c00, 0x78B0, 0x7900, 16, 5), # FM presets / Call ID Start
|
|
(0x7a00, 0x7b00, 0x7900, 0x7A00, 64, 4),
|
|
(0x7900, 0x7a00, 0x7A00, 0x7B00, 64, 4),
|
|
(0x7800, 0x7900, 0x7B00, 0x7C00, 64, 4), # Call ID end / Call Name Start
|
|
(0x7f00, 0x8000, 0x7C00, 0x7D00, 64, 4),
|
|
(0x7e00, 0x7f00, 0x7D00, 0x7E00, 64, 4),
|
|
(0x7d00, 0x7e00, 0x7E00, 0x7F00, 64, 4),
|
|
(0x7c00, 0x7d00, 0x7F00, 0x8000, 64, 4), # Call Name End
|
|
# (0x7bb0, 0x7bf0, 0x7bb0, 0x7bf0, 16, 3) # FM Radio Presets
|
|
)
|
|
|
|
# This map contains 4 values
|
|
# 1st entry is Physical Address that radio Uses for data
|
|
# 2nd entry is block size to write
|
|
# 3rd entry is number of blocks to write
|
|
# 4th entry is the memory address Chirp is using for data
|
|
# Essentially, the Q10H does not store channel memory infomation in contiguous
|
|
# blocks
|
|
# so the driver reads the data in a specific address order to allow Chirp to
|
|
# have the data in a contiguous data address range. This TABLE reverses the
|
|
# contiguous to the non-contiguous addressing that the radio is using.
|
|
# Bad Wouxun - this is just obfuscation to try and thwart 3rd party
|
|
# programmers
|
|
|
|
Q10H_upload_mapfull = (
|
|
# - Use for full radio address order upload testing
|
|
(0x0000, 0x8000, 0x0000, 0x8000, 64, 512),
|
|
)
|
|
|
|
AB_LIST = ["A", "B"]
|
|
STEPS = [2.5, 5.0, 6.25, 8.33, 10.0, 12.5, 25.0, 50.0, 100.0]
|
|
STEP_LIST = [str(x) + "k" for x in STEPS]
|
|
STEPS2 = [2.5, 5.0, 6.25, 8.33, 10.0, 12.5, 20.0, 25.0, 50.0, 100.0]
|
|
STEP2_LIST = [str(x) + "k" for x in STEPS2]
|
|
ROGER_LIST = ["OFF", "Begin", "End", "Both"]
|
|
TIMEOUT_LIST = ["OFF"] + [str(x) + "s" for x in range(15, 901, 15)]
|
|
BANDWIDTH_LIST = ["Narrow", "Wide"]
|
|
SCANMODE_LIST = ["TO", "CO", "SE"]
|
|
# PFKEYLONG_LIST = ["undef", "FRQ2-PTT", "Selec Call", "Scan", "Flashlight",
|
|
# "Alarm", "SOS", "FM Radio", "Moni", "Strobe", "Weather",
|
|
# "Tlk A", "Reverse", "CTC Scan", "DCS Scan", "BRT"]
|
|
# PFKEYSHORT_LIST = ["undef", "Scan", "Flashlight", "Alarm", "SOS", "FM Radio",
|
|
# "Moni", "Strobe", "Weather", "Tlk A", "Reverse",
|
|
# "CTC Scan", "DCS Scan", "BRT"]
|
|
|
|
# PFKEYLONG_LIST = ["undef", "FRQ2-PTT", "Selec Call", "Favorite",
|
|
# "Bright+", "Scan", "Flashlight", "Alarm", "SOS",
|
|
# "FM Radio", "Moni", "Strobe", "Weather", "Tlk A",
|
|
# "Reverse", "CTC Scan", "DCS Scan", "Backlight"]
|
|
# PFKEYSHORT_LIST = ["undef", "Favorite", "Bright+", "Scan",
|
|
# "Flashlight", "Alarm", "SOS", "FM Radio",
|
|
# "Moni", "Strobe", "Weather", "Tlk A", "Reverse",
|
|
# "CTC Scan", "DCS Scan", "Backlight"]
|
|
WORKMODE_LIST = ["VFO", "Ch.Number.", "Ch.Freq.", "Ch.Name"]
|
|
BACKLIGHT_LIST = ["Always On"] + [str(x) + "s" for x in range(1, 21)] + \
|
|
["Always Off"]
|
|
OFFSET_LIST = ["OFF", "Plus Shift", "Minus Shift"]
|
|
PONMSG_LIST = ["Startup Display", "Battery Volts"]
|
|
SPMUTE_LIST = ["QT", "QT+DTMF", "QT*DTMF"]
|
|
DTMFST_LIST = ["OFF", "DTMF", "ANI", "DTMF+ANI"]
|
|
DTMF_TIMES = [('%dms' % dtmf, (dtmf // 10)) for dtmf in range(50, 501, 10)]
|
|
ALERTS = [1750, 2100, 1000, 1450]
|
|
ALERTS_LIST = [str(x) + " Hz" for x in ALERTS]
|
|
PTTID_LIST = ["OFF", "BOT", "EOT", "Both"]
|
|
MAP_1_99 = [(str(x), x) for x in range(1, 100)]
|
|
LIST_10 = ["OFF"] + ["%s" % x for x in range(1, 11)]
|
|
LIST_10S = ["OFF"] + ["%s" % x + "s" for x in range(1, 11)]
|
|
LIST_TOA = ["OFF"] + ["%s" % x + "s" for x in range(1, 11)]
|
|
SCANGRP_LIST = ["All"] + ["%s" % x for x in range(1, 11)]
|
|
SMUTESET_LIST = ["OFF", "Rx", "Tx", "Rx+Tx"]
|
|
POWER_LIST = ["Lo", "Mid", "Hi", "UltraHigh"]
|
|
HOLD_TIMES = ["OFF"] + ["%s" % x + "s" for x in range(100, 5001, 100)]
|
|
RPTTYPE_MAP = [("X-DIRPT", 1), ("X-TWRPT", 2)]
|
|
THEME_LIST = ["White-1", "White-2", "Black-1", "Black-2",
|
|
"Cool", "Rain", "NotARubi", "Sky", "BTWR", "Candy",
|
|
"Custom 1", "Custom 2", "Custom 3", "Custom 4"]
|
|
DSPBRTSBY_LIST = ["OFF", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
|
|
DSPBRTACT_MAP = [("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5),
|
|
("6", 6), ("7", 7), ("8", 8), ("9", 9), ("10", 10)]
|
|
TONESCANSAVELIST = ["Rx", "Tx", "Tx/Rx"]
|
|
PTTDELAY_TIMES = [('%dms' % pttdelay,
|
|
(pttdelay // 100)) for pttdelay in range(100, 3001, 100)]
|
|
SCRAMBLE_LIST = ["OFF"] + [str(x) for x in range(1, 9)]
|
|
ONOFF_LIST = ["OFF", "ON"]
|
|
TONE_MAP = [('OFF - No Tone', 0x0000)] + \
|
|
[('%.1f' % tone,
|
|
int(0x8000 + tone * 10)) for tone in chirp_common.TONES] + \
|
|
[('D%03dn' % tone, int(0x4000 + int(str(tone), 8)))
|
|
for tone in chirp_common.DTCS_CODES] + \
|
|
[('D%03di' % tone, int(0x6000 + int(str(tone), 8)))
|
|
for tone in chirp_common.DTCS_CODES]
|
|
BATT_DISP_LIST = ["Icon", "Voltage", "Percent"]
|
|
WX_TYPE = ["Weather", "Icon-Only", "Tone", "Flash", "Tone-Flash"]
|
|
AM_MODE = ["OFF", "AM Rx", "AM Rx+Tx"]
|
|
AM_MODE_2 = ["OFF", "AM Rx"]
|
|
AM_MODE_CH = [("",0), ("AM Rx", 1), ("AM Rx+Tx", 2)]
|
|
AM_MODE_CH2 = [("",0), ("AM Rx", 1)]
|
|
|
|
TIME_ZONE = ["GMT-12", "GMT-11", "GMT-10", "GMT-9", "GMT-8",
|
|
"GMT-7", "GMT-6", "GMT-5", "GMT-4", "GMT-3",
|
|
"GMT-2", "GMT-1", "GMT", "GMT+1", "GMT+2",
|
|
"GMT+3", "GMT+4", "GMT+5", "GMT+6", "GMT+7",
|
|
"GMT+8", "GMT+9", "GMT+10", "GMT+11", "GMT+12"]
|
|
GPS_SEND_FREQ = ["OFF", "PTT SEND", "1 min", "2 min", "3 min",
|
|
"4 min", "5 min", "6 min", "7 min", "8 min",
|
|
"9 min", "10 min"]
|
|
VFOABAND_MAP = [("150M", 0),
|
|
("400M", 1),
|
|
("200M", 2),
|
|
("66M", 3),
|
|
("800M", 4),
|
|
("300M", 5)]
|
|
VFOABAND_MAP2 = [("150M", 0),
|
|
("400M", 1),
|
|
("200M", 2),
|
|
("26M", 3),
|
|
("800M", 4),
|
|
("300M", 5)]
|
|
|
|
VFOBBAND_MAP = [("150M", 0),
|
|
("400M", 1)]
|
|
PTT_LIST = ["Area A", "Area B", "Main Tx", "Secondary Tx", "Low Power",
|
|
"Ultra Hi Power", "Call"]
|
|
PROG_KEY_LIST = ["DISABLE/UNDEF", "ALARM", "BACKLIGHT", "BRIGHT+", "FAVORITE",
|
|
"FLASHLIGHT", "FM-RADIO", "DISPLAY-MAP", "MONITOR",
|
|
"REVERSE", "SCAN", "SCAN-CTC", "SCAN-DCS", "SOS",
|
|
"STROBE", "TALK-AROUND", "WEATHER"]
|
|
PROG_KEY_LIST2 = ["DISABLE/UNDEF", "ALARM", "BACKLIGHT", "BRIGHT+", "FAVORITE",
|
|
"FLASHLIGHT", "FM-RADIO", "DISPLAY-MAP", "MONITOR",
|
|
"REVERSE", "SCAN", "SCAN-CTC", "SCAN-DCS", "SOS",
|
|
"STROBE", "TALK-AROUND", "WEATHER", "FM/AM", "CH-WIZARD"]
|
|
|
|
VFO_SCANMODE_LIST = ["Current Band", "Range", "All"]
|
|
ACTIVE_AREA_LIST = ["Area A - Top", "Area B - Bottom"]
|
|
TDR_LIST = ["TDR ON", "TDR OFF"]
|
|
PRICHAN_LIST = ["OFF", "ON Standby - Rx OFF", "Always On"]
|
|
# First Q10H Firmware revison did not support 20k Step Size option
|
|
NO_20K_STEP_FIRMWARE = ["VC1.00"]
|
|
# memory slot 0 is not used, start at 1 (so need 1000 slots, not 999)
|
|
# structure elements whose name starts with x are currently unidentified
|
|
|
|
_MEM_FORMAT_Q10H_oem_read = """
|
|
#seekto 0x0002;
|
|
struct {
|
|
ul32 tworx_start;
|
|
ul32 tworx_stop;
|
|
ul32 cm70_tx_start; //70cm Tx
|
|
ul32 cm70_tx_stop; //70cm Tx
|
|
ul32 m125_tx_start; //1.25m Tx
|
|
ul32 m125_tx_stop; //1.25m Tx
|
|
ul32 m6_tx_start; //6m Tx
|
|
ul32 m6_tx_stop; //6m Tx
|
|
#seekto 0x00a6;
|
|
ul32 rx1lim_start;
|
|
ul32 rx1lim_stop;
|
|
ul32 rx2lim_start;
|
|
ul32 rx2lim_stop;
|
|
ul32 rx3lim_start;
|
|
ul32 rx3lim_stop;
|
|
ul32 rx4lim_start;
|
|
ul32 rx4lim_stop;
|
|
ul32 rx5lim_start;
|
|
ul32 rx5lim_stop;
|
|
ul32 rx6lim_start;
|
|
ul32 rx6lim_stop;
|
|
ul32 rx7lim_start;
|
|
ul32 rx7lim_stop;
|
|
ul32 rx8lim_start;
|
|
ul32 rx8lim_stop;
|
|
ul32 m2tx_start; // 2m Tx
|
|
ul32 m2tx_stop; // 2m tx
|
|
ul32 rx10lim_start;
|
|
ul32 rx10lim_stop;
|
|
ul32 rx11lim_start;
|
|
ul32 rx11lim_stop;
|
|
} limits;
|
|
|
|
#seekto 0x0040;
|
|
struct {
|
|
char oem1[8];
|
|
#seekto 0x006c; //0x002c;
|
|
char name[8];
|
|
#seekto 0x0092; //0x0052;
|
|
char firmware[6];
|
|
#seekto 0x0078; //0x0038;
|
|
char date[10];
|
|
#seekto 0x030a;
|
|
u8 locked;
|
|
} oem_info;
|
|
|
|
#seekto 0x7740;
|
|
struct {
|
|
struct {
|
|
ul16 scan_st;
|
|
ul16 scan_end;
|
|
} addrs[10];
|
|
struct {
|
|
char name[12];
|
|
} names[10];
|
|
} scn_grps;
|
|
|
|
#seekto 0x78e0;
|
|
struct {
|
|
u8 cid[6];
|
|
} call_ids[100];
|
|
|
|
#seekto 0x7B40;
|
|
struct {
|
|
char call_name[12];
|
|
} call_names[100];
|
|
|
|
|
|
#seekto 0x0520;
|
|
struct {
|
|
u8 channel_menu;
|
|
u8 power_save;
|
|
u8 roger_beep;
|
|
u8 timeout;
|
|
u8 toalarm;
|
|
u8 wxalert;
|
|
u8 wxalert_type;
|
|
u8 vox;
|
|
u8 unk_xp8;
|
|
u8 voice;
|
|
u8 beep;
|
|
u8 scan_rev;
|
|
u8 backlight;
|
|
u8 DspBrtAct;
|
|
u8 DspBrtSby;
|
|
u8 ponmsg;
|
|
u8 ptt_id; //0x530
|
|
u8 ptt_delay;
|
|
u8 dtmf_st;
|
|
u8 dtmf_tx_time;
|
|
u8 dtmf_interval;
|
|
u8 ring_time;
|
|
u8 alert;
|
|
u8 autolock;
|
|
ul16 pri_ch;
|
|
u8 prich_sw;
|
|
u8 rpttype;
|
|
u8 rpt_spk;
|
|
u8 rpt_ptt;
|
|
u8 rpt_tone;
|
|
u8 rpt_hold;
|
|
u8 scan_det;
|
|
u8 smuteset; //0x540
|
|
u8 batt_ind;
|
|
u8 ToneScnSave;
|
|
#seekto 0x0544;
|
|
u8 theme;
|
|
u8 unkx545;
|
|
u8 disp_time;
|
|
u8 time_zone;
|
|
u8 GPS_send_freq;
|
|
u8 GPS;
|
|
u8 GPS_rcv;
|
|
ul16 custcol1_text;
|
|
ul16 custcol1_bg;
|
|
ul16 custcol1_icon;
|
|
ul16 custcol1_line;
|
|
ul16 custcol2_text;
|
|
ul16 custcol2_bg;
|
|
ul16 custcol2_icon;
|
|
ul16 custcol2_line;
|
|
ul16 custcol3_text;
|
|
ul16 custcol3_bg;
|
|
ul16 custcol3_icon;
|
|
ul16 custcol3_line;
|
|
ul16 custcol4_text;
|
|
ul16 custcol4_bg;
|
|
ul16 custcol4_icon;
|
|
ul16 custcol4_line;
|
|
// #seekto 0x056b;
|
|
char mode_sw_pwd[6];
|
|
char reset_pwd[6];
|
|
u8 work_mode_a;
|
|
u8 work_mode_b;
|
|
ul16 work_ch_a;
|
|
ul16 work_ch_b;
|
|
u8 vfostepA;
|
|
u8 vfostepB;
|
|
u8 squelchA;
|
|
u8 squelchB;
|
|
u8 BCL_A;
|
|
u8 BCL_B;
|
|
u8 vfobandA;
|
|
u8 vfobandB;
|
|
#seekto 0x0587;
|
|
u8 top_short;
|
|
u8 top_long;
|
|
u8 ptt1;
|
|
u8 ptt2;
|
|
u8 pf1_short;
|
|
u8 pf1_long;
|
|
u8 pf2_short;
|
|
u8 pf2_long;
|
|
u8 ScnGrpA_Act;
|
|
u8 ScnGrpB_Act;
|
|
u8 vfo_scanmodea;
|
|
u8 vfo_scanmodeb; //x592
|
|
u8 ani_id[6];
|
|
u8 scc[6];
|
|
#seekto 0x05A1;
|
|
u8 act_area;
|
|
u8 tdr;
|
|
u8 keylock;
|
|
#seekto 0x05A9;
|
|
char dispstr[12];
|
|
#seekto 0x05BD;
|
|
char areamsg[12];
|
|
u8 xunk_1;
|
|
u8 xunk_2;
|
|
u8 xunk_ani_sw;
|
|
u8 xani_code[6];
|
|
u8 xpf1_shrt;
|
|
u8 xpf1_long;
|
|
u8 xpf2_shrt;
|
|
u8 xpf2_long;
|
|
u8 main_band;
|
|
u8 xTDR_single_mode;
|
|
u8 xunk1;
|
|
u8 xunk2;
|
|
u8 cur_call_grp;
|
|
u8 VFO_repeater_a;
|
|
u8 VFO_repeater_b;
|
|
u8 sim_rec;
|
|
} settings;
|
|
|
|
#seekto 0x78B0;
|
|
struct {
|
|
ul16 FM_radio;
|
|
} fm[20];
|
|
|
|
#seekto 0x0440;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 offset;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 ofst_dir:3,
|
|
unknown:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} vfoa[6];
|
|
|
|
#seekto 0x04a0;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 offset;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 ofst_dir:3,
|
|
unknown:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} vfob[2];
|
|
|
|
#seekto 0x05E0;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 txfreq;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 unknown3:1,
|
|
send_loc:1,
|
|
scan_add:1,
|
|
favorite:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} memory[1000];
|
|
|
|
#seekto 0x4460;
|
|
struct {
|
|
u8 name[12];
|
|
} names[1000];
|
|
|
|
#seekto 0x7340;
|
|
u8 valid[1000];
|
|
|
|
#seekto 0x77E0;
|
|
struct {
|
|
ul16 vfo_scan_start_A;
|
|
ul16 vfo_scan_end_A;
|
|
ul16 vfo_scan_start_B;
|
|
ul16 vfo_scan_end_B;
|
|
} vfo_scan;
|
|
|
|
"""
|
|
|
|
_MEM_FORMAT_Q10H_oem_read2 = """
|
|
#seekto 0x02c2;
|
|
struct {
|
|
ul32 rx12lim_start;
|
|
ul32 rx12lim_stop;
|
|
ul32 rx13lim_start;
|
|
ul32 rx13lim_stop;
|
|
ul32 rx14lim_start;
|
|
ul32 rx14lim_stop;
|
|
ul32 rx15lim_start;
|
|
ul32 rx15lim_stop;
|
|
ul32 rx16lim_start;
|
|
ul32 rx16lim_stop;
|
|
ul32 rx17lim_start;
|
|
ul32 rx17lim_stop;
|
|
ul32 rx18lim_start;
|
|
ul32 rx18lim_stop;
|
|
ul32 rx19lim_start;
|
|
ul32 rx19lim_stop;
|
|
#seekto 0x0302;
|
|
ul32 tworx_start;
|
|
ul32 tworx_stop;
|
|
ul32 cm70_tx_start; //70cm Tx
|
|
ul32 cm70_tx_stop; //70cm Tx
|
|
ul32 m125_tx_start; //1.25m Tx
|
|
ul32 m125_tx_stop; //1.25m Tx
|
|
ul32 m6_tx_start; //6m Tx
|
|
ul32 m6_tx_stop; //6m Tx
|
|
#seekto 0x03a6;
|
|
ul32 rx1lim_start;
|
|
ul32 rx1lim_stop;
|
|
ul32 rx2lim_start;
|
|
ul32 rx2lim_stop;
|
|
ul32 rx3lim_start;
|
|
ul32 rx3lim_stop;
|
|
ul32 rx4lim_start;
|
|
ul32 rx4lim_stop;
|
|
ul32 rx5lim_start;
|
|
ul32 rx5lim_stop;
|
|
ul32 rx6lim_start;
|
|
ul32 rx6lim_stop;
|
|
ul32 rx7lim_start;
|
|
ul32 rx7lim_stop;
|
|
ul32 rx8lim_start;
|
|
ul32 rx8lim_stop;
|
|
ul32 m2tx_start; // 2m Tx
|
|
ul32 m2tx_stop; // 2m tx
|
|
ul32 rx10lim_start;
|
|
ul32 rx10lim_stop;
|
|
ul32 rx11lim_start;
|
|
ul32 rx11lim_stop;
|
|
#seekto 0x3a6;
|
|
struct {
|
|
ul32 lim_start;
|
|
ul32 lim_stop;
|
|
} more_limits[14];
|
|
} limits;
|
|
|
|
#seekto 0x0340;
|
|
struct {
|
|
char oem1[8];
|
|
#seekto 0x036c; //0x002c;
|
|
char name[8];
|
|
#seekto 0x0392; //0x0052;
|
|
char firmware[6];
|
|
#seekto 0x0378; //0x0038;
|
|
char date[10];
|
|
#seekto 0x000a;
|
|
u8 locked;
|
|
} oem_info;
|
|
|
|
#seekto 0x7740;
|
|
struct {
|
|
struct {
|
|
ul16 scan_st;
|
|
ul16 scan_end;
|
|
} addrs[10];
|
|
struct {
|
|
char name[12];
|
|
} names[10];
|
|
} scn_grps;
|
|
|
|
#seekto 0x78e0;
|
|
struct {
|
|
u8 cid[6];
|
|
} call_ids[100];
|
|
|
|
#seekto 0x7B40;
|
|
struct {
|
|
char call_name[12];
|
|
} call_names[100];
|
|
|
|
|
|
#seekto 0x0440;
|
|
struct {
|
|
u8 channel_menu;
|
|
u8 power_save;
|
|
u8 roger_beep;
|
|
u8 timeout;
|
|
u8 toalarm;
|
|
u8 wxalert;
|
|
u8 wxalert_type;
|
|
u8 vox;
|
|
u8 unk_xp8;
|
|
u8 voice;
|
|
u8 beep;
|
|
u8 scan_rev;
|
|
u8 backlight;
|
|
u8 DspBrtAct;
|
|
u8 DspBrtSby;
|
|
u8 ponmsg;
|
|
u8 ptt_id; //0x530
|
|
u8 ptt_delay;
|
|
u8 dtmf_st;
|
|
u8 dtmf_tx_time;
|
|
u8 dtmf_interval;
|
|
u8 ring_time;
|
|
u8 alert;
|
|
u8 autolock;
|
|
ul16 pri_ch;
|
|
u8 prich_sw;
|
|
u8 rpttype;
|
|
u8 rpt_spk;
|
|
u8 rpt_ptt;
|
|
u8 rpt_tone;
|
|
u8 rpt_hold;
|
|
u8 scan_det;
|
|
u8 smuteset; //0x540
|
|
u8 batt_ind;
|
|
u8 ToneScnSave;
|
|
#seekto 0x0464;
|
|
u8 theme;
|
|
u8 unkx545;
|
|
u8 disp_time;
|
|
u8 time_zone;
|
|
u8 GPS_send_freq;
|
|
u8 GPS;
|
|
u8 GPS_rcv;
|
|
ul16 custcol1_text;
|
|
ul16 custcol1_bg;
|
|
ul16 custcol1_icon;
|
|
ul16 custcol1_line;
|
|
ul16 custcol2_text;
|
|
ul16 custcol2_bg;
|
|
ul16 custcol2_icon;
|
|
ul16 custcol2_line;
|
|
ul16 custcol3_text;
|
|
ul16 custcol3_bg;
|
|
ul16 custcol3_icon;
|
|
ul16 custcol3_line;
|
|
ul16 custcol4_text;
|
|
ul16 custcol4_bg;
|
|
ul16 custcol4_icon;
|
|
ul16 custcol4_line;
|
|
// #seekto 0x048b;
|
|
char mode_sw_pwd[6];
|
|
char reset_pwd[6];
|
|
u8 work_mode_a;
|
|
u8 work_mode_b;
|
|
ul16 work_ch_a;
|
|
ul16 work_ch_b;
|
|
u8 vfostepA;
|
|
u8 vfostepB;
|
|
u8 squelchA;
|
|
u8 squelchB;
|
|
u8 BCL_A;
|
|
u8 BCL_B;
|
|
u8 vfobandA;
|
|
u8 vfobandB;
|
|
#seekto 0x04a7;
|
|
u8 top_short;
|
|
u8 top_long;
|
|
u8 ptt1;
|
|
u8 ptt2;
|
|
u8 pf1_short;
|
|
u8 pf1_long;
|
|
u8 pf2_short;
|
|
u8 pf2_long;
|
|
u8 ScnGrpA_Act;
|
|
u8 ScnGrpB_Act;
|
|
u8 vfo_scanmodea;
|
|
u8 vfo_scanmodeb; //x592
|
|
u8 ani_id[6];
|
|
u8 scc[6];
|
|
#seekto 0x04c1;
|
|
u8 act_area;
|
|
u8 tdr;
|
|
u8 keylock;
|
|
#seekto 0x04c7;
|
|
u8 stopwatch; //0x04c7
|
|
u8 x0x04c8;
|
|
char dispstr[12];
|
|
#seekto 0x04dD;
|
|
char areamsg[12];
|
|
u8 xUnk_1;
|
|
u8 xunk_2;
|
|
u8 xunk_ani_sw;
|
|
u8 xani_code[6];
|
|
u8 xpf1_shrt;
|
|
u8 xpf1_long;
|
|
u8 xpf2_shrt;
|
|
u8 xpf2_long;
|
|
u8 main_band;
|
|
u8 xTDR_single_mode;
|
|
u8 xunk1;
|
|
u8 xunk2;
|
|
u8 cur_call_grp;
|
|
u8 VFO_repeater_a;
|
|
u8 VFO_repeater_b;
|
|
u8 sim_rec;
|
|
} settings;
|
|
|
|
#seekto 0x78B0;
|
|
struct {
|
|
ul16 FM_radio;
|
|
} fm[20];
|
|
|
|
#seekto 0x0540;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 offset;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 ofst_dir:3,
|
|
unknown:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} vfoa[6];
|
|
|
|
#seekto 0x05a0;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 offset;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 ofst_dir:3,
|
|
unknown:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} vfob[2];
|
|
|
|
#seekto 0x05E0;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 txfreq;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 unknown3:1,
|
|
send_loc:1,
|
|
scan_add:1,
|
|
favorite:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} memory[1000];
|
|
|
|
#seekto 0x4460;
|
|
struct {
|
|
u8 name[12];
|
|
} names[1000];
|
|
|
|
#seekto 0x7340;
|
|
u8 valid[1000];
|
|
|
|
#seekto 0x77E0;
|
|
struct {
|
|
ul16 vfo_scan_start_A;
|
|
ul16 vfo_scan_end_A;
|
|
ul16 vfo_scan_start_B;
|
|
ul16 vfo_scan_end_B;
|
|
} vfo_scan;
|
|
|
|
"""
|
|
|
|
_MEM_FORMAT_Q10H_oem_read_nolims = """
|
|
|
|
#seekto 0x0340;
|
|
struct {
|
|
char oem1[8];
|
|
#seekto 0x036c; //0x002c;
|
|
char name[8];
|
|
#seekto 0x0392; //0x0052;
|
|
char firmware[6];
|
|
#seekto 0x0378; //0x0038;
|
|
char date[10];
|
|
#seekto 0x000a;
|
|
u8 locked;
|
|
} oem_info;
|
|
|
|
#seekto 0x7740;
|
|
struct {
|
|
struct {
|
|
ul16 scan_st;
|
|
ul16 scan_end;
|
|
} addrs[10];
|
|
struct {
|
|
char name[12];
|
|
} names[10];
|
|
} scn_grps;
|
|
|
|
#seekto 0x78e0;
|
|
struct {
|
|
u8 cid[6];
|
|
} call_ids[100];
|
|
|
|
#seekto 0x7B40;
|
|
struct {
|
|
char call_name[12];
|
|
} call_names[100];
|
|
|
|
|
|
#seekto 0x0440;
|
|
struct {
|
|
u8 channel_menu;
|
|
u8 power_save;
|
|
u8 roger_beep;
|
|
u8 timeout;
|
|
u8 toalarm;
|
|
u8 wxalert;
|
|
u8 wxalert_type;
|
|
u8 vox;
|
|
u8 unk_xp8;
|
|
u8 voice;
|
|
u8 beep;
|
|
u8 scan_rev;
|
|
u8 backlight;
|
|
u8 DspBrtAct;
|
|
u8 DspBrtSby;
|
|
u8 ponmsg;
|
|
u8 ptt_id; //0x530
|
|
u8 ptt_delay;
|
|
u8 dtmf_st;
|
|
u8 dtmf_tx_time;
|
|
u8 dtmf_interval;
|
|
u8 ring_time;
|
|
u8 alert;
|
|
u8 autolock;
|
|
ul16 pri_ch;
|
|
u8 prich_sw;
|
|
u8 rpttype;
|
|
u8 rpt_spk;
|
|
u8 rpt_ptt;
|
|
u8 rpt_tone;
|
|
u8 rpt_hold;
|
|
u8 scan_det;
|
|
u8 smuteset; //0x540
|
|
u8 batt_ind;
|
|
u8 ToneScnSave;
|
|
#seekto 0x0464;
|
|
u8 theme;
|
|
u8 unkx545;
|
|
u8 disp_time;
|
|
u8 time_zone;
|
|
u8 GPS_send_freq;
|
|
u8 GPS;
|
|
u8 GPS_rcv;
|
|
ul16 custcol1_text;
|
|
ul16 custcol1_bg;
|
|
ul16 custcol1_icon;
|
|
ul16 custcol1_line;
|
|
ul16 custcol2_text;
|
|
ul16 custcol2_bg;
|
|
ul16 custcol2_icon;
|
|
ul16 custcol2_line;
|
|
ul16 custcol3_text;
|
|
ul16 custcol3_bg;
|
|
ul16 custcol3_icon;
|
|
ul16 custcol3_line;
|
|
ul16 custcol4_text;
|
|
ul16 custcol4_bg;
|
|
ul16 custcol4_icon;
|
|
ul16 custcol4_line;
|
|
// #seekto 0x048b;
|
|
char mode_sw_pwd[6];
|
|
char reset_pwd[6];
|
|
u8 work_mode_a;
|
|
u8 work_mode_b;
|
|
ul16 work_ch_a;
|
|
ul16 work_ch_b;
|
|
u8 vfostepA;
|
|
u8 vfostepB;
|
|
u8 squelchA;
|
|
u8 squelchB;
|
|
u8 BCL_A;
|
|
u8 BCL_B;
|
|
u8 vfobandA;
|
|
u8 vfobandB;
|
|
#seekto 0x04a7;
|
|
u8 top_short;
|
|
u8 top_long;
|
|
u8 ptt1;
|
|
u8 ptt2;
|
|
u8 pf1_short;
|
|
u8 pf1_long;
|
|
u8 pf2_short;
|
|
u8 pf2_long;
|
|
u8 ScnGrpA_Act;
|
|
u8 ScnGrpB_Act;
|
|
u8 vfo_scanmodea;
|
|
u8 vfo_scanmodeb; //x592
|
|
u8 ani_id[6];
|
|
u8 scc[6];
|
|
#seekto 0x04c1;
|
|
u8 act_area;
|
|
u8 tdr;
|
|
u8 keylock;
|
|
#seekto 0x04c7;
|
|
u8 stopwatch; //0x04c7
|
|
u8 x0x04c8;
|
|
char dispstr[12];
|
|
#seekto 0x04dD;
|
|
char areamsg[12];
|
|
u8 xunk_1;
|
|
u8 xunk_2;
|
|
u8 xunk_ani_sw;
|
|
u8 xani_code[6];
|
|
u8 xpf1_shrt;
|
|
u8 xpf1_long;
|
|
u8 xpf2_shrt;
|
|
u8 xpf2_long;
|
|
u8 main_band;
|
|
u8 xTDR_single_mode;
|
|
u8 xunk1;
|
|
u8 xunk2;
|
|
u8 cur_call_grp;
|
|
u8 VFO_repeater_a;
|
|
u8 VFO_repeater_b;
|
|
u8 sim_rec;
|
|
} settings;
|
|
|
|
#seekto 0x78B0;
|
|
struct {
|
|
ul16 FM_radio;
|
|
} fm[20];
|
|
|
|
#seekto 0x0540;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 offset;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 ofst_dir:3,
|
|
unknown:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} vfoa[6];
|
|
|
|
#seekto 0x05a0;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 offset;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 ofst_dir:3,
|
|
unknown:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} vfob[2];
|
|
|
|
#seekto 0x05E0;
|
|
struct {
|
|
ul32 rxfreq;
|
|
ul32 txfreq;
|
|
ul16 rxtone;
|
|
ul16 txtone;
|
|
u8 scrambler:4,
|
|
am_mode:2,
|
|
power:2;
|
|
u8 unknown3:1,
|
|
send_loc:1,
|
|
scan_add:1,
|
|
favorite:1,
|
|
compander:1,
|
|
mute_mode:2,
|
|
iswide:1;
|
|
u8 call_group;
|
|
u8 unknown6;
|
|
} memory[1000];
|
|
|
|
#seekto 0x4460;
|
|
struct {
|
|
u8 name[12];
|
|
} names[1000];
|
|
|
|
#seekto 0x7340;
|
|
u8 valid[1000];
|
|
|
|
#seekto 0x77E0;
|
|
struct {
|
|
ul16 vfo_scan_start_A;
|
|
ul16 vfo_scan_end_A;
|
|
ul16 vfo_scan_start_B;
|
|
ul16 vfo_scan_end_B;
|
|
} vfo_scan;
|
|
|
|
"""
|
|
|
|
# Support for the Wouxun KG-Q10H radio
|
|
# Serial coms are at 115200 baud
|
|
# The data is passed in variable length records
|
|
# Record structure:
|
|
# Offset Usage
|
|
# 0 start of record (\x7c)
|
|
# 1 Command (\x80 Identify \x81 End/Reboot \x82 Read \x83 Write)
|
|
# 2 direction (\xff PC-> Radio, \x00 Radio -> PC)
|
|
# 3 length of payload (excluding header/checksum) (n)
|
|
# 4 payload (n bytes)
|
|
# 4+n+1 checksum - byte sum (% 256) of bytes 1 -> 4+n
|
|
#
|
|
# Memory Read Records:
|
|
# the payload is 3 bytes, first 2 are offset (big endian),
|
|
# 3rd is number of bytes to read
|
|
# Memory Write Records:
|
|
# the maximum payload size (from the Wouxun software) seems to be 66 bytes
|
|
# (2 bytes location + 64 bytes data).
|
|
|
|
|
|
def name2str(name):
|
|
""" Convert a callid or scan group name to a string
|
|
Deal with fixed field padding (\0 or \0xff)
|
|
"""
|
|
|
|
namestr = ""
|
|
for i in range(0, len(name)):
|
|
b = ord(name[i].get_value())
|
|
if b != 0 and b != 0xff:
|
|
namestr += chr(b)
|
|
return namestr
|
|
|
|
|
|
def str2name(val, size=6, fillchar='\0', emptyfill='\0'):
|
|
""" Convert a string to a name. A name is a 6 element bytearray
|
|
with ascii chars.
|
|
"""
|
|
val = str(val).rstrip(' \t\r\n\0\xff')
|
|
if len(val) == 0:
|
|
name = "".ljust(size, emptyfill)
|
|
else:
|
|
name = val.ljust(size, fillchar)
|
|
return name
|
|
|
|
|
|
def str2callid(val):
|
|
""" Convert caller id strings from callid2str.
|
|
"""
|
|
ascii2bin = "0123456789"
|
|
s = str(val).strip()
|
|
LOG.debug("val = %s" % val)
|
|
LOG.debug("s = %s" % s)
|
|
if len(s) < 3 or len(s) > 6:
|
|
raise InvalidValueError(
|
|
"Caller ID must be at least 3 and no more than 6 digits")
|
|
if s[0] == '0':
|
|
raise InvalidValueError(
|
|
"First digit of a Caller ID cannot be a zero '0'")
|
|
blk = bytearray()
|
|
for c in s:
|
|
if c not in ascii2bin:
|
|
raise InvalidValueError(
|
|
"Caller ID must be all digits 0x%x" % c)
|
|
b = ascii2bin.index(c)
|
|
blk.append(b)
|
|
if len(blk) < 6:
|
|
blk.append(0x0F) # EOL a short ID
|
|
if len(blk) < 6:
|
|
for i in range(0, (6 - len(blk))):
|
|
blk.append(0xf0)
|
|
LOG.debug("blk = %s" % blk)
|
|
return blk
|
|
|
|
|
|
def digits2str(digits, padding=' ', width=6):
|
|
"""Convert a password or SCC digit string to a string
|
|
Passwords are expanded to and must be 6 chars. Fill them with '0'
|
|
"""
|
|
|
|
bin2ascii = "0123456789"
|
|
digitsstr = ""
|
|
for i in range(0, 6):
|
|
b = digits[i].get_value()
|
|
if b == 0x0F: # the digits EOL
|
|
break
|
|
if b >= 0xa:
|
|
raise InvalidValueError(
|
|
"Value has illegal byte 0x%x" % ord(b))
|
|
digitsstr += bin2ascii[b]
|
|
digitsstr = digitsstr.ljust(width, padding)
|
|
return digitsstr
|
|
|
|
|
|
def str2digits(val):
|
|
""" Callback for edited strings from digits2str.
|
|
"""
|
|
ascii2bin = " 0123456789"
|
|
s = str(val).strip()
|
|
if len(s) < 3 or len(s) > 6:
|
|
raise InvalidValueError(
|
|
"Value must be at least 3 and no more than 6 digits")
|
|
blk = bytearray()
|
|
for c in s:
|
|
if c not in ascii2bin:
|
|
raise InvalidValueError("Value must be all digits 0x%x" % c)
|
|
blk.append(int(c))
|
|
for i in range(len(blk), 6):
|
|
blk.append(0x0f) # EOL a short ID
|
|
return blk
|
|
|
|
|
|
def apply_scc(setting, obj):
|
|
c = str2digits(setting.value)
|
|
obj.scc = c
|
|
|
|
|
|
@directory.register
|
|
class KGQ10HRadio(chirp_common.CloneModeRadio,
|
|
chirp_common.ExperimentalRadio):
|
|
|
|
"""Wouxun KG-Q10H"""
|
|
VENDOR = "Wouxun"
|
|
MODEL = "KG-Q10H"
|
|
NEEDS_COMPAT_SERIAL = False
|
|
_model = b"KG-Q10H"
|
|
BAUD_RATE = 115200
|
|
POWER_LEVELS = [chirp_common.PowerLevel("L", watts=0.5),
|
|
chirp_common.PowerLevel("M", watts=4.5),
|
|
chirp_common.PowerLevel("H", watts=5.5),
|
|
chirp_common.PowerLevel("U", watts=6.0)]
|
|
_record_start = 0x7C
|
|
_RADIO_ID = ""
|
|
cryptbyte = 0x54
|
|
am_mode_list = AM_MODE
|
|
am_mode_list_ch = AM_MODE_CH
|
|
themelist = THEME_LIST
|
|
vfoa_grp_label = "VFO A Settings"
|
|
vfob_grp_label = "VFO B Settings"
|
|
workmodelist = WORKMODE_LIST
|
|
# pfkeyshort = PFKEYSHORT_LIST
|
|
# pfkeylong = PFKEYLONG_LIST
|
|
dispmesg = "Top Message"
|
|
areamsglabel = "Area Message"
|
|
vfo_area = "VFO "
|
|
# ani_msg = "ANI-ID Switch (ANI-SW)"
|
|
pttdly_msg = "PTT-DLY - menu 34"
|
|
idtx_msg = "PTT-ID - menu 33"
|
|
vfoa3_msg = "66M Settings"
|
|
_prog_key = PROG_KEY_LIST
|
|
_vfoaband = VFOABAND_MAP
|
|
_offset_dir_rpt = OFFSET_LIST
|
|
_offset_dir_rpt_label = "A Shift Dir"
|
|
_offset_dir_rpt_labelB = "B Shift Dir"
|
|
rpttonemenu = 43
|
|
timemenu = 44
|
|
tzmenu = 45
|
|
locmenu = 47
|
|
|
|
Beta_release = True
|
|
|
|
if Beta_release:
|
|
use_color = False
|
|
show_limits = False
|
|
else:
|
|
use_color = True
|
|
show_limits = True
|
|
|
|
def check_for_beta1_file(self):
|
|
check1 = self.get_mmap()[0x0000:0x0005]
|
|
check2 = self.get_mmap()[0x0340:0x0346]
|
|
if ((check1 == b'\xdd\xdd\xdd\xdd\xdd') &
|
|
(check2 == b'\x57\x4F\x55\x58\x55\x4E')):
|
|
beta1 = False
|
|
else:
|
|
beta1 = True
|
|
return beta1
|
|
|
|
def process_mmap(self):
|
|
if self.show_limits:
|
|
self._memobj = bitwise.parse(_MEM_FORMAT_Q10H_oem_read2,
|
|
self._mmap)
|
|
else:
|
|
self._memobj = bitwise.parse(_MEM_FORMAT_Q10H_oem_read_nolims,
|
|
self._mmap)
|
|
|
|
def _checksum(self, data):
|
|
cs = 0
|
|
for byte in data:
|
|
cs += byte
|
|
return cs % 256
|
|
|
|
def strxor(self, xora, xorb):
|
|
return bytes([xora ^ xorb])
|
|
|
|
# Wouxun data jumps around the memory map and is not in continuous memory
|
|
# order
|
|
# Rearrange Mem Map to put all memory into order where data is continuous
|
|
def _rearrange_image(self, image_in):
|
|
image_out = b""
|
|
cfgmap = Q10H_mem_arrange_map
|
|
|
|
for start, end in cfgmap:
|
|
LOG.debug("start = " + str(hex(start)))
|
|
LOG.debug("end = " + str(hex(end)))
|
|
|
|
for i in range(start, end, 1):
|
|
image_out += image_in[i]
|
|
|
|
return image_out
|
|
|
|
def sync_in(self):
|
|
try:
|
|
self._mmap_addrorder = self._download()
|
|
self._mmap = memmap.MemoryMapBytes(self._rearrange_image
|
|
(self._mmap_addrorder))
|
|
# self._mmap = self._download()
|
|
except errors.RadioError:
|
|
raise
|
|
except Exception as e:
|
|
raise errors.RadioError("Failed to communicate with radio: %s" % e)
|
|
self.process_mmap()
|
|
|
|
def sync_out(self):
|
|
self._upload()
|
|
|
|
def _upload(self):
|
|
# Beta 1.x files had a different memory map arrangement
|
|
# Use of Beta 1.x files with Beta 2.x and beyond driver
|
|
# will send settings
|
|
# to incorrect locations on the radio casuing issues-
|
|
# Detect and Prevent!!
|
|
# Check for specific data (static) at specific locations
|
|
# to confirm Beta2 vs Beta1 memory layout.
|
|
beta1 = self.check_for_beta1_file()
|
|
if beta1:
|
|
LOG.debug("beta1 file detected = %s" % beta1)
|
|
raise errors.RadioError("Beta 1 img detected!!!\n"
|
|
"Upload Canceled!\n"
|
|
"Select a Beta 2.x img or\n"
|
|
"Download from radio to get a Beta2 img\n"
|
|
"Then Retry the Upload")
|
|
try:
|
|
self._identify()
|
|
self._do_upload()
|
|
except errors.RadioError:
|
|
raise
|
|
except Exception as e:
|
|
raise errors.RadioError("Failed to communicate with radio: %s" % e)
|
|
return
|
|
|
|
def _do_upload(self):
|
|
if self._RADIO_ID == self._model:
|
|
LOG.debug("Starting Upload")
|
|
if self.show_limits:
|
|
cfgmap = Q10H_upload_map
|
|
else:
|
|
cfgmap = Q10H_upload_map_nolims
|
|
|
|
for (radioaddress, radioend, start, memend,
|
|
blocksize, count) in cfgmap:
|
|
end = start + (blocksize * count)
|
|
LOG.debug("start = " + str(start))
|
|
LOG.debug("end = " + str(end))
|
|
LOG.debug("blksize = " + str(blocksize))
|
|
ptr2 = radioaddress
|
|
|
|
for addr in range(start, end, blocksize):
|
|
ptr = addr
|
|
LOG.debug("ptr = " + str(hex(ptr)))
|
|
LOG.debug("ptr2 = " + str(hex(ptr2)))
|
|
req = struct.pack('>H', ptr2)
|
|
chunk = self.get_mmap()[ptr:ptr + blocksize]
|
|
self._write_record(CMD_WR, req + chunk)
|
|
LOG.debug(util.hexprint(req + chunk))
|
|
cserr, ack = self._read_record()
|
|
LOG.debug(util.hexprint(ack))
|
|
j = struct.unpack('>H', ack)[0]
|
|
if cserr or j != ptr2:
|
|
LOG.debug(util.hexprint(ack))
|
|
raise Exception("Checksum Error on Ack at %i" % ptr)
|
|
ptr += blocksize
|
|
ptr2 += blocksize
|
|
if self.status_fn:
|
|
status = chirp_common.Status()
|
|
status.cur = ptr
|
|
status.max = 0x8000
|
|
status.msg = "Cloning to radio"
|
|
self.status_fn(status)
|
|
# fix for errant upload to radio address 0x100 in beta 2.0 driver
|
|
# this writes the correct data back to the radio
|
|
# consider removing for production
|
|
# if self._RADIO_ID == b"KG-Q10H":
|
|
# fix = struct.pack('>H64B', 0x0100, 0x00, 0x00, 0x00, 0x00,
|
|
# 0x00, 0x00,
|
|
# 0x00, 0x00, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD,
|
|
# 0xDD, 0xDD, 0xDD,
|
|
# 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD,
|
|
# 0xDD, 0x28, 0x32,
|
|
# 0x3D, 0x49, 0x57, 0x00, 0x00, 0x00, 0x00,
|
|
# 0x00, 0x00, 0x00,
|
|
# 0x00, 0x00, 0x00, 0x00, 0xDD, 0xDD, 0xDD,
|
|
# 0xDD, 0xDD, 0xDD,
|
|
# 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD,
|
|
# 0xDD, 0xDD, 0xDD,
|
|
# 0x40, 0x7A, 0x41, 0x04, 0x13, 0x17, 0x20,
|
|
# 0x31)
|
|
# self._write_record(CMD_WR, fix)
|
|
# time.sleep(0.02)
|
|
LOG.debug("Upload Completed")
|
|
else:
|
|
raise errors.RadioError("Radio is not a KG-Q10H. Upload Canceled")
|
|
|
|
self._finish()
|
|
|
|
def get_features(self):
|
|
rf = chirp_common.RadioFeatures()
|
|
rf.has_settings = True
|
|
rf.has_ctone = True
|
|
rf.has_rx_dtcs = True
|
|
rf.has_cross = True
|
|
rf.has_tuning_step = False
|
|
rf.has_bank = False
|
|
rf.can_odd_split = True
|
|
rf.valid_skips = ["", "S"]
|
|
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
|
|
rf.valid_cross_modes = [
|
|
"Tone->Tone",
|
|
"Tone->DTCS",
|
|
"DTCS->Tone",
|
|
"DTCS->",
|
|
"->Tone",
|
|
"->DTCS",
|
|
"DTCS->DTCS",
|
|
]
|
|
rf.valid_modes = ["FM", "NFM", "AM"]
|
|
rf.valid_power_levels = self.POWER_LEVELS
|
|
rf.valid_name_length = 12
|
|
rf.valid_duplexes = ["", "-", "+", "split", "off"]
|
|
rf.valid_bands = [(50000000, 54997500), # 6m
|
|
(108000000, 174997500), # AM Airband and VHF
|
|
(222000000, 225997500), # 1.25M
|
|
(320000000, 479997500), # UHF
|
|
(714000000, 999997500)] # Fixed Land Mobile
|
|
|
|
rf.valid_characters = chirp_common.CHARSET_ASCII
|
|
rf.memory_bounds = (1, 999) # 999 memories
|
|
rf.valid_tuning_steps = STEPS2
|
|
return rf
|
|
|
|
@classmethod
|
|
def get_prompts(cls):
|
|
rp = chirp_common.RadioPrompts()
|
|
rp.experimental = \
|
|
('THIS DRIVER IS BETA 2.x - ''\n'
|
|
'DO NOT USE SAVED IMG FILES FROM''\n'
|
|
'BETA 1.x DRIVER WITH BETA 2.x TO UPLOAD TO RADIO''\n'
|
|
'DOWNLOAD FROM RADIO WITH BETA 2.x FIRST THEN MODIFY'
|
|
' AND UPLOAD''\n'
|
|
'This driver is experimental. USE AT YOUR OWN RISK\n'
|
|
'\n'
|
|
'Please save a copy of the image from your radio with Chirp '
|
|
'before modifying any values.\n'
|
|
'\n'
|
|
'Please keep a copy of your memories with the original Wouxon'
|
|
'CPS software if you treasure them, this driver is new and '
|
|
'may contain bugs.\n'
|
|
)
|
|
# rp.pre_download = _(
|
|
# "Please ensure you have selected the correct radio driver\n")
|
|
rp.pre_upload = (
|
|
"WARNING: THIS DRIVER IS BETA 2.x\n"
|
|
"\n"
|
|
"UPLOADS REQUIRE the use of Beta 2.x Radio img files. \n"
|
|
"DO NOT USE Radio Image files from Beta 1.x"
|
|
" to upload to radio. \n"
|
|
"It will cause incorrect settings on the radio.\n"
|
|
"\n"
|
|
"Please DOWNLOAD FROM RADIO with this driver"
|
|
" to get a Beta 2.x img file\n"
|
|
"for use BEFORE UPLOADING anything with this driver.\n"
|
|
"CANCEL the Upload if you are using a Beta 1.x img \n"
|
|
"Continue if you are using a Beta 2.x img file. \n"
|
|
"\n"
|
|
"If you don't know the img version...\n"
|
|
"The driver will try a check to confirm.\n"
|
|
"If it fails the check - Do a DOWNLOAD FROM RADIO then try again.")
|
|
return rp
|
|
|
|
def get_raw_memory(self, number):
|
|
return repr(self._memobj.memory[number])
|
|
|
|
def _get_tone(self, _mem, mem):
|
|
# MRT - Chirp Uses N for n DCS Tones and R for i DCS Tones
|
|
def _get_dcs(val):
|
|
code = int("%03o" % (val & 0x07FF))
|
|
pol = (val & 0x2000) and "R" or "N"
|
|
return code, pol
|
|
tpol = False
|
|
if _mem.txtone != 0xFFFF and (_mem.txtone & 0x4000) == 0x4000:
|
|
tcode, tpol = _get_dcs(_mem.txtone)
|
|
mem.dtcs = tcode
|
|
txmode = "DTCS"
|
|
elif _mem.txtone != 0xFFFF and _mem.txtone != 0x0:
|
|
mem.rtone = (_mem.txtone & 0x7fff) / 10.0
|
|
txmode = "Tone"
|
|
else:
|
|
txmode = ""
|
|
rpol = False
|
|
if _mem.rxtone != 0xFFFF and (_mem.rxtone & 0x4000) == 0x4000:
|
|
rcode, rpol = _get_dcs(_mem.rxtone)
|
|
mem.rx_dtcs = rcode
|
|
rxmode = "DTCS"
|
|
elif _mem.rxtone != 0xFFFF and _mem.rxtone != 0x0:
|
|
mem.ctone = (_mem.rxtone & 0x7fff) / 10.0
|
|
rxmode = "Tone"
|
|
else:
|
|
rxmode = ""
|
|
|
|
if txmode == "Tone" and not rxmode:
|
|
mem.tmode = "Tone"
|
|
elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
|
|
mem.tmode = "TSQL"
|
|
elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs:
|
|
mem.tmode = "DTCS"
|
|
elif rxmode or txmode:
|
|
mem.tmode = "Cross"
|
|
mem.cross_mode = "%s->%s" % (txmode, rxmode)
|
|
|
|
# always set it even if no dtcs is used
|
|
mem.dtcs_polarity = "%s%s" % (tpol or "N", rpol or "N")
|
|
|
|
# LOG.debug("Got TX %s (%i) RX %s (%i)" %
|
|
# (txmode, _mem.txtone, rxmode, _mem.rxtone))
|
|
|
|
def get_memory(self, number):
|
|
_mem = self._memobj.memory[number]
|
|
_nam = self._memobj.names[number]
|
|
|
|
mem = chirp_common.Memory()
|
|
mem.number = number
|
|
_valid = self._memobj.valid[mem.number]
|
|
LOG.debug("Channel %d Valid = %s", number, _valid == MEM_VALID)
|
|
if _valid != MEM_VALID:
|
|
mem.empty = True
|
|
return mem
|
|
else:
|
|
mem.empty = False
|
|
|
|
mem.freq = int(_mem.rxfreq) * 10
|
|
|
|
if (_mem.txfreq == 0xFFFFFFFF or _mem.txfreq == 0x00000000):
|
|
# TX freq not set
|
|
mem.duplex = "off"
|
|
mem.offset = 0
|
|
elif int(_mem.rxfreq) == int(_mem.txfreq):
|
|
mem.duplex = ""
|
|
mem.offset = 0
|
|
elif abs(int(_mem.rxfreq) * 10 - int(_mem.txfreq) * 10) > 70000000:
|
|
mem.duplex = "split"
|
|
mem.offset = int(_mem.txfreq) * 10
|
|
else:
|
|
mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+"
|
|
mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10
|
|
|
|
for char in _nam.name:
|
|
if char != 0:
|
|
mem.name += chr(char)
|
|
else:
|
|
# 0x00 in name indicates the end of the name.
|
|
# stop looking at next chars as Wouxun does not
|
|
# always clear the remaining bytes
|
|
break
|
|
mem.name = mem.name.rstrip()
|
|
|
|
mem.extra = RadioSettingGroup("Extra", "Extra")
|
|
rs = RadioSetting("mute_mode", "Mute Mode",
|
|
RadioSettingValueList(
|
|
SPMUTE_LIST, SPMUTE_LIST[_mem.mute_mode]))
|
|
mem.extra.append(rs)
|
|
rs = RadioSetting("scrambler", "Scramble Descramble",
|
|
RadioSettingValueList(
|
|
SCRAMBLE_LIST, SCRAMBLE_LIST[_mem.scrambler]))
|
|
mem.extra.append(rs)
|
|
rs = RadioSetting("compander", "Compander",
|
|
RadioSettingValueList(
|
|
ONOFF_LIST, ONOFF_LIST[_mem.compander]))
|
|
mem.extra.append(rs)
|
|
# if _mem.am_mode != 0:
|
|
rs = RadioSetting("am_mode", "AM Mode",
|
|
RadioSettingValueMap(
|
|
self.am_mode_list_ch, _mem.am_mode))
|
|
mem.extra.append(rs)
|
|
rs = RadioSetting("favorite", "Favorite",
|
|
RadioSettingValueList(
|
|
ONOFF_LIST, ONOFF_LIST[_mem.favorite]))
|
|
mem.extra.append(rs)
|
|
rs = RadioSetting("send_loc", "Send Location",
|
|
RadioSettingValueList(
|
|
ONOFF_LIST, ONOFF_LIST[_mem.send_loc]))
|
|
mem.extra.append(rs)
|
|
|
|
if _mem.call_group == 0:
|
|
_mem.call_group = 1
|
|
rs = RadioSetting("call_group", "Call Group",
|
|
RadioSettingValueMap(
|
|
MAP_1_99, _mem.call_group))
|
|
mem.extra.append(rs)
|
|
|
|
self._get_tone(_mem, mem)
|
|
|
|
mem.skip = "" if bool(_mem.scan_add) else "S"
|
|
_mem.power = _mem.power & 0x3
|
|
if _mem.power > 3:
|
|
_mem.power = 3
|
|
mem.power = self.POWER_LEVELS[_mem.power]
|
|
if _mem.am_mode != 0:
|
|
mem.mode = "AM"
|
|
elif _mem.iswide:
|
|
mem.mode = "FM"
|
|
else:
|
|
mem.mode = "NFM"
|
|
return mem
|
|
|
|
def _scan_grp(self):
|
|
"""Scan groups
|
|
"""
|
|
_settings = self._memobj.settings
|
|
|
|
def apply_name(setting, obj):
|
|
name = str2name(setting.value, 12, '\0', '\0')
|
|
obj.name = name
|
|
|
|
def apply_start(setting, obj):
|
|
"""Do a callback to deal with RadioSettingInteger limitation
|
|
on memory address resolution
|
|
"""
|
|
obj.scan_st = int(setting.value)
|
|
|
|
def apply_end(setting, obj):
|
|
"""Do a callback to deal with RadioSettingInteger limitation
|
|
on memory address resolution
|
|
"""
|
|
obj.scan_end = int(setting.value)
|
|
|
|
sgrp = self._memobj.scn_grps
|
|
scan = RadioSettingGroup("scn_grps", "Channel Scan Groups")
|
|
rs = RadioSetting("ScnGrpA_Act", "Scan Group A Active",
|
|
RadioSettingValueList(SCANGRP_LIST,
|
|
SCANGRP_LIST[_settings.
|
|
ScnGrpA_Act]))
|
|
scan.append(rs)
|
|
rs = RadioSetting("ScnGrpB_Act", "Scan Group B Active",
|
|
RadioSettingValueList(SCANGRP_LIST,
|
|
SCANGRP_LIST[_settings.
|
|
ScnGrpB_Act]))
|
|
scan.append(rs)
|
|
for i in range(0, 10):
|
|
s_grp = sgrp.addrs[i]
|
|
s_name = sgrp.names[i]
|
|
rs_name = RadioSettingValueString(0, 12,
|
|
name2str(s_name.name))
|
|
rs = RadioSetting("scn_grps.names[%i].name" % i,
|
|
"Group %i Name" % (i + 1), rs_name)
|
|
rs.set_apply_callback(apply_name, s_name)
|
|
scan.append(rs)
|
|
rs_st = RadioSettingValueInteger(1, 999, s_grp.scan_st)
|
|
rs = RadioSetting("scn_grps.addrs[%i].scan_st" % i,
|
|
" Group %i Start Channel" % (i + 1), rs_st)
|
|
rs.set_apply_callback(apply_start, s_grp)
|
|
scan.append(rs)
|
|
rs_end = RadioSettingValueInteger(1, 999, s_grp.scan_end)
|
|
rs = RadioSetting("scn_grps.addrs[%i].scan_end" % i,
|
|
" Group %i End Channel" % (i + 1), rs_end)
|
|
rs.set_apply_callback(apply_end, s_grp)
|
|
scan.append(rs)
|
|
return scan
|
|
|
|
def _set_tone(self, mem, _mem):
|
|
def _set_dcs(code, pol):
|
|
val = int("%i" % code, 8) | 0x4000
|
|
if pol == "R":
|
|
val += 0x2000
|
|
return val
|
|
|
|
rx_mode = tx_mode = None
|
|
rxtone = txtone = 0x0000
|
|
|
|
if mem.tmode == "Tone":
|
|
tx_mode = "Tone"
|
|
rx_mode = None
|
|
txtone = int(mem.rtone * 10) + 0x8000
|
|
elif mem.tmode == "TSQL":
|
|
rx_mode = tx_mode = "Tone"
|
|
rxtone = txtone = int(mem.ctone * 10) + 0x8000
|
|
elif mem.tmode == "DTCS":
|
|
tx_mode = rx_mode = "DTCS"
|
|
txtone = _set_dcs(mem.dtcs, mem.dtcs_polarity[0])
|
|
rxtone = _set_dcs(mem.dtcs, mem.dtcs_polarity[1])
|
|
elif mem.tmode == "Cross":
|
|
tx_mode, rx_mode = mem.cross_mode.split("->")
|
|
if tx_mode == "DTCS":
|
|
txtone = _set_dcs(mem.dtcs, mem.dtcs_polarity[0])
|
|
elif tx_mode == "Tone":
|
|
txtone = int(mem.rtone * 10) + 0x8000
|
|
if rx_mode == "DTCS":
|
|
rxtone = _set_dcs(mem.rx_dtcs, mem.dtcs_polarity[1])
|
|
elif rx_mode == "Tone":
|
|
rxtone = int(mem.ctone * 10) + 0x8000
|
|
|
|
_mem.rxtone = rxtone
|
|
_mem.txtone = txtone
|
|
|
|
LOG.debug("Set TX %s (%i) RX %s (%i)" %
|
|
(tx_mode, _mem.txtone, rx_mode, _mem.rxtone))
|
|
|
|
def set_memory(self, mem):
|
|
number = mem.number
|
|
|
|
_mem = self._memobj.memory[number]
|
|
_nam = self._memobj.names[number]
|
|
|
|
if mem.empty:
|
|
_mem.set_raw("\x00" * (_mem.size() // 8))
|
|
self._memobj.valid[number] = 0
|
|
self._memobj.names[number].set_raw("\x00" * (_nam.size() // 8))
|
|
return
|
|
|
|
_mem.rxfreq = int(mem.freq / 10)
|
|
if mem.duplex == "off":
|
|
# _mem.txfreq = 0xFFFFFFFF
|
|
_mem.txfreq = 0x00000000
|
|
elif mem.duplex == "split":
|
|
_mem.txfreq = int(mem.offset / 10)
|
|
elif mem.duplex == "off":
|
|
for i in range(0, 4):
|
|
_mem.txfreq[i].set_raw("\xFF")
|
|
elif mem.duplex == "+":
|
|
_mem.txfreq = int(mem.freq / 10) + int(mem.offset / 10)
|
|
elif mem.duplex == "-":
|
|
_mem.txfreq = int(mem.freq / 10) - int(mem.offset / 10)
|
|
else:
|
|
_mem.txfreq = int(mem.freq / 10)
|
|
_mem.scan_add = int(mem.skip != "S")
|
|
if ((mem.mode == "FM") or (mem.mode == "NFM")):
|
|
_mem.iswide = int((mem.mode == "FM"))
|
|
_mem.am_mode = 0
|
|
elif mem.mode == "AM":
|
|
_mem.am_mode = 1
|
|
# Q10H radio only supports wide AM mode
|
|
_mem.iswide = 1
|
|
# set the tone
|
|
self._set_tone(mem, _mem)
|
|
|
|
# set the power
|
|
_mem.power = _mem.power & 0x3
|
|
if mem.power:
|
|
if _mem.power > 3:
|
|
_mem.power = 3
|
|
_mem.power = self.POWER_LEVELS.index(mem.power)
|
|
else:
|
|
_mem.power = True
|
|
|
|
for setting in mem.extra:
|
|
if setting.get_name() != "am_mode":
|
|
setattr(_mem, setting.get_name(), setting.value)
|
|
else:
|
|
if mem.mode != "AM":
|
|
setattr(_mem, setting.get_name(), 0)
|
|
elif int(setting.value) == 2:
|
|
setattr(_mem, setting.get_name(), 2)
|
|
elif int(setting.value) == 1:
|
|
setattr(_mem, setting.get_name(), 1)
|
|
|
|
for i in range(0, len(_nam.name)):
|
|
if i < len(mem.name) and mem.name[i]:
|
|
_nam.name[i] = ord(mem.name[i])
|
|
else:
|
|
_nam.name[i] = 0x0
|
|
self._memobj.valid[mem.number] = MEM_VALID
|
|
|
|
def _get_settings(self):
|
|
if self.use_color:
|
|
from chirp.settings import RadioSettingValueRGB
|
|
|
|
_settings = self._memobj.settings
|
|
_vfoa = self._memobj.vfoa
|
|
_vfob = self._memobj.vfob
|
|
_vfo_scan = self._memobj.vfo_scan
|
|
# _callname = self._memobj.call_names
|
|
_fm = self._memobj.fm
|
|
scan_grp = self._scan_grp()
|
|
_oem = self._memobj.oem_info
|
|
firmware_rev = str(_oem.firmware)
|
|
# release of Q10H Firmware VC1.02 includes 20K Step
|
|
LOG.debug("Firmware revision %s detected" % firmware_rev)
|
|
if firmware_rev not in (NO_20K_STEP_FIRMWARE):
|
|
steps = STEP2_LIST
|
|
LOG.debug("20K Step Included")
|
|
else:
|
|
steps = STEP_LIST
|
|
LOG.debug("20K Step NOT Included")
|
|
|
|
cfg_grp = RadioSettingGroup("cfg_grp", "Config Settings")
|
|
if self.use_color:
|
|
cfg_grp[0] = RadioSettingGroup("color_grp", "Custom Theme Colors")
|
|
else:
|
|
cfg_grp[0] = RadioSettingGroup("color_grp",
|
|
"Custom Theme Colors (RGB565)")
|
|
cfg_grp[0][1] = RadioSettingGroup("color_grp",
|
|
"Integer value of RGB565 Color")
|
|
cfg_grp[0][2] = RadioSettingGroup("color_grp",
|
|
"Search- RGB565 Color Picker")
|
|
vfoa_grp = RadioSettingGroup("vfoa_grp", self.vfoa_grp_label)
|
|
vfoa_grp[0] = RadioSettingGroup("vfoa150_grp", "150M Settings")
|
|
vfoa_grp[1] = RadioSettingGroup("vfoa400_grp", "400M Settings")
|
|
vfoa_grp[2] = RadioSettingGroup("vfoa200_grp", "200M Settings")
|
|
vfoa_grp[3] = RadioSettingGroup("vfoa3_grp", self.vfoa3_msg)
|
|
vfoa_grp[4] = RadioSettingGroup("vfoa800_grp", "800M Settings")
|
|
vfoa_grp[5] = RadioSettingGroup("vfoa300_grp", "300M Settings")
|
|
vfob_grp = RadioSettingGroup("vfob_grp", self.vfob_grp_label)
|
|
vfob_grp[0] = RadioSettingGroup("vfob150_grp", "150M Settings")
|
|
vfob_grp[1] = RadioSettingGroup("vfob400_grp", "400M Settings")
|
|
key_grp = RadioSettingGroup("key_grp", "Key Settings")
|
|
fmradio_grp = RadioSettingGroup("fmradio_grp", "FM Broadcast Memory")
|
|
lmt_grp = RadioSettingGroup("lmt_grp", "Frequency Limits")
|
|
lmt_grp[0] = RadioSettingGroup("lmt_grp", "TX Limits")
|
|
lmt_grp[1] = RadioSettingGroup("lmt_grp", "RX Limits")
|
|
oem_grp = RadioSettingGroup("oem_grp", "OEM Info")
|
|
scanv_grp = RadioSettingGroup("scnv_grp", "VFO Scan Mode")
|
|
call_grp = RadioSettingGroup("call_grp", "Call Group Settings")
|
|
|
|
if self.show_limits:
|
|
group = RadioSettings(cfg_grp, vfoa_grp, vfob_grp,
|
|
fmradio_grp, key_grp, scan_grp, scanv_grp,
|
|
call_grp, lmt_grp, oem_grp)
|
|
else:
|
|
group = RadioSettings(cfg_grp, vfoa_grp, vfob_grp,
|
|
fmradio_grp, key_grp, scan_grp, scanv_grp,
|
|
call_grp, oem_grp)
|
|
|
|
# # Call Settings
|
|
|
|
def apply_callid(setting, obj):
|
|
c = str2callid(setting.value)
|
|
obj.cid = c
|
|
|
|
for i in range(1, 100):
|
|
call = self._memobj.call_names[i].call_name
|
|
_msg = str(call).split("\0")[0]
|
|
val = RadioSettingValueString(0, 12, _msg)
|
|
val.set_mutable(True)
|
|
rs = RadioSetting("call_names[%i].call_name" % i,
|
|
"Call Name %i" % i, val)
|
|
call_grp.append(rs)
|
|
|
|
callid = self._memobj.call_ids[i]
|
|
c_id = RadioSettingValueString(0, 6,
|
|
self.callid2str(callid.cid),
|
|
False)
|
|
rs = RadioSetting("call_ids[%i].cid" % i,
|
|
" Call Code %s" % str(i), c_id)
|
|
rs.set_apply_callback(apply_callid, callid)
|
|
call_grp.append(rs)
|
|
|
|
# Configuration Settings
|
|
#
|
|
rs = RadioSetting("channel_menu", "Menu available in channel mode",
|
|
RadioSettingValueBoolean(_settings.channel_menu))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("power_save", "Battery Saver - menu 4",
|
|
RadioSettingValueBoolean(_settings.power_save))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("wxalert", "Weather Alert - menu 5",
|
|
RadioSettingValueBoolean(_settings.wxalert))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("wxalert_type",
|
|
"Weather Alert Notification - menu 6",
|
|
RadioSettingValueList(WX_TYPE,
|
|
WX_TYPE[_settings.
|
|
wxalert_type]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("roger_beep", "Roger Beep - menu 13",
|
|
RadioSettingValueList(ROGER_LIST,
|
|
ROGER_LIST[_settings.
|
|
roger_beep]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("timeout", "Timeout Timer (TOT) - menu 14",
|
|
RadioSettingValueList(
|
|
TIMEOUT_LIST, TIMEOUT_LIST[_settings.timeout]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("toalarm", "Timeout Pre-Alert (TOA) - menu 15",
|
|
RadioSettingValueList(LIST_10S,
|
|
LIST_10S[_settings.toalarm]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("vox", "VOX - menu 16",
|
|
RadioSettingValueList(LIST_10,
|
|
LIST_10[_settings.vox]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("voice", "Voice Guide - menu 17",
|
|
RadioSettingValueBoolean(_settings.voice))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("beep", "Keypad Beep - menu 18",
|
|
RadioSettingValueBoolean(_settings.beep))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("scan_rev", "Scan Mode - menu 8",
|
|
RadioSettingValueList(SCANMODE_LIST,
|
|
SCANMODE_LIST[_settings.
|
|
scan_rev]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("backlight", "Backlight Active Time - menu 3",
|
|
RadioSettingValueList(BACKLIGHT_LIST,
|
|
BACKLIGHT_LIST[_settings.
|
|
backlight]))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("DspBrtAct", "Display Brightness ACTIVE - menu 1",
|
|
RadioSettingValueMap(DSPBRTACT_MAP,
|
|
_settings.DspBrtAct))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("DspBrtSby", "Display Brightness STANDBY - menu 2",
|
|
RadioSettingValueList(
|
|
DSPBRTSBY_LIST, DSPBRTSBY_LIST[
|
|
_settings.DspBrtSby]))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("theme", "Theme - menu 7",
|
|
RadioSettingValueList(
|
|
self.themelist,
|
|
self.themelist[_settings.theme]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("ponmsg", "Startup Display - menu 27",
|
|
RadioSettingValueList(
|
|
PONMSG_LIST, PONMSG_LIST[_settings.ponmsg]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("batt_ind", "Battery Indicator - menu 39",
|
|
RadioSettingValueList(
|
|
BATT_DISP_LIST,
|
|
BATT_DISP_LIST[_settings.batt_ind]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("ptt_id", self.idtx_msg,
|
|
RadioSettingValueList(PTTID_LIST,
|
|
PTTID_LIST[_settings.ptt_id]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("ptt_delay", self.pttdly_msg,
|
|
RadioSettingValueMap(PTTDELAY_TIMES,
|
|
_settings.ptt_delay))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("dtmf_st", "DTMF Sidetone - menu 31",
|
|
RadioSettingValueList(DTMFST_LIST,
|
|
DTMFST_LIST[_settings.
|
|
dtmf_st]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("dtmf_tx_time", "DTMF Transmit Time",
|
|
RadioSettingValueMap(DTMF_TIMES,
|
|
_settings.dtmf_tx_time))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("dtmf_interval", "DTMF Interval Time",
|
|
RadioSettingValueMap(DTMF_TIMES,
|
|
_settings.dtmf_interval))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("ring_time", "Ring Time - menu 35",
|
|
RadioSettingValueList(LIST_10S,
|
|
LIST_10S[_settings.ring_time]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("alert", "Alert Tone - menu 36",
|
|
RadioSettingValueList(ALERTS_LIST,
|
|
ALERTS_LIST[_settings.alert]))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("autolock", "Autolock - menu 30",
|
|
RadioSettingValueBoolean(_settings.autolock))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("prich_sw", "Priority Channel Scan - menu 11",
|
|
RadioSettingValueList(PRICHAN_LIST,
|
|
PRICHAN_LIST[
|
|
_settings.prich_sw]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("pri_ch",
|
|
"Priority Channel - Can not be empty Channel",
|
|
RadioSettingValueInteger(1, 999, _settings.pri_ch))
|
|
cfg_grp.append(rs)
|
|
|
|
if self.MODEL == "KG-Q10H":
|
|
rs = RadioSetting("rpttype", "Repeater Type - menu 40",
|
|
RadioSettingValueMap(RPTTYPE_MAP,
|
|
_settings.rpttype))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("rpt_spk", "Repeater SPK - menu 41",
|
|
RadioSettingValueBoolean(_settings.rpt_spk))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("rpt_ptt", "Repeater PTT - menu 42",
|
|
RadioSettingValueBoolean(_settings.rpt_ptt))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("rpt_tone",
|
|
"Repeater Tone - menu %i" % self.rpttonemenu,
|
|
RadioSettingValueBoolean(_settings.rpt_tone))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("rpt_hold", "RPT Hold Time",
|
|
RadioSettingValueList(
|
|
HOLD_TIMES, HOLD_TIMES[_settings.rpt_hold]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("scan_det", "Scan Mode Tone Detect - menu 9",
|
|
RadioSettingValueBoolean(_settings.scan_det))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("ToneScnSave", "Tone Scan Save - menu 12",
|
|
RadioSettingValueList(TONESCANSAVELIST,
|
|
TONESCANSAVELIST[_settings.
|
|
ToneScnSave]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("smuteset", "Sub-Freq Mute (SMUTESET) - menu 38",
|
|
RadioSettingValueList(SMUTESET_LIST,
|
|
SMUTESET_LIST[_settings.
|
|
smuteset]))
|
|
cfg_grp.append(rs)
|
|
# rs = RadioSetting("ani_sw", ani_msg,
|
|
# RadioSettingValueBoolean(_settings.ani_sw))
|
|
# cfg_grp.append(rs)
|
|
|
|
# rs = RadioSetting("sim_rec", "Simultaneous Receive",
|
|
# RadioSettingValueBoolean(_settings.sim_rec))
|
|
# cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("disp_time",
|
|
"Display Time - menu %i" % self.timemenu,
|
|
RadioSettingValueBoolean(_settings.disp_time))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("time_zone", "Time Zone - menu %i" % self.tzmenu,
|
|
RadioSettingValueList(
|
|
TIME_ZONE,
|
|
TIME_ZONE[_settings.time_zone]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("GPS", "GPS - menu %i.1" % self.locmenu,
|
|
RadioSettingValueBoolean(_settings.GPS))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("GPS_send_freq",
|
|
"GPS Send Frequency - menu %i.2" % self.locmenu,
|
|
RadioSettingValueList(
|
|
GPS_SEND_FREQ,
|
|
GPS_SEND_FREQ[_settings.GPS_send_freq]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("GPS_rcv", "GPS Receive - menu %i.3" % self.locmenu,
|
|
RadioSettingValueBoolean(_settings.GPS_rcv))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("stopwatch", "Timer / Stopwatch Enabled - menu 37",
|
|
RadioSettingValueBoolean(_settings.stopwatch))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("keylock", "Keypad Locked",
|
|
RadioSettingValueBoolean(_settings.keylock))
|
|
cfg_grp.append(rs)
|
|
|
|
rs = RadioSetting("act_area", "Active Area",
|
|
RadioSettingValueList(
|
|
ACTIVE_AREA_LIST,
|
|
ACTIVE_AREA_LIST[_settings.act_area]))
|
|
cfg_grp.append(rs)
|
|
rs = RadioSetting("tdr", "TDR",
|
|
RadioSettingValueList(
|
|
TDR_LIST,
|
|
TDR_LIST[_settings.tdr]))
|
|
cfg_grp.append(rs)
|
|
|
|
pswdchars = "0123456789"
|
|
_msg = str(_settings.mode_sw_pwd).split("\0")[0]
|
|
val = RadioSettingValueString(0, 6, _msg, False)
|
|
val.set_mutable(True)
|
|
val.set_charset(pswdchars)
|
|
rs = RadioSetting("mode_sw_pwd", "Mode SW Pwd", val)
|
|
cfg_grp.append(rs)
|
|
|
|
_msg = str(_settings.reset_pwd).split("\0")[0]
|
|
val = RadioSettingValueString(0, 6, _msg, False)
|
|
val.set_charset(pswdchars)
|
|
val.set_mutable(True)
|
|
rs = RadioSetting("reset_pwd", "Reset Pwd", val)
|
|
cfg_grp.append(rs)
|
|
# Custom Color Settings
|
|
if self.use_color:
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol1_text)
|
|
rs = RadioSetting("settings.custcol1_text", "Custom 1 - Text",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol1_bg)
|
|
rs = RadioSetting("settings.custcol1_bg", "Custom 1 - Background",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol1_icon)
|
|
rs = RadioSetting("settings.custcol1_icon", "Custom 1 - Icon",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol1_line)
|
|
rs = RadioSetting("settings.custcol1_line", "Custom 1 - Line",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol2_text)
|
|
rs = RadioSetting("settings.custcol2_text", " Custom 2 - Text",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol2_bg)
|
|
rs = RadioSetting("settings.custcol2_bg",
|
|
" Custom 2 - Background",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol2_icon)
|
|
rs = RadioSetting("settings.custcol2_icon", " Custom 2 - Icon",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol2_line)
|
|
rs = RadioSetting("settings.custcol2_line", " Custom 2 - Line",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol3_text)
|
|
rs = RadioSetting("settings.custcol3_text", "Custom 3 - Text",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol3_bg)
|
|
rs = RadioSetting("settings.custcol3_bg", "Custom 3 - Background",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol3_icon)
|
|
rs = RadioSetting("settings.custcol3_icon", "Custom 3 - Icon",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol3_line)
|
|
rs = RadioSetting("settings.custcol3_line", "Custom 3 - Line",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol4_text)
|
|
rs = RadioSetting("settings.custcol4_text",
|
|
" Custom 4 - Text",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol4_bg)
|
|
rs = RadioSetting("settings.custcol4_bg",
|
|
" Custom 4 - Background",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol4_icon)
|
|
rs = RadioSetting("settings.custcol4_icon",
|
|
" Custom 4 - Icon",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
val = RadioSettingValueRGB.from_rgb16(_settings.custcol4_line)
|
|
rs = RadioSetting("settings.custcol4_line",
|
|
" Custom 4 - Line",
|
|
val)
|
|
cfg_grp[0].append(rs)
|
|
else:
|
|
rs = RadioSetting("settings.custcol1_text", "Custom 1 - Text",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol1_text))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol1_bg", "Custom 1 - Background",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol1_bg))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol1_icon", "Custom 1 - Icon",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol1_icon))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol1_line", "Custom 1 - Line",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol1_line))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol2_text", "Custom 2 - Text",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol2_text))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol2_bg", "Custom 2 - Background",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol1_bg))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol2_icon", "Custom 2 - Icon",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol1_icon))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol2_line", "Custom 2 - Line",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol2_line))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol3_text", "Custom 3 - Text",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol3_text))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol3_bg", "Custom 3 - Background",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol3_bg))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol3_icon", "Custom 3 - Icon",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol3_icon))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol3_line", "Custom 3 - Line",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol3_line))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol4_text", "Custom 4 - Text",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol4_text))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol4_bg", "Custom 4 - Background",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol4_bg))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol4_icon", "Custom 4 - Icon",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol4_icon))
|
|
cfg_grp[0].append(rs)
|
|
rs = RadioSetting("settings.custcol4_line", "Custom 4 - Line",
|
|
RadioSettingValueInteger(
|
|
0, 65535, _settings.custcol4_line))
|
|
cfg_grp[0].append(rs)
|
|
|
|
|
|
# # Key Settings
|
|
# #
|
|
_msg = str(_settings.dispstr).split("\0")[0]
|
|
val = RadioSettingValueString(0, 12, _msg)
|
|
val.set_mutable(True)
|
|
rs = RadioSetting("dispstr",
|
|
self.dispmesg, val)
|
|
key_grp.append(rs)
|
|
|
|
def _decode(lst):
|
|
_str = ''.join([chr(int(c)) for c in lst
|
|
if chr(int(c)) in chirp_common.CHARSET_ASCII])
|
|
return _str
|
|
|
|
_str = _decode(self._memobj.settings.areamsg)
|
|
val = RadioSettingValueString(0, 12, _str)
|
|
val.set_mutable(True)
|
|
rs = RadioSetting("settings.areamsg", self.areamsglabel, val)
|
|
key_grp.append(rs)
|
|
|
|
def apply_ani_id(setting, obj):
|
|
c = str2callid(setting.value)
|
|
obj.ani_id = c
|
|
|
|
cid = self._memobj.settings
|
|
my_callid = RadioSettingValueString(3, 6,
|
|
self.callid2str(cid.ani_id),
|
|
False)
|
|
rs = RadioSetting("ani_id", "Radio ID", my_callid)
|
|
rs.set_apply_callback(apply_ani_id, cid)
|
|
key_grp.append(rs)
|
|
|
|
stun = self._memobj.settings
|
|
st = RadioSettingValueString(0, 6, digits2str(stun.scc), False)
|
|
rs = RadioSetting("scc", "Control code", st)
|
|
rs.set_apply_callback(apply_scc, stun)
|
|
key_grp.append(rs)
|
|
|
|
rs = RadioSetting("ptt1", "PTT1 Key function",
|
|
RadioSettingValueList(
|
|
PTT_LIST,
|
|
PTT_LIST[_settings.ptt1]))
|
|
key_grp.append(rs)
|
|
rs = RadioSetting("ptt2", "PTT2 Key function",
|
|
RadioSettingValueList(
|
|
PTT_LIST,
|
|
PTT_LIST[_settings.ptt2]))
|
|
key_grp.append(rs)
|
|
rs = RadioSetting("top_short", "TOP SHORT Key function",
|
|
RadioSettingValueList(
|
|
self._prog_key,
|
|
self._prog_key[_settings.top_short]))
|
|
key_grp.append(rs)
|
|
rs = RadioSetting("top_long", "TOP LONG Key function",
|
|
RadioSettingValueList(
|
|
self._prog_key,
|
|
self._prog_key[_settings.top_long]))
|
|
key_grp.append(rs)
|
|
|
|
rs = RadioSetting("pf1_short", "PF1 SHORT Key function",
|
|
RadioSettingValueList(
|
|
self._prog_key,
|
|
self._prog_key[_settings.pf1_short]))
|
|
key_grp.append(rs)
|
|
rs = RadioSetting("pf1_long", "PF1 LONG Key function",
|
|
RadioSettingValueList(
|
|
self._prog_key,
|
|
self._prog_key[_settings.pf1_long]))
|
|
key_grp.append(rs)
|
|
rs = RadioSetting("pf2_short", "PF2 SHORT Key function",
|
|
RadioSettingValueList(
|
|
self._prog_key,
|
|
self._prog_key[_settings.pf2_short]))
|
|
key_grp.append(rs)
|
|
rs = RadioSetting("pf2_long", "PF2 LONG Key function",
|
|
RadioSettingValueList(
|
|
self._prog_key,
|
|
self._prog_key[_settings.pf2_long]))
|
|
key_grp.append(rs)
|
|
|
|
# # SCAN GROUP settings
|
|
rs = RadioSetting("settings.vfo_scanmodea", "VFO A Scan Mode",
|
|
RadioSettingValueList(
|
|
VFO_SCANMODE_LIST,
|
|
VFO_SCANMODE_LIST[_settings.vfo_scanmodea]))
|
|
scanv_grp.append(rs)
|
|
rs = RadioSetting("vfo_scan.vfo_scan_start_A",
|
|
" VFO A Scan Start (MHz)",
|
|
RadioSettingValueInteger(
|
|
1, 999, _vfo_scan.vfo_scan_start_A))
|
|
scanv_grp.append(rs)
|
|
rs = RadioSetting("vfo_scan.vfo_scan_end_A",
|
|
" VFO A Scan End (MHz)",
|
|
RadioSettingValueInteger(
|
|
1, 999, _vfo_scan.vfo_scan_end_A))
|
|
scanv_grp.append(rs)
|
|
rs = RadioSetting("settings.vfo_scanmodeb", "VFO B Scan Mode",
|
|
RadioSettingValueList(
|
|
VFO_SCANMODE_LIST,
|
|
VFO_SCANMODE_LIST[_settings.vfo_scanmodeb]))
|
|
scanv_grp.append(rs)
|
|
rs = RadioSetting("vfo_scan.vfo_scan_start_B",
|
|
" VFO B Scan Start (MHz)",
|
|
RadioSettingValueInteger(
|
|
1, 999, _vfo_scan.vfo_scan_start_B))
|
|
scanv_grp.append(rs)
|
|
rs = RadioSetting("vfo_scan.vfo_scan_end_B",
|
|
" VFO B Scan End (MHz)",
|
|
RadioSettingValueInteger(
|
|
1, 999, _vfo_scan.vfo_scan_end_B))
|
|
scanv_grp.append(rs)
|
|
|
|
# VFO A Settings
|
|
#
|
|
wml = self.workmodelist
|
|
rs = RadioSetting("work_mode_a", self.vfo_area + "A Workmode",
|
|
RadioSettingValueList(wml,
|
|
wml[_settings.work_mode_a]))
|
|
vfoa_grp.append(rs)
|
|
rs = RadioSetting("work_ch_a", self.vfo_area + "A Work Channel",
|
|
RadioSettingValueInteger(1, 999,
|
|
_settings.work_ch_a))
|
|
vfoa_grp.append(rs)
|
|
for i in range(0, 6):
|
|
rs = RadioSetting("vfoa[%i].rxfreq" % i,
|
|
self.vfo_area + "A Rx Frequency (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.00000, 999.999999,
|
|
(_vfoa[i].rxfreq / 100000.0),
|
|
0.000001, 6))
|
|
vfoa_grp[i].append(rs)
|
|
if self.MODEL == "KG-Q10H":
|
|
rs = RadioSetting("vfoa[%i].offset" % i,
|
|
self.vfo_area + "A Offset (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.00000, 599.999999,
|
|
(_vfoa[i].offset / 100000.0),
|
|
0.000001, 6))
|
|
vfoa_grp[i].append(rs)
|
|
|
|
rs = RadioSetting("vfoa[%i].rxtone" % i,
|
|
self.vfo_area + "A Rx tone",
|
|
RadioSettingValueMap(
|
|
TONE_MAP, _vfoa[i].rxtone))
|
|
vfoa_grp[i].append(rs)
|
|
rs = RadioSetting("vfoa[%i].txtone" % i,
|
|
self.vfo_area + "A Tx tone",
|
|
RadioSettingValueMap(
|
|
TONE_MAP, _vfoa[i].txtone))
|
|
vfoa_grp[i].append(rs)
|
|
|
|
# # MRT - AND power with 0x03 to display only the lower 2 bits for
|
|
# # power level and to clear the upper bits
|
|
# # MRT - any bits set in the upper 2 bits will cause radio to show
|
|
# # invalid values for power level and a display glitch
|
|
# # MRT - when PTT is pushed
|
|
_vfoa[i].power = _vfoa[i].power & 0x3
|
|
if _vfoa[i].power > 3:
|
|
_vfoa[i].power = 3
|
|
rs = RadioSetting("vfoa[%i].power" % i, self.vfo_area + "A Power",
|
|
RadioSettingValueList(
|
|
POWER_LIST, POWER_LIST[_vfoa[i].power]))
|
|
vfoa_grp[i].append(rs)
|
|
rs = RadioSetting("vfoa[%i].iswide" % i,
|
|
self.vfo_area + "A Wide/Narrow",
|
|
RadioSettingValueList(
|
|
BANDWIDTH_LIST,
|
|
BANDWIDTH_LIST[_vfoa[i].iswide]))
|
|
vfoa_grp[i].append(rs)
|
|
rs = RadioSetting("vfoa[%i].mute_mode" % i,
|
|
self.vfo_area + "A Mute (SP Mute)",
|
|
RadioSettingValueList(
|
|
SPMUTE_LIST,
|
|
SPMUTE_LIST[_vfoa[i].mute_mode]))
|
|
vfoa_grp[i].append(rs)
|
|
rs = RadioSetting("vfoa[%i].ofst_dir" % i,
|
|
self.vfo_area + self._offset_dir_rpt_label,
|
|
RadioSettingValueList(
|
|
self._offset_dir_rpt,
|
|
self._offset_dir_rpt[_vfoa[i].ofst_dir]))
|
|
vfoa_grp[i].append(rs)
|
|
rs = RadioSetting("vfoa[%i].scrambler" % i,
|
|
self.vfo_area + "A Scramble/Descramble",
|
|
RadioSettingValueList(
|
|
SCRAMBLE_LIST,
|
|
SCRAMBLE_LIST[_vfoa[i].scrambler]))
|
|
vfoa_grp[i].append(rs)
|
|
|
|
rs = RadioSetting("vfoa[%i].compander" % i,
|
|
self.vfo_area + "A Compander",
|
|
RadioSettingValueList(
|
|
ONOFF_LIST, ONOFF_LIST[_vfoa[i].compander]))
|
|
vfoa_grp[i].append(rs)
|
|
rs = RadioSetting("vfoa[%i].call_group" % i,
|
|
self.vfo_area + "A Call Group",
|
|
RadioSettingValueInteger(
|
|
1, 99, _vfoa[i].call_group))
|
|
vfoa_grp[i].append(rs)
|
|
rs = RadioSetting("vfoa[%i].am_mode" % i,
|
|
self.vfo_area + "A AM Mode",
|
|
RadioSettingValueList(
|
|
self.am_mode_list,
|
|
self.am_mode_list[_vfoa[i].am_mode]))
|
|
vfoa_grp[i].append(rs)
|
|
|
|
rs = RadioSetting("settings.vfostepA", self.vfo_area + "A Step (kHz)",
|
|
RadioSettingValueList(
|
|
steps, steps[_settings.vfostepA]))
|
|
vfoa_grp.append(rs)
|
|
rs = RadioSetting("settings.squelchA", self.vfo_area + "A Squelch",
|
|
RadioSettingValueList(
|
|
LIST_10, LIST_10[_settings.squelchA]))
|
|
vfoa_grp.append(rs)
|
|
rs = RadioSetting("BCL_A", "Busy Channel Lock-out A",
|
|
RadioSettingValueBoolean(_settings.BCL_A))
|
|
vfoa_grp.append(rs)
|
|
rs = RadioSetting("settings.vfobandA", "VFO A Current Band",
|
|
RadioSettingValueMap(self._vfoaband,
|
|
_settings.vfobandA))
|
|
vfoa_grp.append(rs)
|
|
|
|
# # VFO B Settings
|
|
wml = self.workmodelist
|
|
rs = RadioSetting("work_mode_b", self.vfo_area + "B Workmode",
|
|
RadioSettingValueList(wml,
|
|
wml[_settings.work_mode_b]))
|
|
vfob_grp.append(rs)
|
|
rs = RadioSetting("work_ch_b", self.vfo_area + "B Work Channel",
|
|
RadioSettingValueInteger(1, 999,
|
|
_settings.work_ch_b))
|
|
vfob_grp.append(rs)
|
|
for i in range(0, 2):
|
|
rs = RadioSetting("vfob[%i].rxfreq" % i,
|
|
self.vfo_area + "B Rx Frequency (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.00000, 999.999999,
|
|
(_vfob[i].rxfreq / 100000.0),
|
|
0.000001, 6))
|
|
vfob_grp[i].append(rs)
|
|
if self.MODEL == "KG-Q10H":
|
|
rs = RadioSetting("vfob[%i].offset" % i,
|
|
self.vfo_area + "B Offset (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.00000, 599.999999,
|
|
(_vfob[i].offset / 100000.0),
|
|
0.000001, 6))
|
|
vfob_grp[i].append(rs)
|
|
|
|
rs = RadioSetting("vfob[%i].rxtone" % i,
|
|
self.vfo_area + "B Rx tone",
|
|
RadioSettingValueMap(
|
|
TONE_MAP, _vfob[i].rxtone))
|
|
vfob_grp[i].append(rs)
|
|
rs = RadioSetting("vfob[%i].txtone" % i,
|
|
self.vfo_area + "B Tx tone",
|
|
RadioSettingValueMap(
|
|
TONE_MAP, _vfob[i].txtone))
|
|
vfob_grp[i].append(rs)
|
|
|
|
# # MRT - AND power with 0x03 to display only the lower 2 bits for
|
|
# # power level and to clear the upper bits
|
|
# # MRT - any bits set in the upper 2 bits will cause radio to show
|
|
# # invalid values for power level and a display glitch
|
|
# # MRT - when PTT is pushed
|
|
_vfob[i].power = _vfob[i].power & 0x3
|
|
if _vfob[i].power > 3:
|
|
_vfob[i].power = 3
|
|
rs = RadioSetting("vfob[%i].power" % i,
|
|
self.vfo_area + "B Power",
|
|
RadioSettingValueList(
|
|
POWER_LIST, POWER_LIST[_vfob[i].power]))
|
|
vfob_grp[i].append(rs)
|
|
rs = RadioSetting("vfob[%i].iswide" % i,
|
|
self.vfo_area + "B Wide/Narrow",
|
|
RadioSettingValueList(
|
|
BANDWIDTH_LIST,
|
|
BANDWIDTH_LIST[_vfob[i].iswide]))
|
|
vfob_grp[i].append(rs)
|
|
rs = RadioSetting("vfob[%i].mute_mode" % i,
|
|
self.vfo_area + "B Mute (SP Mute)",
|
|
RadioSettingValueList(
|
|
SPMUTE_LIST,
|
|
SPMUTE_LIST[_vfob[i].mute_mode]))
|
|
vfob_grp[i].append(rs)
|
|
rs = RadioSetting("vfob[%i].ofst_dir" % i,
|
|
self.vfo_area + self._offset_dir_rpt_labelB,
|
|
RadioSettingValueList(
|
|
self._offset_dir_rpt,
|
|
self._offset_dir_rpt[_vfob[i].ofst_dir]))
|
|
vfob_grp[i].append(rs)
|
|
rs = RadioSetting("vfob[%i].scrambler" % i,
|
|
self.vfo_area + "B Scramble/Descramble",
|
|
RadioSettingValueList(
|
|
SCRAMBLE_LIST,
|
|
SCRAMBLE_LIST[_vfob[i].scrambler]))
|
|
vfob_grp[i].append(rs)
|
|
|
|
rs = RadioSetting("vfob[%i].compander" % i,
|
|
self.vfo_area + "B Compander",
|
|
RadioSettingValueList(
|
|
ONOFF_LIST, ONOFF_LIST[_vfob[i].compander]))
|
|
vfob_grp[i].append(rs)
|
|
rs = RadioSetting("vfob[%i].call_group" % i,
|
|
self.vfo_area + "B Call Group",
|
|
RadioSettingValueInteger(
|
|
1, 99, _vfob[i].call_group))
|
|
vfob_grp[i].append(rs)
|
|
|
|
rs = RadioSetting("settings.vfostepB", self.vfo_area + "B Step (kHz)",
|
|
RadioSettingValueList(
|
|
steps, steps[_settings.vfostepB]))
|
|
vfob_grp.append(rs)
|
|
rs = RadioSetting("settings.squelchB", self.vfo_area + "B Squelch",
|
|
RadioSettingValueList(
|
|
LIST_10, LIST_10[_settings.squelchB]))
|
|
vfob_grp.append(rs)
|
|
rs = RadioSetting("BCL_B", "Busy Channel Lock-out B",
|
|
RadioSettingValueBoolean(_settings.BCL_B))
|
|
vfob_grp.append(rs)
|
|
rs = RadioSetting("settings.vfobandB", "VFO B Current Band",
|
|
RadioSettingValueMap(VFOBBAND_MAP,
|
|
_settings.vfobandB))
|
|
vfob_grp.append(rs)
|
|
|
|
# FM RADIO PRESETS
|
|
|
|
# memory stores raw integer value like 760
|
|
# radio will divide 760 by 10 and interpret correctly at 76.0Mhz
|
|
for i in range(1, 21):
|
|
chan = str(i)
|
|
s = i-1
|
|
rs = RadioSetting("fm[%s].FM_radio" % s, "FM Preset " + chan,
|
|
RadioSettingValueFloat(76.0, 108.0,
|
|
_fm[i-1].FM_radio / 10.0,
|
|
0.1, 1))
|
|
fmradio_grp.append(rs)
|
|
|
|
if self.show_limits:
|
|
lim = self._memobj.limits
|
|
rs = RadioSetting("limits.m2tx_start",
|
|
"2M TX Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
118.000000, 299.999999,
|
|
(lim.m2tx_start / 100000.0),
|
|
0.000001, 6))
|
|
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.m2tx_stop",
|
|
"2M TX Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
118.000000, 299.999999,
|
|
(lim.m2tx_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.tworx_start",
|
|
"2M TX SUPER Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
108.000000, 299.999999,
|
|
(lim.tworx_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.tworx_stop",
|
|
"2M TX SUPER Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
108.000000, 299.999999,
|
|
(lim.tworx_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
|
|
rs = RadioSetting("limits.cm70_tx_start",
|
|
"70cm TX Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
300.000000, 999.999999,
|
|
(lim.cm70_tx_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.cm70_tx_stop",
|
|
"70cm TX Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
300.000000, 999.999999,
|
|
(lim.cm70_tx_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.m125_tx_start",
|
|
"1.25M TX Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
200.000000, 299.999999,
|
|
(lim.m125_tx_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.m125_tx_stop",
|
|
"1.25M TX Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
200.000000, 299.999999,
|
|
(lim.m125_tx_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.m6_tx_start",
|
|
"6M TX Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
26.000000, 99.999999,
|
|
(lim.m6_tx_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.m6_tx_stop",
|
|
"6M TX Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
26.000000, 99.999999,
|
|
(lim.m6_tx_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.rx1lim_start",
|
|
"2M Area A RX Lower Limit (MHz) - Verified",
|
|
RadioSettingValueFloat(
|
|
108.000000, 299.999999,
|
|
(lim.rx1lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx1lim_stop",
|
|
"2M Area A RX Upper Limit (MHz) - Verified",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx1lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx7lim_start",
|
|
"2M Area B RX Lower Limit (MHz) - Verified",
|
|
RadioSettingValueFloat(
|
|
136.000000, 999.999999,
|
|
(lim.rx7lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx7lim_stop",
|
|
"2M Area B RX Upper Limit (MHz) - Verified",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx7lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx12lim_start",
|
|
"2m Area A SUPER Rx Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx12lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx12lim_stop",
|
|
"2m Area A SUPER Rx Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx12lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx18lim_start",
|
|
"2m Area B SUPER Rx Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx18lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx18lim_stop",
|
|
"2m Area B SUPER Rx Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx18lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx13lim_start",
|
|
"70cm Area A SUPER Rx Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx13lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx13lim_stop",
|
|
"70cm Area A SUPER Rx Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx13lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx2lim_start",
|
|
"70cm Area A RX Lower Limit (MHz) - Verified",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx2lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx2lim_stop",
|
|
"70cm Area A RX Upper Limit (MHz) - Verified",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx2lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx8lim_start",
|
|
"70cm Area B RX Lower Limit (MHz) - Verified",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx8lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx8lim_stop",
|
|
"70cm Area B RX Upper Limit (MHz) - Verified",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx8lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx19lim_start",
|
|
"70cm Area B SUPER RX Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx19lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx19lim_stop",
|
|
"70cm Area B SUPER RX Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx19lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx3lim_start",
|
|
"1.25m RX Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx3lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx3lim_stop",
|
|
"1.25m RX Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx3lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx4lim_start",
|
|
"6M RX Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx4lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx4lim_stop",
|
|
"6M RX Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx4lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx5lim_start",
|
|
"800MHz Rz Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx5lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx5lim_stop",
|
|
"800MHz Rz Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx5lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx6lim_start",
|
|
"rx6_start Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx6lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx6lim_stop",
|
|
"rx6_stop Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx6lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx10lim_start",
|
|
"70cm Area B TX Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx10lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.rx10lim_stop",
|
|
"70cm Area B TX Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx10lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp[0].append(rs)
|
|
rs = RadioSetting("limits.rx14lim_start",
|
|
"rx14lim_start Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx14lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx14lim_stop",
|
|
"rx14lim_stop Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx14lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx15lim_start",
|
|
"rx15lim_start Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx15lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx15lim_stop",
|
|
"rx15lim_stop Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx15lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx16lim_start",
|
|
"rx16lim_start Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx16lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx16lim_stop",
|
|
"rx16lim_stop Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx16lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx17lim_start",
|
|
"rx17lim_start Lower Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx17lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.rx17lim_stop",
|
|
"rx17lim_stop Upper Limit (MHz)",
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(lim.rx17lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
for i in range(0, 14):
|
|
s = self._memobj.limits.more_limits[i]
|
|
rs = RadioSetting("limits.more_limits[%i].lim_start" % i,
|
|
"More %i Lower Limit (MHz)" % i,
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(s.lim_start / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
rs = RadioSetting("limits.more_limits[%i].lim_stop" % i,
|
|
"More %i Upper Limit (MHz)" % i,
|
|
RadioSettingValueFloat(
|
|
0.000000, 999.999999,
|
|
(s.lim_stop / 100000.0),
|
|
0.000001, 6))
|
|
lmt_grp.append(rs)
|
|
|
|
# # OEM info
|
|
|
|
def _decode(lst):
|
|
_str = ''.join([chr(int(c)) for c in lst
|
|
if chr(int(c)) in chirp_common.CHARSET_ASCII])
|
|
return _str
|
|
|
|
def do_nothing(setting, obj):
|
|
return
|
|
|
|
_str = _decode(self._memobj.oem_info.oem1)
|
|
val = RadioSettingValueString(0, 15, _str)
|
|
val.set_mutable(False)
|
|
rs = RadioSetting("oem_info.oem1", "OEM String 1", val)
|
|
rs.set_apply_callback(do_nothing, _settings)
|
|
oem_grp.append(rs)
|
|
# if self.MODEL == "KG-Q10H" :
|
|
_str = _decode(self._memobj.oem_info.name)
|
|
val = RadioSettingValueString(0, 15, _str)
|
|
val.set_mutable(False)
|
|
rs = RadioSetting("oem_info.name", "Radio Model", val)
|
|
rs.set_apply_callback(do_nothing, _settings)
|
|
oem_grp.append(rs)
|
|
|
|
_str = _decode(self._memobj.oem_info.firmware)
|
|
val = RadioSettingValueString(0, 15, _str)
|
|
val.set_mutable(False)
|
|
rs = RadioSetting("oem_info.firmware", "Firmware Version", val)
|
|
rs.set_apply_callback(do_nothing, _settings)
|
|
oem_grp.append(rs)
|
|
|
|
_str = _decode(self._memobj.oem_info.date)
|
|
val = RadioSettingValueString(0, 15, _str)
|
|
val.set_mutable(False)
|
|
rs = RadioSetting("oem_info.date", "OEM Date", val)
|
|
rs.set_apply_callback(do_nothing, _settings)
|
|
oem_grp.append(rs)
|
|
if self.MODEL == "KG-Q10H":
|
|
rs = RadioSetting("oem_info.locked", "OEM Lock Mode -"
|
|
" Tx/Rx Range Locked to factory settings",
|
|
RadioSettingValueBoolean(
|
|
self._memobj.oem_info.locked))
|
|
oem_grp.append(rs)
|
|
|
|
return group
|
|
|
|
def get_settings(self):
|
|
try:
|
|
return self._get_settings()
|
|
except Exception:
|
|
import traceback
|
|
LOG.error("Failed to parse settings: %s", traceback.format_exc())
|
|
return None
|
|
|
|
def set_settings(self, settings):
|
|
for element in settings:
|
|
if not isinstance(element, RadioSetting):
|
|
self.set_settings(element)
|
|
continue
|
|
else:
|
|
try:
|
|
if "." in element.get_name():
|
|
bits = element.get_name().split(".")
|
|
obj = self._memobj
|
|
for bit in bits[:-1]:
|
|
if "[" in bit and "]" in bit:
|
|
bit, index = bit.split("[", 1)
|
|
index, junk = index.split("]", 1)
|
|
index = int(index)
|
|
obj = getattr(obj, bit)[index]
|
|
else:
|
|
obj = getattr(obj, bit)
|
|
setting = bits[-1]
|
|
else:
|
|
obj = self._memobj.settings
|
|
setting = element.get_name()
|
|
|
|
if element.has_apply_callback():
|
|
element.run_apply_callback()
|
|
else:
|
|
LOG.debug("Setting %s = %s" % (setting, element.value))
|
|
if self._is_freq(element):
|
|
# MRT rescale freq values to match radio
|
|
# expected values
|
|
setattr(obj, setting,
|
|
int(element.values()[0]._current *
|
|
100000.0))
|
|
elif self._is_fmradio(element):
|
|
# MRT rescale FM Radio values to match radio
|
|
# expected values
|
|
setattr(obj, setting,
|
|
int(element.values()[0]._current * 10.0))
|
|
elif self._is_color(element):
|
|
setattr(obj, setting,
|
|
RadioSettingValueRGB.get_rgb16(
|
|
element.value))
|
|
else:
|
|
setattr(obj, setting, element.value)
|
|
except Exception:
|
|
LOG.debug(element.get_name())
|
|
raise
|
|
|
|
def _is_freq(self, element):
|
|
return ("rxfreq" in element.get_name() or
|
|
"offset" in element.get_name() or
|
|
"rx_start" in element.get_name() or
|
|
"rx_stop" in element.get_name() or
|
|
"lim_start" in element.get_name() or
|
|
"lim_stop" in element.get_name() or
|
|
"tx_start" in element.get_name() or
|
|
"tx_stop" in element.get_name())
|
|
|
|
def _is_color(self, element):
|
|
return (("custcol" in element.get_name()) & (self.use_color is True))
|
|
|
|
def _is_fmradio(self, element):
|
|
return "FM_radio" in element.get_name()
|
|
|
|
def callid2str(self, cid):
|
|
"""Caller ID per MDC-1200 spec? Must be 3-6 digits (100 - 999999).
|
|
One digit (binary) per byte, terminated with '0xc'
|
|
"""
|
|
|
|
bin2ascii = "0123456789"
|
|
cidstr = ""
|
|
for i in range(0, 6):
|
|
b = cid[i].get_value()
|
|
# Handle fluky firmware 0x0a is sometimes used instead of 0x00
|
|
if b == 0x0a:
|
|
b = 0x00
|
|
if b == 0xc or b == 0xf: # the cid EOL
|
|
break
|
|
if b > 0xa:
|
|
raise InvalidValueError(
|
|
"Caller ID code has illegal byte 0x%x" % b)
|
|
cidstr += bin2ascii[b]
|
|
return cidstr
|
|
|
|
def _checksum2(self, data):
|
|
cs = 0
|
|
cs_adj = 0
|
|
for byte in data:
|
|
cs += byte
|
|
cs %= 256
|
|
cs_adj = (data[3] & 0x0F) % 4
|
|
if cs_adj == 0:
|
|
cs += 3
|
|
elif cs_adj == 1:
|
|
cs += 1
|
|
elif cs_adj == 2:
|
|
cs -= 1
|
|
elif cs_adj == 3:
|
|
cs -= 3
|
|
return (cs & 0xFF)
|
|
|
|
def _checksum_adjust(self, data):
|
|
cs_mod = 0
|
|
cs_adj = 0
|
|
cs_adj = (data & 0x0F) % 4
|
|
if cs_adj == 0:
|
|
cs_mod = 3
|
|
elif cs_adj == 1:
|
|
cs_mod = 1
|
|
elif cs_adj == 2:
|
|
cs_mod = -1
|
|
elif cs_adj == 3:
|
|
cs_mod = -3
|
|
return (cs_mod)
|
|
|
|
def _write_record(self, cmd, payload=b''):
|
|
_packet = struct.pack('BBBB', self._record_start, cmd, 0xFF,
|
|
len(payload))
|
|
LOG.debug("Sent: Unencrypt\n%s" % util.hexprint(_packet + payload))
|
|
checksum = bytes([self._checksum2(_packet[1:] + payload)])
|
|
_packet += self.encrypt(payload + checksum)
|
|
LOG.debug("Sent:\n%s" % util.hexprint(_packet))
|
|
self.pipe.write(_packet)
|
|
time.sleep(0.000005)
|
|
|
|
def _identify(self):
|
|
"""Wouxun CPS sends the same Read command 3 times to establish comms"""
|
|
"""Read Resp and check radio model in prep for actual download"""
|
|
LOG.debug("Starting Radio Identifcation")
|
|
|
|
for i in range(0, 3):
|
|
ident = struct.pack(
|
|
'BBBBBBBB', 0x7c, 0x82, 0xff, 0x03, 0x54, 0x14, 0x54, 0x53)
|
|
self.pipe.write(ident)
|
|
_chksum_err, _resp = self._read_record()
|
|
_radio_id = _resp[46:53]
|
|
self._RADIO_ID = _radio_id
|
|
LOG.debug("Radio Identified as Model %s" % _radio_id)
|
|
if _chksum_err:
|
|
LOG.debug(util.hexprint(_resp))
|
|
raise errors.RadioError("Checksum Error on Identify")
|
|
elif _radio_id != self._model:
|
|
self._finish()
|
|
raise errors.RadioError("Radio identified as Model: %s \n"
|
|
"You selected Model: %s.\n"
|
|
"Please select the correct radio model"
|
|
" to continue"
|
|
# "Your Model is not currently supported"
|
|
% (_radio_id.decode('UTF-8'),
|
|
self._model.decode('UTF-8')))
|
|
LOG.debug("Ending Radio Identifcation")
|
|
|
|
def _download(self):
|
|
try:
|
|
self._identify()
|
|
return self._do_download()
|
|
except errors.RadioError:
|
|
raise
|
|
except Exception as e:
|
|
LOG.exception('Unknown error during download process')
|
|
raise errors.RadioError("Failed to communicate with radio: %s" % e)
|
|
|
|
def _do_download(self):
|
|
LOG.debug("Starting Download")
|
|
# allocate & fill memory
|
|
image = b""
|
|
# Download full memory in 0x000 to 0x8000 address order
|
|
# rearrange later
|
|
cfgmap = Q10H_download_map_full
|
|
|
|
for start, blocksize, count in cfgmap:
|
|
end = start + (blocksize * count)
|
|
LOG.debug("start = " + str(start))
|
|
LOG.debug("end = " + str(end))
|
|
LOG.debug("blksize = " + str(blocksize))
|
|
|
|
for i in range(start, end, blocksize):
|
|
time.sleep(0.005)
|
|
req = struct.pack('>HB', i, blocksize)
|
|
self._write_record(CMD_RD, req)
|
|
cs_error, resp = self._read_record()
|
|
if cs_error:
|
|
LOG.debug(util.hexprint(resp))
|
|
raise Exception("Checksum error on read")
|
|
LOG.debug("Got:\n%s" % util.hexprint(resp))
|
|
image += resp[2:]
|
|
if self.status_fn:
|
|
status = chirp_common.Status()
|
|
status.cur = i
|
|
status.max = 0x8000
|
|
status.msg = "Cloning from radio"
|
|
self.status_fn(status)
|
|
self._finish()
|
|
LOG.debug("Download Completed")
|
|
return memmap.MemoryMapBytes(image)
|
|
|
|
def _read_record(self):
|
|
# read 4 chars for the header
|
|
_header = self.pipe.read(4)
|
|
|
|
if len(_header) != 4:
|
|
raise errors.RadioError('Radio did not respond \n'
|
|
'Confirm proper radio selection \n'
|
|
'Confirm radio is Powered On and '
|
|
'programming cable is fully inserted')
|
|
_length = struct.unpack('xxxB', _header)[0]
|
|
_packet = self.pipe.read(_length)
|
|
|
|
_rcs_xor = _packet[-1]
|
|
_packet = self.decrypt(_packet)
|
|
LOG.debug("Header =%a" % util.hexprint(_header + _packet[0:2]))
|
|
_cs = self._checksum(_header[1:])
|
|
_cs += self._checksum(_packet)
|
|
_csa = self._checksum_adjust(_packet[0])
|
|
LOG.debug("_cs (preadjusted)=%x", _cs & 0xff)
|
|
_cs += _csa
|
|
_cs = _cs & 0xFF
|
|
_rcs = self.strxor(self.pipe.read(1)[0], _rcs_xor)[0]
|
|
LOG.debug("_csa=%x", _csa)
|
|
LOG.debug("_cs (adjusted)=%x", _cs)
|
|
LOG.debug("_rcs=%x", _rcs)
|
|
return (_rcs != _cs, _packet)
|
|
|
|
def _finish(self):
|
|
# this is the encrypted finish command sent by Q10H CPS
|
|
finish = struct.pack('BBBBB', 0x7c, 0x81, 0xff, 0x00, 0xd7)
|
|
self.pipe.write(finish)
|
|
return
|
|
|
|
def decrypt(self, data):
|
|
result = b''
|
|
for i in range(len(data)-1, 0, -1):
|
|
result += self.strxor(data[i], data[i - 1])
|
|
result += self.strxor(data[0], self.cryptbyte)
|
|
return result[::-1]
|
|
|
|
def encrypt(self, data):
|
|
result = self.strxor(self.cryptbyte, data[0])
|
|
for i in range(1, len(data), 1):
|
|
result += self.strxor(result[i - 1], data[i])
|
|
return result
|
|
|
|
|
|
@directory.register
|
|
class KGQ10GRadio(KGQ10HRadio):
|
|
|
|
"""Wouxun KG-Q10G"""
|
|
VENDOR = "Wouxun"
|
|
MODEL = "KG-Q10G"
|
|
NEEDS_COMPAT_SERIAL = False
|
|
_model = b"KG-Q10G"
|
|
cryptbyte = 0x54
|
|
am_mode_list = AM_MODE_2
|
|
am_mode_list_ch = AM_MODE_CH2
|
|
vfoa3_msg = "26M Settings"
|
|
_prog_key = PROG_KEY_LIST2
|
|
_vfoaband = VFOABAND_MAP2
|
|
_offset_dir_rpt = ONOFF_LIST
|
|
_offset_dir_rpt_label = "A Repeater"
|
|
_offset_dir_rpt_labelB = "B Repeater"
|
|
rpttonemenu = 40
|
|
timemenu = 41
|
|
tzmenu = 42
|
|
locmenu = 44
|
|
|
|
def get_features(self):
|
|
rf = chirp_common.RadioFeatures()
|
|
rf.has_settings = True
|
|
rf.has_ctone = True
|
|
rf.has_rx_dtcs = True
|
|
rf.has_cross = True
|
|
rf.has_tuning_step = False
|
|
rf.has_bank = False
|
|
rf.can_odd_split = True
|
|
rf.valid_skips = ["", "S"]
|
|
rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
|
|
rf.valid_cross_modes = [
|
|
"Tone->Tone",
|
|
"Tone->DTCS",
|
|
"DTCS->Tone",
|
|
"DTCS->",
|
|
"->Tone",
|
|
"->DTCS",
|
|
"DTCS->DTCS",
|
|
]
|
|
rf.valid_modes = ["FM", "NFM", "AM"]
|
|
rf.valid_power_levels = self.POWER_LEVELS
|
|
rf.valid_name_length = 12
|
|
rf.valid_duplexes = ["", "-", "+", "split", "off"]
|
|
# MRT - Open up channel memory freq range to support
|
|
# RxFreq limit expansion
|
|
rf.valid_bands = [(26000000, 31997500), # CB
|
|
(108000000, 174997500), # AM Airband and VHF
|
|
(222000000, 225997500), # 1.25M
|
|
(320000000, 479997500), # UHF
|
|
(714000000, 999997500)] # Fixed Land Mobile
|
|
|
|
rf.valid_characters = chirp_common.CHARSET_ASCII
|
|
rf.memory_bounds = (1, 999) # 999 memories
|
|
rf.valid_tuning_steps = STEPS2
|
|
return rf
|
|
|
|
def _do_upload(self):
|
|
# self._identify()
|
|
if self._RADIO_ID == self._model:
|
|
LOG.debug("Starting Upload")
|
|
if self.show_limits:
|
|
cfgmap = Q10H_upload_map
|
|
else:
|
|
cfgmap = Q10G_upload_map_nolims
|
|
|
|
for (radioaddress, radioend, start, memend,
|
|
blocksize, count) in cfgmap:
|
|
end = start + (blocksize * count)
|
|
LOG.debug("start = " + str(start))
|
|
LOG.debug("end = " + str(end))
|
|
LOG.debug("blksize = " + str(blocksize))
|
|
ptr2 = radioaddress
|
|
|
|
for addr in range(start, end, blocksize):
|
|
ptr = addr
|
|
LOG.debug("ptr = " + str(hex(ptr)))
|
|
LOG.debug("ptr2 = " + str(hex(ptr2)))
|
|
req = struct.pack('>H', ptr2)
|
|
chunk = self.get_mmap()[ptr:ptr + blocksize]
|
|
self._write_record(CMD_WR, req + chunk)
|
|
LOG.debug(util.hexprint(req + chunk))
|
|
cserr, ack = self._read_record()
|
|
LOG.debug(util.hexprint(ack))
|
|
j = struct.unpack('>H', ack)[0]
|
|
if cserr or j != ptr2:
|
|
LOG.debug(util.hexprint(ack))
|
|
raise Exception("Checksum Error on Ack at %i" % ptr)
|
|
ptr += blocksize
|
|
ptr2 += blocksize
|
|
if self.status_fn:
|
|
status = chirp_common.Status()
|
|
status.cur = ptr
|
|
status.max = 0x8000
|
|
status.msg = "Cloning to radio"
|
|
self.status_fn(status)
|
|
LOG.debug("Upload Completed")
|
|
else:
|
|
raise errors.RadioError("Radio is not a KG-Q10G. Upload Canceled")
|
|
|
|
self._finish()
|
