mirror of
https://github.com/DJ2LS/FreeDATA
synced 2024-05-14 08:04:33 +00:00
157 lines
4 KiB
Python
157 lines
4 KiB
Python
"""
|
|
Tests for the FreeDATA modem.
|
|
"""
|
|
|
|
import multiprocessing
|
|
import sys
|
|
import time
|
|
|
|
import pytest
|
|
|
|
# pylint: disable=wrong-import-position
|
|
sys.path.insert(0, "..")
|
|
sys.path.insert(0, "../tnc")
|
|
import helpers
|
|
import modem
|
|
import static
|
|
|
|
|
|
def print_frame(data: bytearray):
|
|
"""
|
|
Pretty-print the provided frame.
|
|
|
|
:param data: Frame to be output
|
|
:type data: bytearray
|
|
"""
|
|
print(f"Type : {int(data[0])}")
|
|
print(f"DXCRC : {bytes(data[1:4])}")
|
|
print(f"CallCRC: {bytes(data[4:7])}")
|
|
print(f"Call : {helpers.bytes_to_callsign(data[7:13])}")
|
|
|
|
|
|
def t_create_frame(frame_type: int, mycall: str, dxcall: str) -> bytearray:
|
|
"""
|
|
Generate the requested frame.
|
|
|
|
:param frame_type: The numerical type of the desired frame.
|
|
:type frame_type: int
|
|
:param mycall: Callsign of the near station
|
|
:type mycall: str
|
|
:param dxcall: Callsign of the far station
|
|
:type dxcall: str
|
|
:return: Bytearray of the requested frame
|
|
:rtype: bytearray
|
|
"""
|
|
mycallsign_bytes = helpers.callsign_to_bytes(mycall)
|
|
mycallsign = helpers.bytes_to_callsign(mycallsign_bytes)
|
|
mycallsign_crc = helpers.get_crc_24(mycallsign)
|
|
|
|
dxcallsign_bytes = helpers.callsign_to_bytes(dxcall)
|
|
dxcallsign = helpers.bytes_to_callsign(dxcallsign_bytes)
|
|
dxcallsign_crc = helpers.get_crc_24(dxcallsign)
|
|
|
|
frame = bytearray(14)
|
|
frame[:1] = bytes([frame_type])
|
|
frame[1:4] = dxcallsign_crc
|
|
frame[4:7] = mycallsign_crc
|
|
frame[7:13] = mycallsign_bytes
|
|
|
|
return frame
|
|
|
|
|
|
def t_create_session_close(mycall: str, dxcall: str) -> bytearray:
|
|
"""
|
|
Generate the session_close frame.
|
|
|
|
:param mycall: Callsign of the near station
|
|
:type mycall: str
|
|
:param dxcall: Callsign of the far station
|
|
:type dxcall: str
|
|
:return: Bytearray of the requested frame
|
|
:rtype: bytearray
|
|
"""
|
|
return t_create_frame(223, mycall, dxcall)
|
|
|
|
|
|
def t_create_start_session(mycall: str, dxcall: str) -> bytearray:
|
|
"""
|
|
Generate the create_session frame.
|
|
|
|
:param mycall: Callsign of the near station
|
|
:type mycall: str
|
|
:param dxcall: Callsign of the far station
|
|
:type dxcall: str
|
|
:return: Bytearray of the requested frame
|
|
:rtype: bytearray
|
|
"""
|
|
return t_create_frame(221, mycall, dxcall)
|
|
|
|
|
|
def t_modem():
|
|
"""
|
|
Execute test to validate that receiving a session open frame sets the correct machine
|
|
state.
|
|
"""
|
|
t_mode = t_repeats = t_repeat_delay = 0
|
|
t_frames = []
|
|
|
|
def t_tx_dummy(mode, repeats, repeat_delay, frames):
|
|
"""Replacement function for transmit"""
|
|
print(f"t_tx_dummy: In transmit({mode}, {repeats}, {repeat_delay}, {frames})")
|
|
nonlocal t_mode, t_repeats, t_repeat_delay, t_frames
|
|
t_mode = mode
|
|
t_repeats = repeats
|
|
t_repeat_delay = repeat_delay
|
|
t_frames = frames[:]
|
|
static.TRANSMITTING = False
|
|
|
|
# enable testmode
|
|
modem.TESTMODE = True
|
|
modem.RXCHANNEL = "/tmp/hfchannel1"
|
|
modem.TXCHANNEL = "/tmp/hfchannel2"
|
|
static.HAMLIB_RADIOCONTROL = "disabled"
|
|
|
|
# Create the modem
|
|
local_modem = modem.RF()
|
|
|
|
# Replace transmit routine with our own, an effective No-Op.
|
|
local_modem.transmit = t_tx_dummy
|
|
|
|
txbuffer = t_create_start_session("AA9AA", "DC2EJ")
|
|
|
|
# Start the transmission
|
|
static.TRANSMITTING = True
|
|
modem.MODEM_TRANSMIT_QUEUE.put([14, 5, 250, txbuffer])
|
|
while static.TRANSMITTING:
|
|
time.sleep(0.1)
|
|
|
|
# Check that the contents were transferred correctly.
|
|
assert t_mode == 14
|
|
assert t_repeats == 5
|
|
assert t_repeat_delay == 250
|
|
assert t_frames == txbuffer
|
|
|
|
|
|
def test_modem_queue():
|
|
proc = multiprocessing.Process(target=t_modem, args=())
|
|
# print("Starting threads.")
|
|
proc.start()
|
|
|
|
time.sleep(0.5)
|
|
|
|
# print("Terminating threads.")
|
|
proc.terminate()
|
|
proc.join()
|
|
|
|
# print(f"\n{proc.exitcode=}")
|
|
assert proc.exitcode == 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# Run pytest with the current script as the filename.
|
|
ecode = pytest.main(["-v", "-s", sys.argv[0]])
|
|
if ecode == 0:
|
|
print("errors: 0")
|
|
else:
|
|
print(ecode)
|