CHIRP

# Copyright 2010 Dan Smith <dsmith@danplanet.com>

# Copyright 2014 Angus Ainslie <angus@akkea.ca>

# Copyright 2023 Declan Rieb <WD5EQY@arrl.net>

# Sections of digital settings applied from ft70.py, thus

# Copyright 2017 Nicolas Pike <nick@zbm2.com>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 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/>.

import re

import string

import logging

from chirp.drivers import yaesu_clone

from chirp import chirp_common, directory, bitwise

from chirp import memmap

from chirp.settings import RadioSettingGroup, RadioSetting, RadioSettings, \

            RadioSettingValueInteger, RadioSettingValueString, \

            RadioSettingValueList, RadioSettingValueBoolean, \

            InvalidValueError

from chirp import util

LOG = logging.getLogger(__name__)

MEM_SETTINGS_FORMAT = """

#seekto 0x049a;

struct {

  u8 vfo_a;

  u8 vfo_b;

} squelch;

#seekto 0x04c1;

struct {

  u8 beep;

} beep_select;

#seekto 0x04ce;

struct {

  u8 lcd_dimmer;        // 14 DIMMER

  u8 dtmf_delay;        // 18 DT DLY

  u8 unknown0[3];

  u8 unknown1:4,

     lcd_contrast:4;

  u8 lamp;              // 28 LAMP

  u8 lock;              // 30 LOCK

  u8 unknown2;

  u8 mic_gain;          // 31 MCGAIN

  u8 unknown2_3;

  u8 dw_interval;       // 21 DW INT

  u8 ptt_delay;         // 42 PTT.DLY

  u8 rx_save;           // 48 RX.SAVE

  u8 scan_restart;      // 53 SCN.STR

  u8 unknown3;

  u8 scan_resume;

  u8 unknown4[5];

  u8 tot;

  u8 unknown5[3];

  u8 vfo_mode:1,        // 60 VFO.MOD

     unknown6:1,

     scan_lamp:1,       // 51 SCN.LMP

     unknown7:1,

     ars:1,             // 45 RPT.ARS

     dtmf_speed:1,      // 20 DT SPD

     unknown8:1,

     dtmf_mode:1;

  u8 busy_led:1,

     unknown9:2,

     bclo:1,            // 03 BCLO

     beep_edge:1,       // 06 BEP.EDG

     unknown9_1:3;

  u8 unknown10:5,

     password:1,

     home_rev:1,        // 26 HOME/REV

     moni:1;            // 32 MON/T-Call

  u8 gm_interval:4,     // 25 GM INT

     unknown11:4;

  u8 vol_mode:1,

     unknown11_1:7;

  u8 unknown12:4,

     home_vfo:1,        // 27 HOME->VFO

     unknown12_1:2,

     dw_rt:1;           // 23 DW RVT;

} scan_settings;

#seekto 0x064a;

struct {

  u8 unknown0[4];

  u8 frequency_band;

  u8 unknown1:6,

     manual_or_mr:2;

  u8 unknown2:7,

     mr_banks:1;

  u8 unknown3;

  u16 mr_index;

  u16 bank_index;

  u16 bank_enable;

  u8 unknown4[5];

  u8 unknown5:6,

     power:2;

  u8 unknown6:4,

     tune_step:4;

  u8 unknown7:6,

     duplex:2;

  u8 unknown8:6,

     tone_mode:2;

  u8 unknown9:2,

     tone:6;

  u8 unknown10;

  u8 unknown11:6,

     mode:2;

  bbcd freq0[4];

  bbcd offset_freq[4];

  u8 unknown12[2];

  char label[16];

  u8 unknown13[6];

  bbcd band_lower[4];

  bbcd band_upper[4];

  bbcd rx_freq[4];

  u8 unknown14[22];

  bbcd freq1[4];

  u8 unknown15[11];

  u8 unknown16:3,

     volume:5;

  u8 unknown17[18];

  u8 active_menu_item;

  u8 checksum;

} vfo_info[6];

#seekto 0x047e;

struct {

  u8 unknown1;

  u8 flag;

  u16 unknown2;

  struct {

    u8 padded_yaesu[16];

  } message;

} opening_message;

#seekto 0x%(dtmadd)04X; // FT-1D:0e4a, FT2D:094a

struct {

  u8 memory[16];

} dtmf[10];

#seekto 0x154a;

// These "channels" seem to actually be a structure:

//  first five bits are flags

//      0   Unused (1=entry is unused)

//      1   SW Broadcast

//      2   VHF Marine

//      3   WX (weather)

//      4   ? a mode? ?

//  11 bits of index into frequency tables

//

struct {

    u16 channel[100];

} bank_members[24];

#seekto 0x54a;

struct {

    u16 in_use;

} bank_used[24];

#seekto 0x0EFE;

struct {

  u8 unknown[2];

  u8 name[16];

} bank_info[24];

"""

MEM_FORMAT = """

struct memslot {

  u8 unknown0:2,

     mode_alt:1,  // mode for FTM-3200D

     clock_shift:1,

     unknown1:4;

  u8 mode:2,

     duplex:2,

     tune_step:4;

  bbcd freq[3];

  u8 power:2,

     digmode:2,   // 0=Analog, 1=AMS, 2=DN, 3=VW

     tone_mode:4;

  u16 charsetbits;

  char label[16];

  bbcd offset[3];

  u8 unknown5:2,

     tone:6;

  u8 unknown6:1,

     dcs:7;

  u16 unknown7;

  u8 unknown8:2,

     att:1,

     autostep:1,

     automode:1,

     unknown9:3;

};

#seekto 0x2D4A;

struct memslot memory[%(memnum)d];

struct memslot Skip[99];

struct memslot PMS[100];

#seekto 0x10ca;

struct memslot Home[11];

struct flagslot {

  u8 nosubvfo:1,

     unknown:3,

     pskip:1,

     skip:1,

     used:1,

     valid:1;

};

#seekto 0x280A;

struct flagslot flag[%(memnum)d];

struct flagslot flagskp[99];

struct flagslot flagPMS[100];

"""

MEM_APRS_FORMAT = """

#seekto 0xbeca;

struct {

  u8 rx_baud;

  u8 custom_symbol;

  struct {

    char callsign[6];

    u8 ssid;

  } my_callsign;

  u8 unknown3:4,

     selected_position_comment:4;

  u8 unknown4;

  u8 set_time_manually:1,

     tx_interval_beacon:1,

     ring_beacon:1,

     ring_msg:1,

     aprs_mute:1,

     unknown6:1,

     tx_smartbeacon:1,

     af_dual:1;

  u8 unknown7:1,

     aprs_units_wind_mph:1,

     aprs_units_rain_inch:1,

     aprs_units_temperature_f:1,

     aprs_units_altitude_ft:1,

     unknown8:1,

     aprs_units_distance_m:1,

     aprs_units_position_mmss:1;

  u8 unknown9:6,

     aprs_units_speed:2;

  u8 unknown11:1,

     filter_other:1,

     filter_status:1,

     filter_item:1,

     filter_object:1,

     filter_weather:1,

     filter_position:1,

     filter_mic_e:1;

  u8 unknown12;

  u8 unknown13;

  u8 unknown14;

  u8 unknown15:7,

     latitude_sign:1;

  u8 latitude_degree;

  u8 latitude_minute;

  u8 latitude_second;

  u8 unknown16:7,

     longitude_sign:1;

  u8 longitude_degree;

  u8 longitude_minute;

  u8 longitude_second;

  u8 unknown17:4,

     selected_position:4;

  u8 unknown18:5,

     selected_beacon_status_txt:3;

  u8 unknown19:4,

     beacon_interval:4;

  u8 unknowni21:4,

       tx_delay:4;

  u8 unknown21b:6,

     gps_units_altitude_ft:1,

     gps_units_position_sss:1;

  u8 unknown20:6,

     gps_units_speed:2;

  u8 unknown21c[4];

  struct {

    struct {

      char callsign[6];

      u8 ssid;

    } entry[8];

  } digi_path_7;

  u8 unknown22[18];

  struct {

    char padded_string[16];

  } message_macro[7];

  u8 unknown23:5,

     selected_msg_group:3;

  u8 unknown24;

  struct {

    char padded_string[9];

  } msg_group[8];

  u8 unknown25;

  u8 unknown25a:2,

     timezone:6;

  u8 unknown25b[2];

  u8 active_smartbeaconing;

  struct {

    u8 low_speed_mph;

    u8 high_speed_mph;

    u8 slow_rate_min;

    u8 fast_rate_sec;

    u8 turn_angle;

    u8 turn_slop;

    u8 turn_time_sec;

  } smartbeaconing_profile[3];

  u8 unknown26:2,

     flash_msg:6;

  u8 unknown27:2,

     flash_grp:6;

  u8 unknown28:2,

     flash_bln:6;

  u8 selected_digi_path;

  struct {

    struct {

      char callsign[6];

      u8 ssid;

    } entry[2];

  } digi_path_3_6[4];

  u8 unknown30:6,

     selected_my_symbol:2;

  u8 unknown31[3];

  u8 unknown32:2,

     vibrate_msg:6;

  u8 unknown33:2,

     vibrate_grp:6;

  u8 unknown34:2,

     vibrate_bln:6;

} aprs;

#seekto 0xc26a;

struct {

  char padded_string[60];

} aprs_beacon_status_txt[5];

#seekto 0xFECA;

struct {

  bbcd date[3];

  bbcd time[2];

  u8 sequence;

  u8 unknown1;

  u8 unknown2;

  char sender_callsign[9];

  u8 data_type;

  u8 yeasu_data_type;

  u8 unknown4:1,

     callsign_is_ascii:1,

     unknown5:6;

  u8 unknown6;

  u16 pkt_len;

  u8 unknown7;

  u16 in_use;

  u16 unknown8;

  u16 unknown9;

  u16 unknown10;

} aprs_beacon_meta[60];

#seekto 0x1064A;

struct {

  char dst_callsign[9];

  char path[30];

  u16 flags;

  u8 separator;

  char body[134];

} aprs_beacon_pkt[60];

#seekto 0x137c4;

struct {

  u8 flag;

  char dst_callsign[6];

  u8 dst_callsign_ssid;

  char path_and_body[66];

  u8 unknown[70];

} aprs_message_pkt[60];

"""

MEM_BACKTRACK_FORMAT = """

#seekto 0xdf06;

struct {

  u8 status; // 01 full 08 empty

  u8 reserved0; // 00

  bbcd year; // 17

  bbcd mon; // 06

  bbcd day; // 01

  u8 reserved1; // 06

  bbcd hour; // 21

  bbcd min; // xx

  u8 reserved2; // 00

  u8 reserved3; // 00

  char NShemi[1];

  char lat[3];

  char lat_min[2];

  char lat_dec_sec[4];

  char WEhemi[1];

  char lon[3];

  char lon_min[2];

  char lon_dec_sec[4];

} backtrack[3];

"""

MEM_GM_FORMAT = """

#seekto 0x04ba;

struct {

    u8 unknown:3,

        scan_resume:5;          // 52 SCN.RSM

    u8 unknown1:3,

       dw_resume_interval:5;       // 22 DW RSM

    u8 unknown2;

    u8 unknown3:3,

        apo:5;                  // 02 APO

    u8 unknown4:6,

        gm_ring:2;              // 24 GM RNG

    u8 temp_cf;               // Placeholder as not found

    u8 unknown5;

    } first_settings;

#seekto 0x04ed;

struct {

    u8 unknown1:1,

       unknown2:1,

       unknown3:1,

       unknown4:1,

       unknown5:1,

       unknown6:1,

       unknown7:1,

       unknown8:1;

     } test_bit_field;

#seekto 0x04c0;

struct {

    u8 unknown1:5,

        beep_level:3;           // 05 BEP.LVL

    u8 unknown2:6,

        beep_select:2;          // 04 BEEP

    } beep_settings;

#seekto 0xCF30;

struct {

    u8 unknown0;

    u8 unknown1;

    u8 unknown2;

    u8 unknown3;

    u8 unknown4;

    u8 unknown5;

    u8 unknown6;

    u8 digital_popup;              // 15 DIG.POP

    } digital_settings_more;

#seekto 0xCF7C;

struct {

    u8 unknown0:6,

       ams_tx_mode:2;              // AMS TX Mode

    u8 unknown1;

    u8 unknown2:7,

       standby_beep:1;             // 07 BEP.STB

    u8 unknown3;

    u8 unknown4:6,

       gm_ring:2;                  // 24 GM RNG

    u8 unknown5;

    u8 rx_dg_id;                   // RX DG-ID

    u8 tx_dg_id;                   // TX DG-ID

    u8 unknown6:7,

       vw_mode:1;                  // 16 DIG VW

    u8 unknown7;

    } digital_settings;

#seekto 0x1d6d3;

struct {

    char message[32];

    } GM[10];

#seekto 0x0ced0;

struct {

    char callsign[10];              // 63 MYCALL

    u16 charset;                    // character set ID

    } my_call;

#seekto 0x1ddca;

struct {

    struct {

        char name[16];

    } Category[5];

    struct {

        struct {

            char ID[5];             // ASCII numerals

            char name[16];          // blank-fill

            u8 unknown[3];

        } Rooms[20];

    } RoomsPerCategory[5];

} WiresX_settings;

"""

MEM_CHECKSUM_FORMAT = """

#seekto 0x1FDC9;

u8 checksum;

"""

TMODES = ["", "Tone", "TSQL", "DTCS"]

DUPLEX = ["", "-", "+", "split"]

MODES = ["FM", "AM", "WFM"]

STEPS = list(chirp_common.TUNING_STEPS)

STEPS.remove(30.0)

STEPS.append(100.0)

STEPS.insert(2, 0.0)  # There is a skipped tuning step at index 2 (?)

SKIPS = ["", "S", "P"]

FT1_DTMF_CHARS = list("0123456789ABCD*#-")

CHARSET = ["%i" % int(x) for x in range(0, 10)] + \

    [chr(x) for x in range(ord("A"), ord("Z") + 1)] + \

    [" ", ] + \

    [chr(x) for x in range(ord("a"), ord("z") + 1)] + \

    list(".,:;*#_-/&()@!?^ ") + list("\x00" * 100)

POWER_LEVELS = [chirp_common.PowerLevel("Hi", watts=5.00),

                chirp_common.PowerLevel("L3", watts=2.50),

                chirp_common.PowerLevel("L2", watts=1.00),

                chirp_common.PowerLevel("L1", watts=0.05)]

SKIPNAMES = ["Skip%i" % i for i in range(901, 1000)]

PMSNAMES = ["%s%i" % (c, i) for i in range(1, 51) for c in ['L', 'U']]

HOMENAMES = ["Home%i" % i for i in range(1, 12)]

ALLNAMES = SKIPNAMES + PMSNAMES + HOMENAMES

# list of (array name, (list of memories in that array))

# array names must match names of memories defined for radio

SPECIALS = [

    ("Skip", SKIPNAMES),

    ("PMS", PMSNAMES),

    ("Home", HOMENAMES)

]

# Band edges are integer Hz.

VALID_BANDS = [

    (510000, 1790000),

    (1800000, 50490000),

    (50500000, 75990000),

    (76000000, 107990000),

    (108000000, 136990000),

    (145000000, 169920000),

    (174000000, 221950000),

    (222000000, 419990000),

    (420000000, 469990000),

    (470000000, 773990000),

    (810010000, 999000000)

]

class FT1Bank(chirp_common.NamedBank):

    """A FT1D bank"""

    def get_name(self):

        _bank = self._model._radio._memobj.bank_info[self.index]

        name = ""

        for i in _bank.name:

            if i == 0xFF:

                break

            name += CHARSET[i & 0x7F]

        return name.rstrip()

    def set_name(self, name):

        _bank = self._model._radio._memobj.bank_info[self.index]

        _bank.name = [CHARSET.index(x) for x in name.ljust(16)[:16]]

class FT1BankModel(chirp_common.BankModel):

    """A FT1D bank model"""

    def __init__(self, radio, name='Banks'):

        super(FT1BankModel, self).__init__(radio, name)

        _banks = self._radio._memobj.bank_info

        self._bank_mappings = []

        for index, _bank in enumerate(_banks):

            bank = FT1Bank(self, "%i" % index, "BANK-%i" % index)

            bank.index = index

            self._bank_mappings.append(bank)

    def get_num_mappings(self):

        return len(self._bank_mappings)

    def get_mappings(self):

        return self._bank_mappings

    def _channel_numbers_in_bank(self, bank):

        _bank_used = self._radio._memobj.bank_used[bank.index]

        if _bank_used.in_use == 0xFFFF:

            return set()

        _members = self._radio._memobj.bank_members[bank.index]

        return set([int(ch) + 1 for ch in _members.channel if ch != 0xFFFF])

    def update_vfo(self):

        chosen_bank = [None, None]

        chosen_mr = [None, None]

        flags = self._radio._memobj.flag

        # Find a suitable bank and MR for VFO A and B.

        for bank in self.get_mappings():

            for channel in self._channel_numbers_in_bank(bank):

                chosen_bank[0] = bank.index

                chosen_mr[0] = channel

                if channel & 0x7000 != 0:

                    # Ignore preset channels without comment DAR

                    break

                if not flags[channel].nosubvfo:

                    chosen_bank[1] = bank.index

                    chosen_mr[1] = channel

                    break

            if chosen_bank[1]:

                break

        for vfo_index in (0, 1):

            # 3 VFO info structs are stored as 3 pairs of (master, backup)

            vfo = self._radio._memobj.vfo_info[vfo_index * 2]

            vfo_bak = self._radio._memobj.vfo_info[(vfo_index * 2) + 1]

            if vfo.checksum != vfo_bak.checksum:

                LOG.warn("VFO settings are inconsistent with backup")

            else:

                if ((chosen_bank[vfo_index] is None) and (vfo.bank_index !=

                                                          0xFFFF)):

                    LOG.info("Disabling banks for VFO %d" % vfo_index)

                    vfo.bank_index = 0xFFFF

                    vfo.mr_index = 0xFFFF

                    vfo.bank_enable = 0xFFFF

                elif ((chosen_bank[vfo_index] is not None) and

                      (vfo.bank_index == 0xFFFF)):

                    LOG.info("Enabling banks for VFO %d" % vfo_index)

                    vfo.bank_index = chosen_bank[vfo_index]

                    vfo.mr_index = chosen_mr[vfo_index]

                    vfo.bank_enable = 0x0000

                vfo_bak.bank_index = vfo.bank_index

                vfo_bak.mr_index = vfo.mr_index

                vfo_bak.bank_enable = vfo.bank_enable

    def _update_bank_with_channel_numbers(self, bank, channels_in_bank):

        _members = self._radio._memobj.bank_members[bank.index]

        if len(channels_in_bank) > len(_members.channel):

            raise Exception("Too many entries in bank %d" % bank.index)

        empty = 0

        for index, channel_number in enumerate(sorted(channels_in_bank)):

            _members.channel[index] = channel_number - 1

            if channel_number & 0x7000 != 0:

                LOG.warn("Bank %d uses Yaesu preset frequency id=%04X. "

                         "Chirp cannot see or change that entry." % (

                             bank.index, channel_number))

            empty = index + 1

        for index in range(empty, len(_members.channel)):

            _members.channel[index] = 0xFFFF

    def add_memory_to_mapping(self, memory, bank):

        channels_in_bank = self._channel_numbers_in_bank(bank)

        channels_in_bank.add(memory.number)

        self._update_bank_with_channel_numbers(bank, channels_in_bank)

        _bank_used = self._radio._memobj.bank_used[bank.index]

        _bank_used.in_use = 0x06

        self.update_vfo()

    def remove_memory_from_mapping(self, memory, bank):

        channels_in_bank = self._channel_numbers_in_bank(bank)

        try:

            channels_in_bank.remove(memory.number)

        except KeyError:

            raise Exception("Memory %i is not in bank %s. Cannot remove" %

                            (memory.number, bank))

        self._update_bank_with_channel_numbers(bank, channels_in_bank)

        if not channels_in_bank:

            _bank_used = self._radio._memobj.bank_used[bank.index]

            _bank_used.in_use = 0xFFFF

        self.update_vfo()

    def get_mapping_memories(self, bank):

        memories = []

        for channel in self._channel_numbers_in_bank(bank):

            memories.append(self._radio.get_memory(channel))

        return memories

    def get_memory_mappings(self, memory):

        banks = []

        for bank in self.get_mappings():

            if memory.number in self._channel_numbers_in_bank(bank):

                banks.append(bank)

        return banks

# Note: other radios like FTM3200Radio subclass this radio

@directory.register

class FT1Radio(yaesu_clone.YaesuCloneModeRadio):

    """Yaesu FT1DR"""

    BAUD_RATE = 38400

    VENDOR = "Yaesu"

    MODEL = "FT-1D"

    VARIANT = "R"

    FORMATS = [directory.register_format('FT1D ADMS-6', '*.ft1d')]

    class_specials = SPECIALS

    _model = b"AH44M"

    _memsize = 130507

    _block_lengths = [10, 130497]

    _block_size = 32

    MAX_MEM_SLOT = 900

    _mem_params = {

         "memnum": 900,            # size of memories array

         "flgnum": 900,            # size of flags array

         "dtmadd": 0xe4a,          # location of DTMF storage

    }

    _has_vibrate = False

    _has_af_dual = True

    _adms_ext = '.ft1d'

    _SG_RE = re.compile(r"(?P<sign>[-+NESW]?)(?P<d>[\d]+)[\s\.,]*"

                        r"(?P<m>[\d]*)[\s\']*(?P<s>[\d]*)")

    _RX_BAUD = ("off", "1200 baud", "9600 baud")

    _TX_DELAY = ("100ms", "150ms", "200ms", "250ms", "300ms",

                 "400ms", "500ms", "750ms", "1000ms")

    _WIND_UNITS = ("m/s", "mph")

    _RAIN_UNITS = ("mm", "inch")

    _TEMP_UNITS = ("C", "F")

    _ALT_UNITS = ("m", "ft")

    _DIST_UNITS = ("km", "mile")

    _POS_UNITS = ("dd.mmmm'", "dd mm'ss\"")

    _SPEED_UNITS = ("km/h", "knot", "mph")

    _TIME_SOURCE = ("manual", "GPS")

    _TZ = ("-13:00", "-13:30", "-12:00", "-12:30", "-11:00", "-11:30",

           "-10:00", "-10:30", "-09:00", "-09:30", "-08:00", "-08:30",

           "-07:00", "-07:30", "-06:00", "-06:30", "-05:00", "-05:30",

           "-04:00", "-04:30", "-03:00", "-03:30", "-02:00", "-02:30",

           "-01:00", "-01:30", "-00:00", "-00:30", "+01:00", "+01:30",

           "+02:00", "+02:30", "+03:00", "+03:30", "+04:00", "+04:30",

           "+05:00", "+05:30", "+06:00", "+06:30", "+07:00", "+07:30",

           "+08:00", "+08:30", "+09:00", "+09:30", "+10:00", "+10:30",

           "+11:00", "+11:30")

    _BEACON_TYPE = ("Off", "Interval", "SmartBeaconing")

    _SMARTBEACON_PROFILE = ("Off", "Type 1", "Type 2", "Type 3")

    _BEACON_INT = ("30s", "1m", "2m", "3m", "5m", "10m", "15m",

                   "20m", "30m", "60m")

    _DIGI_PATHS = ("OFF", "WIDE1-1", "WIDE1-1, WIDE2-1", "Digi Path 4",

                   "Digi Path 5", "Digi Path 6", "Digi Path 7", "Digi Path 8")

    _MSG_GROUP_NAMES = ("Message Group 1", "Message Group 2",

                        "Message Group 3", "Message Group 4",

                        "Message Group 5", "Message Group 6",

                        "Message Group 7", "Message Group 8")

    _POSITIONS = ("GPS", "Manual Latitude/Longitude",

                  "Manual Latitude/Longitude", "P1", "P2", "P3", "P4",

                  "P5", "P6", "P7", "P8", "P9")

    _FLASH = ("OFF", "2 seconds", "4 seconds", "6 seconds", "8 seconds",

              "10 seconds", "20 seconds", "30 seconds", "60 seconds",

              "CONTINUOUS", "every 2 seconds", "every 3 seconds",

              "every 4 seconds", "every 5 seconds", "every 6 seconds",

              "every 7 seconds", "every 8 seconds", "every 9 seconds",

              "every 10 seconds", "every 20 seconds", "every 30 seconds",

              "every 40 seconds", "every 50 seconds", "every minute",

              "every 2 minutes", "every 3 minutes", "every 4 minutes",

              "every 5 minutes", "every 6 minutes", "every 7 minutes",

              "every 8 minutes", "every 9 minutes", "every 10 minutes")

    _BEEP_SELECT = ("Off", "Key+Scan", "Key")

    _SQUELCH = ["%d" % x for x in range(0, 16)]

    _VOLUME = ["%d" % x for x in range(0, 33)]

    _OPENING_MESSAGE = ("Off", "DC", "Message", "Normal")

    _SCAN_RESUME = ["%.1fs" % (0.5 * x) for x in range(4, 21)] + \

                   ["Busy", "Hold"]

    _SCAN_RESTART = ["%.1fs" % (0.1 * x) for x in range(1, 10)] + \

                    ["%.1fs" % (0.5 * x) for x in range(2, 21)]

    _LAMP_KEY = ["Key %d sec" % x

                 for x in range(2, 11)] + ["Continuous", "OFF"]

    _LCD_CONTRAST = ["Level %d" % x for x in range(1, 16)]

    _LCD_DIMMER = ["Level %d" % x for x in range(1, 7)]

    _TOT_TIME = ["Off"] + ["%.1f min" % (0.5 * x) for x in range(1, 21)]

    _OFF_ON = ("Off", "On")

    _VOL_MODE = ("Normal", "Auto Back")

    _DTMF_MODE = ("Manual", "Auto")

    _DTMF_SPEED = ("50ms", "100ms")

    _DTMF_DELAY = ("50ms", "250ms", "450ms", "750ms", "1000ms")

    _MY_SYMBOL = ("/[ Person", "/b Bike", "/> Car", "User selected")

    _BACKTRACK_STATUS = ("Valid", "Invalid")

    _NS_HEMI = ("N", "S")

    _WE_HEMI = ("W", "E")

    _APRS_HIGH_SPEED_MAX = 70

    _MIC_GAIN = ("Level %d" % i for i in range(1, 10))

    _AMS_TX_MODE = ("TX Auto", "TX DIGITAL", "TX FM")

    _VW_MODE = ("On", "Off")

    _DIG_POP_UP = ("Off", "2sec", "4sec", "6sec", "8sec", "10sec",

                   "20sec", "30sec", "60sec", "Continuous")

    _STANDBY_BEEP = ("On", "Off")

    _ON_OFF = ("On", "Off")

    _TEMP_CF = ("Centigrade", "Fahrenheit")

    _APO_SELECT = ("Off", "0.5H", "1.0H", "1.5H", "2.0H", "2.5H",

                   "3.0H", "3.5H", "4.0H", "4.5H", "5.0H",

                   "5.5H", "6.0H", "6.5H", "7.0H", "7.5H", "8.0H",

                   "8.5H", "9.0H", "9.5H", "10.0H", "10.5H",

                   "11.0H", "11.5H", "12.0H")

    _MONI_TCALL = ("Monitor", "Tone-CALL")

    _HOME_REV = ("Home", "Reverse")

    _LOCK = ("KEY", "DIAL", "Key+Dial", "PTT", "Key+PTT", "Dial+PTT", "ALL")

    _PTT_DELAY = ("Off", "20 ms", "50 ms", "100 ms", "200 ms")

    _BEEP_LEVEL = ("Level %i" % i for i in range(1, 7))

    _SET_MODE = ("Level %i" % i for i in range(1, 8))

    _RX_SAVE = ("OFF", "0.2s", ".3s", ".4s", ".5s", ".6s",

                ".7s", ".8s", ".9s", "1.0s", "1.5s",

                "2.0s", "2.5s", "3.0s", "3.5s", "4.0s", "4.5s",

                "5.0s", "5.5s", "6.0s", "6.5s", "7.0s",

                "7.5s", "8.0s", "8.5s", "9.0s", "10.0s", "15s",

                "20s", "25s", "30s", "35s", "40s", "45s", "50s", "55s",

                "60s")

    _VFO_MODE = ("ALL", "BAND")

    _VFO_SCAN_MODE = ("BAND", "ALL")

    _MEMORY_SCAN_MODE = ("BAND", "ALL")

    _SG_RE = re.compile(r"(?P<sign>[-+NESW]?)(?P<d>[\d]+)[\s\.,]*"

                        "(?P<m>[\d]*)[\s\']*(?P<s>[\d]*)")

    _RX_BAUD = ("off", "1200 baud", "9600 baud")

    _TX_DELAY = ("100ms", "150ms", "200ms", "250ms", "300ms",

                 "400ms", "500ms", "750ms", "1000ms")

    _WIND_UNITS = ("m/s", "mph")

    _RAIN_UNITS = ("mm", "inch")

    _TEMP_UNITS = ("C", "F")

    _ALT_UNITS = ("m", "ft")

    _DIST_UNITS = ("km", "mile")

    _POS_UNITS = ("dd.mmmm'", "dd mm'ss\"")

    _SPEED_UNITS = ("km/h", "knot", "mph")

    _TIME_SOURCE = ("manual", "GPS")

    _TZ = ("-13:00", "-13:30", "-12:00", "-12:30", "-11:00", "-11:30",

           "-10:00", "-10:30", "-09:00", "-09:30", "-08:00", "-08:30",

           "-07:00", "-07:30", "-06:00", "-06:30", "-05:00", "-05:30",

           "-04:00", "-04:30", "-03:00", "-03:30", "-02:00", "-02:30",

           "-01:00", "-01:30", "-00:00", "-00:30", "+01:00", "+01:30",

           "+02:00", "+02:30", "+03:00", "+03:30", "+04:00", "+04:30",

           "+05:00", "+05:30", "+06:00", "+06:30", "+07:00", "+07:30",

           "+08:00", "+08:30", "+09:00", "+09:30", "+10:00", "+10:30",

           "+11:00", "+11:30")

    _BEACON_TYPE = ("Off", "Interval", "SmartBeaconing")

    _SMARTBEACON_PROFILE = ("Off", "Type 1", "Type 2", "Type 3")

    _BEACON_INT = ("30s", "1m", "2m", "3m", "5m", "10m", "15m",

                   "20m", "30m", "60m")

    _DIGI_PATHS = ("OFF", "WIDE1-1", "WIDE1-1, WIDE2-1", "Digi Path 4",

                   "Digi Path 5", "Digi Path 6", "Digi Path 7", "Digi Path 8")

    _MSG_GROUP_NAMES = ("Message Group 1", "Message Group 2",

                        "Message Group 3", "Message Group 4",

                        "Message Group 5", "Message Group 6",

                        "Message Group 7", "Message Group 8")

    _POSITIONS = ("GPS", "Manual Latitude/Longitude",

                  "Manual Latitude/Longitude", "P1", "P2", "P3", "P4",

                  "P5", "P6", "P7", "P8", "P9")

    _FLASH = ("OFF", "2 seconds", "4 seconds", "6 seconds", "8 seconds",

              "10 seconds", "20 seconds", "30 seconds", "60 seconds",

              "CONTINUOUS", "every 2 seconds", "every 3 seconds",

              "every 4 seconds", "every 5 seconds", "every 6 seconds",

              "every 7 seconds", "every 8 seconds", "every 9 seconds",

              "every 10 seconds", "every 20 seconds", "every 30 seconds",

              "every 40 seconds", "every 50 seconds", "every minute",

              "every 2 minutes", "every 3 minutes", "every 4 minutes",

              "every 5 minutes", "every 6 minutes", "every 7 minutes",

              "every 8 minutes", "every 9 minutes", "every 10 minutes")

    _BEEP_SELECT = ("Off", "Key+Scan", "Key")

    _SQUELCH = ["%d" % x for x in range(0, 16)]

    _VOLUME = ["%d" % x for x in range(0, 33)]

    _DG_ID = ["%d" % x for x in range(0, 100)]

    _GM_RING = ("OFF", "IN RING", "AlWAYS")

    _GM_INTERVAL = ("LONG", "NORMAL", "OFF")

    _MYCALL_CHR_SET = list(string.ascii_uppercase) + \

        list(string.digits) + ['-', '/']

    @classmethod

    def match_model(cls, filedata, filename):

        if filename.endswith(cls._adms_ext):

            return True

        else:

            return super().match_model(filedata, filename)

    @classmethod

    def get_prompts(cls):

        rp = chirp_common.RadioPrompts()

        rp.pre_download = _(

            "1. Turn radio off.\n"

            "2. Connect cable to DATA terminal.\n"

            "3. Press and hold in the [F] key while turning the radio on\n"

            "     (\"CLONE\" will appear on the display).\n"

            "4. <b>After clicking OK</b>, press the [BAND] key to send"

            " image.\n")

        rp.pre_upload = _(

            "1. Turn radio off.\n"

            "2. Connect cable to DATA terminal.\n"

            "3. Press and hold in the [F] key while turning the radio on\n"

            "     (\"CLONE\" will appear on the display).\n"

            "4. Press the [Dx] key (\"-WAIT-\" will appear on the LCD).\n")

        return rp

    def process_mmap(self):

        mem_format = MEM_SETTINGS_FORMAT + MEM_FORMAT + MEM_APRS_FORMAT + \