Project

General

Profile

Bug #11167 » 20240217fullbackup.py

Sander van der Wel, 02/18/2024 01:31 AM

 
# Copyright 2023:
# * Sander van der Wel, <svdwel@icloud.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

import logging

from pathlib import Path


from chirp import chirp_common, directory
from chirp.settings import RadioSettingGroup, RadioSetting, \
RadioSettingValueBoolean, RadioSettingValueList, \
RadioSettings, RadioSettingValueString
import struct
from chirp.drivers import baofeng_common, baofeng_uv17Pro
from chirp import errors, util

LOG = logging.getLogger(__name__)
LIST_DTMFST = ["Off", "DT-ST", "ANI-ST", "DT+ANI"]
LIST_SAVE = ["Off", "1:1", "1:2", "1:3", "1:4"]
LIST_SCANMODE = ["Time", "Carrier", "Search"]


def _sendmagic(radio, magic, response_len):
baofeng_common._rawsend(radio, magic)
baofeng_common._rawrecv(radio, response_len)


# Locations of memory may differ each time, so a mapping has to be made first
def _get_memory_map(radio):
# Get memory map
memory_map = []
for addr in range(0x1FFF, 0x10FFF, 0x1000):
frame = radio._make_frame(b"R", addr, 1)
baofeng_common._rawsend(radio, frame)
blocknr = baofeng_common._rawrecv(radio, 6)[5]
memory_map += [blocknr]
baofeng_uv17Pro._sendmagic(radio, b"\x06", 1)
return memory_map


def _download(radio):
"""Get the memory map"""
home = str(Path.home())
baofeng_uv17Pro._do_ident(radio)
data = b""
memory_map = _get_memory_map(radio)

status = chirp_common.Status()
status.cur = 0
status.max = radio.MEM_TOTAL // radio.BLOCK_SIZE
status.msg = "Cloning from radio..."
radio.status_fn(status)

for block_number in range(0,16):
block_index = block_number
start_addr = block_index * 0x1000
for addr in range(start_addr, start_addr + 0x1000,
radio.BLOCK_SIZE):
frame = radio._make_read_frame(addr, radio.BLOCK_SIZE)
# DEBUG
LOG.debug("Frame=" + util.hexprint(frame))

baofeng_common._rawsend(radio, frame)

d = baofeng_common._rawrecv(radio, radio.BLOCK_SIZE + 5)

LOG.debug("Response Data= " + util.hexprint(d))

data += d[5:]

status.cur = len(data) // radio.BLOCK_SIZE
status.msg = "Cloning from radio..."
radio.status_fn(status)

baofeng_uv17Pro._sendmagic(radio, b"\x06", 1)
data += bytes(radio.MODEL, 'ascii')
with open(home + "/backup.bin", "wb") as binary_file:
binary_file.write(data)
raise errors.RadioError('Backup complete!')
return data


def _upload(radio):
"""Upload procedure"""
baofeng_uv17Pro._do_ident(radio)

_start_communication(radio)

memory_map = _get_memory_map(radio)

status = chirp_common.Status()
status.cur = 0
status.max = radio.WRITE_MEM_TOTAL // radio.BLOCK_SIZE
status.msg = "Cloning to radio..."
radio.status_fn(status)

for block_number in radio.BLOCK_ORDER:
# Choose a block number if memory map is corrupt
# This happens when the upload process is interrupted
if block_number not in memory_map:
for bn in memory_map:
if bn not in radio.BLOCK_ORDER:
memory_map[memory_map.index(bn)] = block_number
break
block_index = memory_map.index(block_number) + 1
start_addr = block_index * 0x1000
data_start_addr = radio.BLOCK_ORDER.index(block_number) * 0x1000
for addr in range(start_addr, start_addr + 0x1000,
radio.BLOCK_SIZE):

# sending the data
data_addr = data_start_addr + addr - start_addr
data = radio.get_mmap()[data_addr:data_addr + radio.BLOCK_SIZE]
frame = radio._make_frame(b"W", addr, radio.BLOCK_SIZE, data)
baofeng_common._rawsend(radio, frame)

# receiving the response
ack = baofeng_common._rawrecv(radio, 1)
if ack != b"\x06":
msg = "Bad ack writing block 0x%04x" % addr
raise errors.RadioError(msg)

# UI Update
status.cur = (data_addr) // radio.BLOCK_SIZE
status.msg = "Cloning to radio..."
radio.status_fn(status)


def _start_communication(radio):
for magic in radio._magics:
_sendmagic(radio, magic[0], magic[1])


@directory.register
class UV17Backup(baofeng_uv17Pro.UV17Pro):
"""Baofeng UV-17"""
VENDOR = "Baofeng"
MODEL = "UV-17Backup"
NEEDS_COMPAT_SERIAL = False

download_function = _download
upload_function = _upload

MODES = ["FM", "NFM"]
BLOCK_ORDER = [0x16, 0x17, 0x18, 0x19, 0x24, 0x25, 0x26, 0x4, 0x6]
MEM_TOTAL = 0x9000
WRITE_MEM_TOTAL = 0x9000
BLOCK_SIZE = 0x40
BAUD_RATE = 57600
_magic = b"PSEARCH"
_magic_response_length = 8
_magics = [[b"PASSSTA", 3], [b"SYSINFO", 1],
[b"\x56\x00\x00\x0A\x0D", 13], [b"\x06", 1],
[b"\x56\x00\x10\x0A\x0D", 13], [b"\x06", 1],
[b"\x56\x00\x20\x0A\x0D", 13], [b"\x06", 1],
[b"\x56\x00\x00\x00\x0A", 11], [b"\x06", 1],
[b"\xFF\xFF\xFF\xFF\x0C\x55\x56\x31\x35\x39\x39\x39", 1],
[b"\02", 8], [b"\x06", 1]]
_fingerprint = b"\x06" + b"UV15999"
_scode_offset = 1

_tri_band = False
POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1.00),
chirp_common.PowerLevel("High", watts=5.00)]

LENGTH_NAME = 11
VALID_BANDS = [baofeng_uv17Pro.UV17Pro._vhf_range,
baofeng_uv17Pro.UV17Pro._uhf_range]
SCODE_LIST = ["%s" % x for x in range(1, 16)]
SQUELCH_LIST = ["Off"] + list("123456789")
LIST_POWERON_DISPLAY_TYPE = ["Full", "Message", "Voltage"]
LIST_TIMEOUT = ["Off"] + ["%s sec" % x for x in range(15, 615, 15)]
LIST_VOICE = ["Chinese", "English"]
LIST_BACKLIGHT_TIMER = ["Always On"] + ["%s sec" % x for x in range(1, 11)]
LIST_MODE = ["Name", "Frequency"]
CHANNELS = 999

MEM_FORMAT = """
#seekto 0x0030;
struct channel {
lbcd rxfreq[4];
lbcd txfreq[4];
u8 unused1;
ul16 rxtone;
ul16 txtone;
u8 unknown1:1,
bcl:1,
pttid:2,
unknown2:1,
wide:1,
lowpower:1,
unknown:1;
u8 scode:4,
unknown3:3,
scan:1;
u8 unknown4;
};

struct {
struct channel mem[252];
} mem1;

#seek 0x10;
struct {
struct channel mem[255];
} mem2;

#seek 0x10;
struct {
struct channel mem[255];
} mem3;

#seek 0x10;
struct {
struct channel mem[237];
} mem4;

#seekto 0x7000;
struct {
u8 powerondistype;
u8 unknown0[15];
char boottext1[10];
u8 unknown1[6];
char boottext2[10];
u8 unknown2[22];
u8 tot;
u8 squelch;
u8 vox;
u8 powersave: 4,
unknown3:2,
voice: 1,
voicesw: 1;
u8 backlight;
u8 beep:1,
autolock:1,
unknown4:1,
tail:1,
scanmode:2,
dtmfst:2;
u8 unknown5:1,
dualstandby:1,
roger:1,
unknown6:3,
fmenable:1,
unknown7:1;
u8 unknown8[9];
u8 unknown9:6,
chbdistype:1,
chadistype:1;
} settings;

struct vfo {
lbcd rxfreq[4];
lbcd txfreq[4];
u8 unused1;
ul16 rxtone;
ul16 txtone;
u8 unknown1:1,
bcl:1,
pttid:2,
unknown2:1,
wide:1,
lowpower:1,
unknown:1;
u8 scode:4,
unknown3:3,
scan:1;
u8 unknown4;
};

#seekto 0x0010;
struct {
struct vfo a;
struct vfo b;
} vfo;

#seekto 0x4000;
struct {
char name[11];
} names[999];

#seekto 0x8000;
struct {
u8 code[5];
} pttid[15];

struct {
u8 unknown[5];
u8 code[5];
} ani;

"""

def _make_frame(self, cmd, addr, length, data=""):
"""Pack the info in the header format"""
frame = struct.pack("<cH", cmd, addr) + struct.pack(">H", length)
# add the data if set
if len(data) != 0:
frame += data
# return the data
return frame

def get_settings(self):
"""Translate the bit in the mem_struct into settings in the UI"""
_mem = self._memobj
basic = RadioSettingGroup("basic", "Basic Settings")
dtmfe = RadioSettingGroup("dtmfe", "DTMF Encode Settings")
top = RadioSettings(basic, dtmfe)

self.get_settings_common_basic(basic, _mem)

def _filter(name):
filtered = ""
for char in str(name):
if char in chirp_common.CHARSET_ASCII:
filtered += char
else:
filtered += " "
return filtered

rs = RadioSetting("settings.boottext1", "Power-On Message 1",
RadioSettingValueString(
0, 10, _filter(self._memobj.settings.boottext1)))
basic.append(rs)

rs = RadioSetting("settings.boottext2", "Power-On Message 2",
RadioSettingValueString(
0, 10, _filter(self._memobj.settings.boottext2)))
basic.append(rs)

if _mem.settings.powersave > 0x04:
val = 0x00
else:
val = _mem.settings.powersave
rs = RadioSetting("settings.powersave", "Battery Saver",
RadioSettingValueList(
LIST_SAVE, LIST_SAVE[val]))
basic.append(rs)

rs = RadioSetting("settings.scanmode", "Scan Mode",
RadioSettingValueList(
LIST_SCANMODE,
LIST_SCANMODE[_mem.settings.scanmode]))
basic.append(rs)

rs = RadioSetting("settings.dtmfst", "DTMF Sidetone",
RadioSettingValueList(LIST_DTMFST, LIST_DTMFST[
_mem.settings.dtmfst]))
basic.append(rs)

rs = RadioSetting("settings.fmenable", "Enable FM radio",
RadioSettingValueBoolean(_mem.settings.fmenable))
basic.append(rs)

self.get_settings_common_dtmf(dtmfe, _mem)

return top

def decode_tone(self, val):
pol = "N"
mode = ""
if val in [0, 0xFFFF]:
xval = 0
elif (val & 0x8000) > 0:
mode = "DTCS"
xval = (val & 0x0f) + (val >> 4 & 0xf)\
* 10 + (val >> 8 & 0xf) * 100
if (val & 0xC000) == 0xC000:
pol = "R"
else:
mode = "Tone"
xval = int((val & 0x0f) + (val >> 4 & 0xf) * 10 +
(val >> 8 & 0xf) * 100 + (val >> 12 & 0xf)
* 1000) / 10.0

return mode, xval, pol

def get_raw_memory(self, number):
# The flash memory contains page_numbers
# This is probably to do wear leveling on the memory
# These numbers are needed, but make the channel memory
# not continuous.
number = number - 1
if number >= 762:
_mem = self._memobj.mem4.mem[number - 762]
return _mem
if number >= 507:
_mem = self._memobj.mem3.mem[number - 507]
return _mem
if number >= 252:
_mem = self._memobj.mem2.mem[number - 252]
return _mem
_mem = self._memobj.mem1.mem[number]
return _mem

def get_memory(self, number):
_mem = self.get_raw_memory(number)
_nam = self._memobj.names[number - 1]

mem = chirp_common.Memory()
mem.number = number

self.get_memory_common(_mem, _nam.name, mem)

return mem

def encode_tone(self, memtone, mode, tone, pol):
if mode == "Tone":
xtone = '%04i' % (tone * 10)
memtone.set_value((int(xtone[0]) << 12) + (int(xtone[1]) << 8) +
(int(xtone[2]) << 4) + int(xtone[3]))
elif mode == "TSQL":
xtone = '%04i' % (tone * 10)
memtone.set_value((int(tone[0]) << 12) + (int(xtone[1]) << 8) +
(int(xtone[2]) << 4) + int(xtone[3]))
elif mode == "DTCS":
xtone = str(int(tone)).rjust(4, '0')
memtone.set_value((0x8000 + (int(xtone[0]) << 12) +
(int(xtone[1]) << 8) + (int(xtone[2]) << 4) +
int(xtone[3])))
else:
memtone.set_value(0)

if mode == "DTCS" and pol == "R":
memtone.set_value(memtone + 0x4000)

def set_memory(self, mem):
_mem = self.get_raw_memory(mem.number)
_nam = self._memobj.names[mem.number - 1]

if mem.empty:
_mem.set_raw(b"\xff" * 16)
return

_mem.set_raw(b"\x00" * 16)

_namelength = self.get_features().valid_name_length
_nam.name = mem.name.ljust(_namelength, '\x00')

self.set_memory_common(mem, _mem)


(24-24/30)