CHIRP

# Copyright 2022 Mel Terechenok <melvin.terechenok@gmail.com>

# Updated Driver to support Wouxon KG-UV9PX

# based on prior driver for KG-UV9D Plus by

# Jim Lieb <lieb@sea-troll.net>

#

# Borrowed from other chirp drivers, especially the KG-UV8D Plus

# by Krystian Struzik <toner_82@tlen.pl>

#

# 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-UV9D Plus radio management module"""

import time

import os

import logging

import struct

import string

from chirp import util, chirp_common, bitwise, memmap, errors, directory

from chirp.settings import RadioSetting, RadioSettingValue, \

     RadioSettingGroup, \

     RadioSettingValueBoolean, RadioSettingValueList, \

     RadioSettingValueInteger, RadioSettingValueString, \

     RadioSettings, InvalidValueError

LOG = logging.getLogger(__name__)

CMD_IDENT = 0x80

CMD_HANGUP = 0x81

CMD_RCONF = 0x82

CMD_WCONF = 0x83

CMD_RCHAN = 0x84

CMD_WCHAN = 0x85

cmd_name = {

    CMD_IDENT:  "ident",

    CMD_HANGUP: "hangup",

    CMD_RCONF:  "read config",

    CMD_WCONF:  "write config",

    CMD_RCHAN:  "read channel memory",  # Unused

    CMD_WCHAN:  "write channel memory"  # Unused because it is a hack.

    }

# This is used to write the configuration of the radio base on info

# gleaned from the downloaded app. There are empty spaces and we honor

# them because we don't know what they are (yet) although we read the

# whole of memory.

#

# Channel memory is separate. There are 1000 (1-999) channels.

# These are read/written to the radio in 4 channel (96 byte)

# records starting at address 0xa00 and ending at

# 0x4800 (presuming the end of channel 1000 is 0x4860-1

config_map = (          # map address, write size, write count

    (0x40,   16, 1),    # Passwords

    (0x60,   20, 1),    # RX frequency limits

    (0x74,    8, 1),    # TX frequency limits

    (0x740,  40, 1),    # FM chan 1-20

    (0x780,  16, 1),    # vfo-b-150

    (0x790,  16, 1),    # vfo-b-450

    (0x800,  16, 1),    # vfo-a-150

    (0x810,  16, 1),    # vfo-a-450

    (0x820,  16, 1),    # vfo-a-300

    (0x830,  16, 1),    # vfo-a-700

    (0x840,  16, 1),    # vfo-a-200

    (0x860,  16, 1),    # area-a-conf

    (0x870,  16, 1),    # area-b-conf

    (0x880,  16, 1),    # radio conf 0

    (0x890,  16, 1),    # radio conf 1

    (0x8a0,  16, 1),    # radio conf 2

    (0x8b0,  16, 1),    # radio conf 3

    (0x8c0,  16, 1),    # PTT-ANI

    (0x8d0,  16, 1),    # SCC

    (0x8e0,  16, 1),    # power save

    (0x8f0,  16, 1),    # Display banner

    (0x940,  64, 2),    # Scan groups and names

    (0xa00,  64, 249),  # Memory Channels 1-996

    (0x4840, 48, 1),    # Memory Channels 997-999

    (0x4900, 32, 249),  # Memory Names    1-996

    (0x6820, 24, 1),    # Memory Names    997-999

    (0x7400, 64, 5),    # CALL-ID 1-20, names 1-20

    )

config_map2 = (          # map address, write size, write count

    (0x40,   16, 1),    # Passwords

    (0x50,   10, 1),    # OEM Display Name

    (0x60,   20, 1),    # Rx Freq Limits Area A

    (0x74,   8,  1),    # TX Frequency Limits 150M and 450M

    (0x7c,   4,  1),    # Rx 150M Freq Limits Area B

    #   (0x80,   8,  1),    # unknown Freq limits

    (0x740,  40, 1),    # FM chan 1-20

    (0x780,  16, 1),    # vfo-b-150

    (0x790,  16, 1),    # vfo-b-450

    (0x800,  16, 1),    # vfo-a-150

    (0x810,  16, 1),    # vfo-a-450

    (0x820,  16, 1),    # vfo-a-300

    (0x830,  16, 1),    # vfo-a-700

    (0x840,  16, 1),    # vfo-a-200

    (0x860,  16, 1),    # area-a-conf

    (0x870,  16, 1),    # area-b-conf

    (0x880,  16, 1),    # radio conf 0

    (0x890,  16, 1),    # radio conf 1

    (0x8a0,  16, 1),    # radio conf 2

    (0x8b0,  16, 1),    # radio conf 3

    (0x8c0,  16, 1),    # PTT-ANI

    (0x8d0,  16, 1),    # SCC

    (0x8e0,  16, 1),    # power save

    (0x8f0,  16, 1),    # Display banner

    (0x940,  64, 2),    # Scan groups and names

    (0xa00,  64, 249),  # Memory Channels 1-996

    (0x4840, 48, 1),    # Memory Channels 997-999

    (0x4900, 32, 249),  # Memory Names    1-996

    (0x6820, 24, 1),    # Memory Names    997-999

    (0x7400, 64, 5),    # CALL-ID 1-20, names 1-20

    (0x7600,  1, 1)     # Screen Mode

    )

MEM_VALID = 0xfc

MEM_INVALID = 0xff

# In Issue #6995 we can find _valid values of 0 and 2 in the IMG

# so these values should be treated like MEM_VALID.

# state value of 0x40 found in deleted memory - still shows in CPS

VALID_MEM_VALUES = [MEM_VALID, 0x00, 0x02, 0x40, 0x3D]

INVALID_MEM_VALUES = [MEM_INVALID]

# Radio memory map. This matches the reads/writes above.

# structure elements whose name starts with x are currently unidentified

_MEM_FORMAT02 = """

#seekto 0x40;

struct {

    char reset[6];

    char x46[2];

    char mode_sw[6];

    char x4e;

}  passwords;

#seekto 0x60;

struct freq_limit {

    u16 start;

    u16 stop;

};

struct {

    struct freq_limit band_150;

    struct freq_limit band_450;

    struct freq_limit band_300;

    struct freq_limit band_700;

    struct freq_limit band_200;

} rx_freq_limits;

struct {

    struct freq_limit band_150;

    struct freq_limit band_450;

} tx_freq_limits;

#seekto 0x740;

struct {

    u16 fm_freq;

} fm_chans[20];

// each band has its own configuration, essentially its default params

struct vfo {

    u32 freq;

    u32 offset;

    u16 encqt;

    u16 decqt;

    u8  bit7_4:3,

        qt:3,

        bit1_0:2;

    u8  bit7:1,

        scan:1,

        bit5:1,

        pwr:2,

        mod:1,

        fm_dev:2;

    u8  pad2:6,

        shift:2;

    u8  zeros;

};

#seekto 0x780;

struct {

    struct vfo band_150;

    struct vfo band_450;

} vfo_b;

#seekto 0x800;

struct {

    struct vfo band_150;

    struct vfo band_450;

    struct vfo band_300;

    struct vfo band_700;

    struct vfo band_200;

} vfo_a;

// There are two independent radios, aka areas (as described

// in the manual as the upper and lower portions of the display...

struct area_conf {

    u8 w_mode;

    u16 w_chan;

    u8 scan_grp;

    u8 bcl;

    u8 sql;

    u8 cset;

    u8 step;

    u8 scan_mode;

    u8 x869;

    u8 scan_range;

    u8 x86b;

    u8 x86c;

    u8 x86d;

    u8 x86e;

    u8 x86f;

};

#seekto 0x860;

struct area_conf a_conf;

#seekto 0x870;

struct area_conf b_conf;

#seekto 0x880;

struct {

    u8 menu_avail;

    u8 reset_avail;

    u8 x882;

    u8 x883;

    u8 lang;

    u8 x885;

    u8 beep;

    u8 auto_am;

    u8 qt_sw;

    u8 lock;

    u8 x88a;

    u8 pf1;

    u8 pf2;

    u8 pf3;

    u8 s_mute;

    u8 type_set;

    u8 tot;

    u8 toa;

    u8 ptt_id;

    u8 x893;

    u8 id_dly;

    u8 x895;

    u8 voice_sw;

    u8 s_tone;

    u8 abr_lvl;

    u8 ring_time;

    u8 roger;

    u8 x89b;

    u8 abr;

    u8 save_m;

    u8 lock_m;

    u8 auto_lk;

    u8 rpt_ptt;

    u8 rpt_spk;

    u8 rpt_rct;

    u8 prich_sw;

    u16 pri_ch;

    u8 x8a6;

    u8 x8a7;

    u8 dtmf_st;

    u8 dtmf_tx;

    u8 x8aa;

    u8 sc_qt;

    u8 apo_tmr;

    u8 vox_grd;

    u8 vox_dly;

    u8 rpt_kpt;

    struct {

        u16 scan_st;

        u16 scan_end;

    } a;

    struct {

        u16 scan_st;

        u16 scan_end;

    } b;

    u8 x8b8;

    u8 x8b9;

    u8 x8ba;

    u8 ponmsg;

    u8 blcdsw;

    u8 bledsw;

    u8 x8be;

    u8 x8bf;

} settings;

#seekto 0x8c0;

struct {

    u8 code[6];

    char x8c6[10];

} my_callid;

#seekto 0x8d0;

struct {

    u8 scc[6];

    char x8d6[10];

} stun;

#seekto 0x8e0;

struct {

    u16 wake;

    u16 sleep;

} save[4];

#seekto 0x8f0;

struct {

    char banner[16];

} display;

#seekto 0x940;

struct {

    struct {

        i16 scan_st;

        i16 scan_end;

    } addrs[10];

    u8 x0968[8];

    struct {

        char name[8];

    } names[10];

} scn_grps;

// this array of structs is marshalled via the R/WCHAN commands

#seekto 0xa00;

struct {

    u32 rxfreq;

    u32 txfreq;

    u16 encQT;

    u16 decQT;

    u8  bit7_5:3,  // all ones

        qt:3,

        bit1_0:2;

    u8  bit7:1,

        scan:1,

        bit5:1,

        pwr:2,

        mod:1,

        fm_dev:2;

    u8  state;

    u8  c3;

} chan_blk[999];

// nobody really sees this. It is marshalled with chan_blk

// in 4 entry chunks

#seekto 0x4900;

// Tracks with the index of  chan_blk[]

struct {

    char name[8];

} chan_name[999];

#seekto 0x7400;

struct {

    u8 cid[6];

    u8 pad[2];

}call_ids[20];

// This array tracks with the index of call_ids[]

struct {

    char name[6];

    char pad[2];

} cid_names[20];

    """

_MEM_FORMAT_9PX = """

#seekto 0x40;

struct {

    char reset[6];

    char x46[2];

    char mode_sw[6];

    char x4e;

}  passwords;

#seekto 0x50;

struct {

    char model[10];

} oemmodel;

#seekto 0x60;

struct {

    u16 lim_150M_area_a_rxlower_limit; // 0x60

    u16 lim_150M_area_a_rxupper_limit;

    u16 lim_450M_rxlower_limit;

    u16 lim_450M_rxupper_limit;

    u16 lim_300M_rxlower_limit;

    u16 lim_300M_rxupper_limit;

    u16 lim_800M_rxlower_limit;

    u16 lim_800M_rxupper_limit;

    u16 lim_210M_rxlower_limit;

    u16 lim_210M_rxupper_limit;

    u16 lim_150M_Txlower_limit;

    u16 lim_150M_Txupper_limit;

    u16 lim_450M_Txlower_limit;

    u16 lim_450M_Txupper_limit;

    u16 lim_150M_area_b_rxlower_limit;

    u16 lim_150M_area_b_rxupper_limit;

    u16 unknown_lower_limit;

    u16 unknown_upper_limit;

    u16 unknown2_lower_limit;

    u16 unknown2_upper_limit;

}  limits;

#seekto 0x740;

struct {

    u16 fm_freq;

} fm_chans[20];

// each band has its own configuration, essentially its default params

struct vfo {

    u32 freq;

    u32 offset;

    u16 encqt;

    u16 decqt;

    u8  bit7_4:3,

        qt:3,

        bit1_0:2;

    u8  bit7:1,

        scan:1,

        bit5:1,

        pwr:2,

        mod:1,

        fm_dev:2;

    u8  pad2:6,

        shift:2;

    u8  zeros;

};

#seekto 0x780;

struct {

    struct vfo band_150;

    struct vfo band_450;

} vfo_b;

#seekto 0x800;

struct {

    struct vfo band_150;

    struct vfo band_450;

    struct vfo band_300;

    struct vfo band_700;

    struct vfo band_200;

} vfo_a;

// There are two independent radios, aka areas (as described

// in the manual as the upper and lower portions of the display...

struct area_conf {

    u8 w_mode;

    u16 w_chan; // fix issue in 9D Plus -  w_chan is 2bytes

    u8 scan_grp;

    u8 bcl;

    u8 sql;

    u8 cset;

    u8 step;

    u8 scan_mode;

    u8 x869;

    u8 scan_range;

    u8 x86b;

    u8 x86c;

    u8 x86d;

    u8 x86e;

    u8 x86f;

};

#seekto 0x860;

struct area_conf a_conf;

#seekto 0x870;

struct area_conf b_conf;

#seekto 0x880;

struct {

    u8 menu_avail;

    u8 reset_avail;

    u8 act_area;

    u8 tdr;

    u8 lang;

    u8 x885;

    u8 beep;

    u8 auto_am;

    u8 qt_sw;

    u8 lock;

    u8 x88a;

    u8 pf1;

    u8 pf2;

    u8 pf3;

    u8 s_mute;

    u8 type_set;

    u8 tot;

    u8 toa;

    u8 ptt_id;

    u8 x893;

    u8 id_dly;

    u8 x895;

    u8 voice_sw;

    u8 s_tone;

    u8 abr_lvl;

    u8 ring_time;

    u8 roger;

    u8 x89b;

    u8 abr;

    u8 save_m;

    u8 lock_m;

    u8 auto_lk;

    u8 rpt_ptt;

    u8 rpt_spk;

    u8 rpt_rct;

    u8 prich_sw;

    u16 pri_ch;

    u8 x8a6;

    u8 x8a7;

    u8 dtmf_st;

    u8 dtmf_tx;

    u8 x8aa;

    u8 sc_qt;

    u8 apo_tmr;

    u8 vox_grd;

    u8 vox_dly;

    u8 rpt_kpt;

    struct {

        u16 scan_st;

        u16 scan_end;

    } a;

    struct {

        u16 scan_st;

        u16 scan_end;

    } b;

    u8 x8b8;

    u8 x8b9;

    u8 x8ba;

    u8 ponmsg;

    u8 blcdsw;

    u8 bledsw;

    u8 x8be;

    u8 x8bf;

} settings;

#seekto 0x8c0;

struct {

    u8 code[6];

    char x8c6[10];

} my_callid;

#seekto 0x8d0;

struct {

    u8 scc[6];

    char x8d6[10];

} stun;

#seekto 0x8e0;

struct {

    u16 wake;

    u16 sleep;

} save[4];

#seekto 0x8f0;

struct {

    char banner[16];

} display;

#seekto 0x940;

struct {

    struct {

        i16 scan_st;

        i16 scan_end;

    } addrs[10];

    u8 x0968[8];

    struct {

        char name[8];

    } names[10];

} scn_grps;

// this array of structs is marshalled via the R/WCHAN commands

#seekto 0xa00;

struct {

    u32 rxfreq;

    u32 txfreq;

    u16 encQT;

    u16 decQT;

    u8  bit7_5:3,  // all ones

        qt:3,

        bit1_0:2;

    u8  bit7:1,

        scan:1,

        bit5:1,

        pwr:2,

        mod:1,

        fm_dev:2;

    u8  state;

    u8  c3;

} chan_blk[999];

// nobody really sees this. It is marshalled with chan_blk

// in 4 entry chunks

#seekto 0x4900;

// Tracks with the index of  chan_blk[]

struct {

    char name[8];

} chan_name[999];

#seekto 0x7400;

struct {

    u8 cid[6];

    u8 pad[2];

}call_ids[20];

// This array tracks with the index of call_ids[]

struct {

    char name[6];

    char pad[2];

} cid_names[20];

#seekto 0x7600;

struct {

    u8 screen_mode;

} screen;

"""

# Support for the Wouxun KG-UV9D Plus and KG-UV9PX radio

# Serial coms are at 19200 baud

# The data is passed in variable length records

# Record structure:

#  Offset   Usage

#    0      start of record (\x7d)

#    1      Command (6 commands, see above)

#    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 _pkt_encode(op, payload):

    """Assemble a packet for the radio and encode it for transmission.

    Yes indeed, the checksum we store is only 4 bits. Why?

    I suspect it's a bug in the radio firmware guys didn't want to fix,

    i.e. a typo 0xff -> 0xf..."""

    data = bytearray()

    data.append(0x7d)  # tag that marks the beginning of the packet

    data.append(op)

    data.append(0xff)  # 0xff is from app to radio

    # calc checksum from op to end

    cksum = op + 0xff

    if (payload):

        data.append(len(payload))

        cksum += len(payload)

        for byte in payload:

            cksum += byte

            data.append(byte)

    else:

        data.append(0x00)

        # Yea, this is a 4 bit cksum (also known as a bug)

    data.append(cksum & 0xf)

    # now obfuscate by an xor starting with first payload byte ^ 0x52

    # including the trailing cksum.

    xorbits = 0x52

    for i, byte in enumerate(data[4:]):

        xord = xorbits ^ byte

        data[i + 4] = xord

        xorbits = xord

    return(data)

def _pkt_decode(data):

    """Take a packet hot off the wire and decode it into clear text

    and return the fields. We say <<cleartext>> here because all it

    turns out to be is annoying obfuscation.

    This is the inverse of pkt_decode"""

    # we don't care about data[0].

    # It is always 0x7d and not included in checksum

    op = data[1]

    direction = data[2]

    bytecount = data[3]

    # First un-obfuscate the payload and cksum

    payload = bytearray()

    xorbits = 0x52

    for i, byte in enumerate(data[4:]):

        payload.append(xorbits ^ byte)

        xorbits = byte

    # Calculate the checksum starting with the 3 bytes of the header

    cksum = op + direction + bytecount

    for byte in payload[:-1]:

        cksum += byte

    # yes, a 4 bit cksum to match the encode

    cksum_match = (cksum & 0xf) == payload[-1]

    if (not cksum_match):

        LOG.debug(

            "Checksum mismatch: %x != %x; " % (cksum, payload[-1]))

    return (cksum_match, op, payload[:-1])

# UI callbacks to process input for mapping UI fields to memory cells

def freq2int(val, min, max):

    """Convert a frequency as a string to a u32. Units is Hz

    """

    _freq = chirp_common.parse_freq(str(val))

    if _freq > max or _freq < min:

        raise InvalidValueError("Frequency %s is not with in %s-%s" %

                                (chirp_common.format_freq(_freq),

                                 chirp_common.format_freq(min),

                                 chirp_common.format_freq(max)))

    return _freq

def int2freq(freq):

    """

    Convert a u32 frequency to a string for UI data entry/display

    This is stored in the radio as units of 10Hz which we compensate to Hz.

    A value of -1 indicates <no frequency>, i.e. unused channel.

    """

    if (int(freq) > 0):

        f = chirp_common.format_freq(freq)

        return f

    else:

        return ""

def freq2short(val, min, max):

    """Convert a frequency as a string to a u16 which is units of 10KHz

    """

    _freq = chirp_common.parse_freq(str(val))

    if _freq > max or _freq < min:

        raise InvalidValueError("Frequency %s is not with in %s-%s" %

                                (chirp_common.format_freq(_freq),

                                 chirp_common.format_freq(min),

                                 chirp_common.format_freq(max)))

    return _freq // 100000 & 0xFFFF

def short2freq(freq):

    """

       Convert a short frequency to a string for UI data entry/display

       This is stored in the radio as units of 10KHz which we

       compensate to Hz.

       A value of -1 indicates <no frequency>, i.e. unused channel.

    """

    if (int(freq) > 0):

        f = chirp_common.format_freq(freq * 100000)

        return f

    else:

        return ""

def tone2short(t):

    """Convert a string tone or DCS to an encoded u16

    """

    tone = str(t)

    if tone == "----":

        u16tone = 0x0000

    elif tone[0] == 'D':  # This is a DCS code

        c = tone[1: -1]

        code = int(c, 8)

        if tone[-1] == 'I':

            code |= 0x4000

        u16tone = code | 0x8000

    else:              # This is an analog CTCSS

        u16tone = int(tone[0:-2]+tone[-1]) & 0xffff  # strip the '.'

    return u16tone

def short2tone(tone):

    """ Map a binary CTCSS/DCS to a string name for the tone

    """

    if tone == 0 or tone == 0xffff:

        ret = "----"

    else:

        code = tone & 0x3fff

        if tone & 0x8000:      # This is a DCS

            if tone & 0x4000:  # This is an inverse code

                ret = "D%0.3oI" % code

            else:

                ret = "D%0.3oN" % code

        else:   # Just plain old analog CTCSS

            ret = "%4.1f" % (code / 10.0)

    return ret

def str2callid(val):

    """ Convert caller id strings from callid2str.

    """

    ascii2bin = "0123456789"

    s = str(val).strip()

    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 = (0xa, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9)[int(c)]

        blk.append(b)

    if len(blk) < 6:

        blk.append(0xc)  # EOL a short ID

    if len(blk) < 6:

        for i in range(0, (6 - len(blk))):

            blk.append(0xf0)

    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 == 0xc:  # 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(0xc)  # EOL a short ID

    return blk

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\0xff')

    if len(val) == 0:

        name = "".ljust(size, emptyfill)

    else:

        name = val.ljust(size, fillchar)

    return name

def pw2str(pw):

    """Convert a password string (6 digits) to a string

    Passwords must be 6 digits. If it is shorter, pad right with '0'

    """

    pwstr = ""

    ascii2bin = "0123456789"

    for i in range(0, len(pw)):

        b = pw[i].get_value()

        if b not in ascii2bin:

            raise InvalidValueError("Value must be digits 0-9")

        pwstr += b

    pwstr = pwstr.ljust(6, '0')

    return pwstr

def str2pw(val):

    """Store a password from UI to memory obj

    If we clear the password (make it go away), change the

    empty string to '000000' since the radio must have *something*

    Also, fill a < 6 digit pw with 0's

    """

    ascii2bin = "0123456789"

    val = str(val).rstrip(' \t\r\n\0\0xff')

    if len(val) == 0:  # a null password

        val = "000000"

    for i in range(0, len(val)):

        b = val[i]

        if b not in ascii2bin:

            raise InvalidValueError("Value must be digits 0-9")

    if len(val) == 0:

        pw = "".ljust(6, '\0')

    else:

        pw = val.ljust(6, '0')

    return pw

# Helpers to replace python2 things like confused str/byte

def _hex_print(data, addrfmt=None):

    """Return a hexdump-like encoding of @data

    We expect data to be a bytearray, not a string.

    Expanded from borrowed code to use the first 2 bytes as the address

    per comm packet format.

    """

    if addrfmt is None:

        addrfmt = '%(addr)03i'

        addr = 0

    else:  # assume first 2 bytes are address

        a = struct.unpack(">H", data[0:2])

        addr = a[0]

        data = data[2:]

    block_size = 16

    lines = (len(data) // block_size)

    if (len(data) % block_size > 0):

        lines += 1

    out = ""

    left = len(data)

    for block in range(0, lines):

        addr += block * block_size

        try:

            out += addrfmt % locals()

        except (OverflowError, ValueError, TypeError, KeyError):

            out += "%03i" % addr

        out += ': '

        if left < block_size:

            limit = left

        else:

            limit = block_size

        for j in range(0, block_size):

            if (j < limit):

                out += "%02x " % data[(block * block_size) + j]

            else:

                out += "   "

        out += "  "

        for j in range(0, block_size):

            if (j < limit):

                _byte = data[(block * block_size) + j]

                if _byte >= 0x20 and _byte < 0x7F:

                    out += "%s" % chr(_byte)

                else:

                    out += "."

            else:

                out += " "

        out += "\n"

        if (left > block_size):

            left -= block_size

    return out

# Useful UI lists

STEPS = [2.5, 5.0, 6.25, 10.0, 12.5, 25.0, 50.0, 100.0]

S_TONES = [str(x) for x in [1000, 1450, 1750, 2100]]

STEP_LIST = [str(x)+"kHz" for x in STEPS]

ROGER_LIST = ["Off", "Begin", "End", "Both"]

TIMEOUT_LIST = [str(x) + "s" for x in range(15, 601, 15)]

TOA_LIST = ["Off"] + ["%ds" % t for t in range(1, 11)]

BANDWIDTH_LIST = ["Wide", "Narrow"]

LANGUAGE_LIST = ["English", "Chinese"]

LANGUAGE_LIST2 = ["English", "Chinese-DISABLED"]

PF1KEY_LIST = ["OFF", "call id", "r-alarm", "SOS", "SF-TX"]

PF1KEY_LIST9GX = ["OFF", "call id", "r-alarm", "SOS", "SF-TX", "Scan",

                  "Second", "Lamp"]

PF2KEY_LIST = ["OFF", "Scan", "Second", "Lamp", "SDF-DIR", "K-lamp"]

PF2KEY_LIST9GX = ["OFF", "Scan", "Second", "Lamp", "K-lamp"]

PF3KEY_LIST2 = ["OFF", "Call ID", "R-ALARM", "SOS", "SF-TX", "Scan",

                "Second", "Lamp"]

PF3KEY_LIST9GX = ["OFF", "call id", "r-alarm", "SOS", "SF-TX", "Scan",

                  "Second", "Lamp"]

PF3KEY_LIST = ["OFF", "Call ID", "R-ALARM", "SOS", "SF-TX"]

WORKMODE_LIST = ["VFO freq", "Channel No.", "Ch. No.+Freq.",