| 18 |
18 |
import os
|
| 19 |
19 |
|
| 20 |
20 |
from chirp import chirp_common, yaesu_clone, directory, errors, util
|
| 21 |
|
from chirp import ft7800
|
| 22 |
21 |
from chirp import bitwise, memmap
|
| 23 |
22 |
from chirp.settings import RadioSettingGroup, RadioSetting
|
| 24 |
23 |
from chirp.settings import RadioSettingValueInteger, RadioSettingValueString
|
| ... | ... | |
| 30 |
29 |
unknown1:5;
|
| 31 |
30 |
u8 unknown2:1,
|
| 32 |
31 |
mode:3,
|
| 33 |
|
unknown8:2,
|
|
32 |
unknown8:1,
|
|
33 |
oddsplit:1,
|
| 34 |
34 |
duplex:2;
|
| 35 |
35 |
bbcd freq[3];
|
| 36 |
36 |
u8 unknownA:1,
|
| 37 |
37 |
tmode:3,
|
| 38 |
38 |
unknownB:4;
|
| 39 |
|
u8 unknown3[3];
|
| 40 |
|
u8 unknown4:2,
|
|
39 |
bbcd split[3];
|
|
40 |
u8 power:2,
|
| 41 |
41 |
tone:6;
|
| 42 |
42 |
u8 unknownC:1,
|
| 43 |
43 |
dtcs:7;
|
| ... | ... | |
| 81 |
81 |
_TMODES = ["", "Tone", "TSQL", "-RVT", "DTCS", "-PR", "-PAG"]
|
| 82 |
82 |
TMODES = ["", "Tone", "TSQL", "", "DTCS", "", ""]
|
| 83 |
83 |
MODES = ["FM", "AM", "NFM", "", "WFM"]
|
| 84 |
|
DUPLEXES = ["", "-", "+"]
|
|
84 |
DUPLEXES = ["", "", "-", "+", "split"]
|
| 85 |
85 |
CHARSET = ('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!"' +
|
| 86 |
86 |
'```````````````````````````````````` ')
|
| 87 |
87 |
|
|
88 |
POWER_LEVELS = [chirp_common.PowerLevel("Hi", watts=50),
|
|
89 |
chirp_common.PowerLevel("Mid", watts=20),
|
|
90 |
chirp_common.PowerLevel("Low", watts=5)]
|
|
91 |
|
| 88 |
92 |
SKIPS = ["", "S", "P"]
|
| 89 |
93 |
|
| 90 |
94 |
def aprs_call_to_str(_call):
|
| ... | ... | |
| 182 |
186 |
status.msg = "Cloning to radio"
|
| 183 |
187 |
radio.status_fn(status)
|
| 184 |
188 |
|
|
189 |
def get_freq(rawfreq):
|
|
190 |
"""Decode a frequency that may include a fractional step flag"""
|
|
191 |
# Ugh. The 0x80 and 0x40 indicate values to add to get the
|
|
192 |
# real frequency. Gross.
|
|
193 |
if rawfreq > 8000000000:
|
|
194 |
rawfreq = (rawfreq - 8000000000) + 5000
|
|
195 |
|
|
196 |
if rawfreq > 4000000000:
|
|
197 |
rawfreq = (rawfreq - 4000000000) + 2500
|
|
198 |
|
|
199 |
if rawfreq > 2000000000:
|
|
200 |
rawfreq = (rawfreq - 2000000000) + 1250
|
|
201 |
|
|
202 |
return rawfreq
|
|
203 |
|
|
204 |
def set_freq(freq, obj, field):
|
|
205 |
"""Encode a frequency with any necessary fractional step flags"""
|
|
206 |
obj[field] = freq / 10000
|
|
207 |
if (freq % 10000) == 5000:
|
|
208 |
obj[field][0].set_bits(0x80)
|
|
209 |
|
|
210 |
if (freq % 10000) == 2500:
|
|
211 |
obj[field][0].set_bits(0x40)
|
|
212 |
|
|
213 |
if (freq % 10000) == 1250:
|
|
214 |
obj[field][0].set_bits(0x20)
|
|
215 |
|
|
216 |
return freq
|
|
217 |
|
| 185 |
218 |
@directory.register
|
| 186 |
219 |
class FTM350Radio(yaesu_clone.YaesuCloneModeRadio):
|
| 187 |
220 |
"""Yaesu FTM-350"""
|
| ... | ... | |
| 209 |
242 |
rf.valid_name_length = 8
|
| 210 |
243 |
rf.valid_characters = CHARSET
|
| 211 |
244 |
rf.memory_bounds = (0, 500)
|
|
245 |
rf.valid_power_levels = POWER_LEVELS
|
| 212 |
246 |
rf.valid_bands = [( 500000, 1800000),
|
| 213 |
247 |
(76000000, 250000000),
|
| 214 |
248 |
(30000000, 1000000000)]
|
|
249 |
rf.can_odd_split = True
|
| 215 |
250 |
return rf
|
| 216 |
251 |
|
| 217 |
252 |
def get_sub_devices(self):
|
| ... | ... | |
| 267 |
302 |
mem.empty = True
|
| 268 |
303 |
return mem
|
| 269 |
304 |
|
| 270 |
|
mem.freq = ft7800.get_freq(int(_mem.freq) * 10000)
|
|
305 |
mem.freq = get_freq(int(_mem.freq) * 10000)
|
| 271 |
306 |
mem.rtone = chirp_common.TONES[_mem.tone]
|
| 272 |
307 |
mem.tmode = TMODES[_mem.tmode]
|
| 273 |
|
mem.duplex = DUPLEXES[_mem.duplex - 1]
|
|
308 |
|
|
309 |
if _mem.oddsplit:
|
|
310 |
mem.duplex = "split"
|
|
311 |
mem.offset = get_freq(int(_mem.split) * 10000)
|
|
312 |
else:
|
|
313 |
mem.duplex = DUPLEXES[_mem.duplex]
|
|
314 |
mem.offset = int(_mem.offset) * 50000
|
|
315 |
|
| 274 |
316 |
mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
|
| 275 |
|
mem.offset = int(_mem.offset) * 50000
|
| 276 |
317 |
mem.mode = MODES[_mem.mode]
|
| 277 |
318 |
mem.skip = SKIPS[_mem.skip]
|
|
319 |
mem.power = POWER_LEVELS[_mem.power]
|
| 278 |
320 |
|
| 279 |
321 |
for char in _lab.string:
|
| 280 |
322 |
if char == 0xCA:
|
| ... | ... | |
| 298 |
340 |
if mem.empty:
|
| 299 |
341 |
return
|
| 300 |
342 |
|
| 301 |
|
ft7800.set_freq(mem.freq, _mem, 'freq')
|
|
343 |
set_freq(mem.freq, _mem, 'freq')
|
| 302 |
344 |
_mem.tone = chirp_common.TONES.index(mem.rtone)
|
| 303 |
345 |
_mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
|
| 304 |
346 |
_mem.tmode = TMODES.index(mem.tmode)
|
| 305 |
|
_mem.duplex = DUPLEXES.index(mem.duplex) + 1
|
| 306 |
|
_mem.offset = mem.offset / 50000
|
| 307 |
347 |
_mem.mode = MODES.index(mem.mode)
|
| 308 |
348 |
_mem.skip = SKIPS.index(mem.skip)
|
| 309 |
349 |
|
|
350 |
if mem.duplex == "split":
|
|
351 |
set_freq(mem.offset, _mem, 'split')
|
|
352 |
_mem.oddsplit = True
|
|
353 |
_mem.duplex = 0
|
|
354 |
else:
|
|
355 |
_mem.duplex = DUPLEXES.index(mem.duplex)
|
|
356 |
_mem.offset = mem.offset / 50000
|
|
357 |
|
|
358 |
if mem.power:
|
|
359 |
_mem.power = POWER_LEVELS.index(mem.power)
|
|
360 |
else:
|
|
361 |
_mem.power = 0
|
|
362 |
|
| 310 |
363 |
for i in range(0, 8):
|
| 311 |
364 |
try:
|
| 312 |
365 |
char = CHARSET.index(mem.name[i])
|