mirror
/
micropython-lib
kopia lustrzana https://github.com/micropython/micropython-lib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
micropython-lib/micropython/lora/tests/test_time_on_air.py

311 wiersze
12 KiB
Python
Czysty Wina Historia

# MicroPython LoRa modem driver time on air tests
# MIT license; Copyright (c) 2023 Angus Gratton
#
# LoRa is a registered trademark or service mark of Semtech Corporation or its affiliates.
#
# ## What is this?
#
# Host tests for the BaseModem.get_time_on_air_us() function. Theses against
# dummy test values produced by the Semtech "SX1261 LoRa Calculator" software,
# as downloaded from
# https://lora-developers.semtech.com/documentation/product-documents/
#
# The app notes for SX1276 (AN1200.3) suggest a similar calculator exists for that
# modem, but it doesn't appear to be available for download any more. I couldn't find
# an accurate calculator for SX1276, so manually calculated the SF5 & SF6 test cases below
# (other values should be the same as SX1262).
#
# ## Instructions
#
# These tests are intended to be run on a host PC via micropython unix port:
#
# cd /path/to/micropython-lib/micropython/lora
# micropython -m tests.test_time_on_air
#
# Note: Using the working directory shown above is easiest way to ensure 'lora' files are imported.
#
from lora import SX1262, SX1276
# Allow time calculations to deviate by up to this much as a ratio
# of the expected value (due to floating point, etc.)
TIME_ERROR_RATIO = 0.00001 # 0.001%
def main():
sx1262 = SX1262(spi=DummySPI(), cs=DummyPin(), busy=DummyPin())
sx1276 = SX1276(spi=DummySPI(0x12), cs=DummyPin())
# Test case format is based on the layout of the Semtech Calculator UI:
#
# (modem_instance,
# (modem settings),
# [
# ((packet config), (output values)),
# ...
# ],
# ),
#
# where each set of modem settings maps to zero or more packet config / output pairs
#
# - modem instance is sx1262 or sx1276 (SF5 & SF6 are different between these modems)
# - (modem settings) is (sf, bw (in khz), coding_rate, low_datarate_optimize)
# - (packet config) is (preamble_len, payload_len, explicit_header, crc_en)
# - (output values) is (total_symbols_excl, symbol_time in ms, time_on_air in ms)
#
# NOTE: total_symbols_excl is the value shown in the calculator output,
# which doesn't include 8 symbols of constant overhead between preamble and
# header+payload+crc. I think this is a bug in the Semtech calculator(!).
# These 8 symbols are included when the calculator derives the total time on
# air.
#
# NOTE ALSO: The "symbol_time" only depends on the modem settings so is
# repeated each group of test cases, and the "time_on_air" is the previous
# two output values multiplied (after accounting for the 8 symbols noted
# above). This repetition is deliberate to make the cases easier to read
# line-by-line when comparing to the calculator window.
CASES = [
(
sx1262,
(12, 500, 5, False), # Calculator defaults when launching calculator
[
((8, 1, True, True), (17.25, 8.192, 206.848)), # Calculator defaults
((12, 64, True, True), (71.25, 8.192, 649.216)),
((8, 1, True, False), (12.25, 8.192, 165.888)),
((8, 192, True, True), (172.25, 8.192, 1476.608)),
((12, 16, False, False), (26.25, 8.192, 280.576)),
],
),
(
sx1262,
(8, 125, 6, False),
[
((8, 1, True, True), (18.25, 2.048, 53.760)),
((8, 2, True, True), (18.25, 2.048, 53.760)),
((8, 2, True, False), (18.25, 2.048, 53.760)),
((8, 3, True, True), (24.25, 2.048, 66.048)),
((8, 3, True, False), (18.25, 2.048, 53.760)),
((8, 4, True, True), (24.25, 2.048, 66.048)),
((8, 4, True, False), (18.25, 2.048, 53.760)),
((8, 5, True, True), (24.25, 2.048, 66.048)),
((8, 5, True, False), (24.25, 2.048, 66.048)),
((8, 253, True, True), (396.25, 2.048, 827.904)),
((8, 253, True, False), (396.25, 2.048, 827.904)),
((12, 5, False, True), (22.25, 2.048, 61.952)),
((12, 5, False, False), (22.25, 2.048, 61.952)),
((12, 10, False, True), (34.25, 2.048, 86.528)),
((12, 253, False, True), (394.25, 2.048, 823.808)),
],
),
# quick check that sx1276 is the same as sx1262 for SF>6
(
sx1276,
(8, 125, 6, False),
[
((8, 1, True, True), (18.25, 2.048, 53.760)),
((8, 2, True, True), (18.25, 2.048, 53.760)),
((12, 5, False, True), (22.25, 2.048, 61.952)),
((12, 5, False, False), (22.25, 2.048, 61.952)),
],
),
# SF5 on SX1262
(
sx1262,
(5, 500, 5, False),
[
(
(2, 1, True, False),
(13.25, 0.064, 1.360),
), # Shortest possible LoRa packet?
((2, 1, True, True), (18.25, 0.064, 1.680)),
((12, 1, False, False), (18.25, 0.064, 1.680)),
((12, 253, False, True), (523.25, 0.064, 34.000)),
],
),
(
sx1262,
(5, 125, 8, False),
[
((12, 253, False, True), (826.25, 0.256, 213.568)),
],
),
# SF5 on SX1276
#
# Note: SF5 & SF6 settings are different between SX1262 & SX1276.
#
# There's no Semtech official calculator available for SX1276, so the
# symbol length is calculated by copying the formula from the datasheet
# "Time on air" section. Symbol time is the same as SX1262. Then the
# time on air is manually calculated by multiplying the two together.
#
# see the functions sx1276_num_payload and sx1276_num_symbols at end of this module
# for the actual functions used.
(
sx1276,
(5, 500, 5, False),
[
(
(2, 1, True, False),
(19.25 - 8, 0.064, 1.232),
), # Shortest possible LoRa packet?
((2, 1, True, True), (24.25 - 8, 0.064, 1.552)),
((12, 1, False, False), (24.25 - 8, 0.064, 1.552)),
((12, 253, False, True), (534.25 - 8, 0.064, 34.192)),
],
),
(
sx1276,
(5, 125, 8, False),
[
((12, 253, False, True), (840.25 - 8, 0.256, 215.104)),
],
),
(
sx1262,
(12, 7.81, 8, True), # Slowest possible
[
((128, 253, True, True), (540.25, 524.456, 287532.907)),
((1000, 253, True, True), (1412.25, 524.456, 744858.387)),
],
),
(
sx1262,
(11, 10.42, 7, True),
[
((25, 16, True, True), (57.25, 196.545, 12824.568)),
((25, 16, False, False), (50.25, 196.545, 11448.752)),
],
),
]
tests = 0
failures = set()
for modem, modem_settings, packets in CASES:
(sf, bw_khz, coding_rate, low_datarate_optimize) = modem_settings
print(
f"Modem config sf={sf} bw={bw_khz}kHz coding_rate=4/{coding_rate} "
+ f"low_datarate_optimize={low_datarate_optimize}"
)
# We don't call configure() as the Dummy interfaces won't handle it,
# just update the BaseModem fields directly
modem._sf = sf
modem._bw_hz = int(bw_khz * 1000)
modem._coding_rate = coding_rate
# Low datarate optimize on/off is auto-configured in the current driver,
# check the automatic selection matches the test case from the
# calculator
if modem._get_ldr_en() != low_datarate_optimize:
print(
f" -- ERROR: Test case has low_datarate_optimize={low_datarate_optimize} "
+ f"but modem selects {modem._get_ldr_en()}"
)
failures += 1
continue # results will not match so don't run any of the packet test cases
for packet_config, expected_outputs in packets:
preamble_len, payload_len, explicit_header, crc_en = packet_config
print(
f" -- preamble_len={preamble_len} payload_len={payload_len} "
+ f"explicit_header={explicit_header} crc_en={crc_en}"
)
modem._preamble_len = preamble_len
modem._implicit_header = not explicit_header # opposite logic to calculator
modem._crc_en = crc_en
# Now calculate the symbol length and times and compare with the expected valuesd
(
expected_symbols,
expected_symbol_time,
expected_time_on_air,
) = expected_outputs
print(f" ---- calculator shows total length {expected_symbols}")
expected_symbols += 8 # Account for the calculator bug mentioned in the comment above
n_symbols = modem.get_n_symbols_x4(payload_len) / 4.0
symbol_time_us = modem._get_t_sym_us()
time_on_air_us = modem.get_time_on_air_us(payload_len)
tests += 1
if n_symbols == expected_symbols:
print(f" ---- symbols {n_symbols}")
else:
print(f" ---- SYMBOL COUNT ERROR expected {expected_symbols} got {n_symbols}")
failures.add((modem, modem_settings, packet_config))
max_error = expected_symbol_time * 1000 * TIME_ERROR_RATIO
if abs(int(expected_symbol_time * 1000) - symbol_time_us) <= max_error:
print(f" ---- symbol time {expected_symbol_time}ms")
else:
print(
f" ---- SYMBOL TIME ERROR expected {expected_symbol_time}ms "
+ f"got {symbol_time_us}us"
)
failures.add((modem, modem_settings, packet_config))
max_error = expected_time_on_air * 1000 * TIME_ERROR_RATIO
if abs(int(expected_time_on_air * 1000) - time_on_air_us) <= max_error:
print(f" ---- time on air {expected_time_on_air}ms")
else:
print(
f" ---- TIME ON AIR ERROR expected {expected_time_on_air}ms "
+ f"got {time_on_air_us}us"
)
failures.add((modem, modem_settings, packet_config))
print("************************")
print(f"\n{len(failures)}/{tests} tests failed")
if failures:
print("FAILURES:")
for f in failures:
print(f)
raise SystemExit(1)
print("SUCCESS")
class DummySPI:
# Dummy SPI Interface allows us to use normal constructors
#
# Reading will always return the 'always_read' value
def __init__(self, always_read=0x00):
self.always_read = always_read
def write_readinto(self, _wrbuf, rdbuf):
for i in range(len(rdbuf)):
rdbuf[i] = self.always_read
class DummyPin:
# Dummy Pin interface allows us to use normal constructors
def __init__(self):
pass
def __call__(self, _=None):
pass
# Copies of the functions used to calculate SX1276 SF5, SF6 test case symbol counts.
# (see comments above).
#
# These are written as closely to the SX1276 datasheet "Time on air" section as
# possible, quite different from the BaseModem implementation.
def sx1276_n_payload(pl, sf, ih, de, cr, crc):
import math
ceil_arg = 8 * pl - 4 * sf + 28 + 16 * crc - 20 * ih
ceil_arg /= 4 * (sf - 2 * de)
return 8 + max(math.ceil(ceil_arg) * (cr + 4), 0)
def sx1276_n_syms(pl, sf, ih, de, cr, crc, n_preamble):
return sx1276_n_payload(pl, sf, ih, de, cr, crc) + n_preamble + 4.25
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik