test_config.py 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375
  1. # python-cc1101 - Python Library to Transmit RF Signals via C1101 Transceivers
  2. #
  3. # Copyright (C) 2020 Fabian Peter Hammerle <fabian@hammerle.me>
  4. #
  5. # This program is free software: you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation, either version 3 of the License, or
  8. # any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program. If not, see <https://www.gnu.org/licenses/>.
  17. import unittest.mock
  18. import pytest
  19. import cc1101
  20. from cc1101.options import PacketLengthMode, SyncMode
  21. # pylint: disable=protected-access
  22. @pytest.mark.parametrize(
  23. ("xfer_return_value", "sync_word"),
  24. [([64, 211, 145], b"\xd3\x91"), ([64, 0, 0], b"\0\0")],
  25. )
  26. def test_get_sync_word(transceiver, xfer_return_value, sync_word):
  27. transceiver._spi.xfer.return_value = xfer_return_value
  28. assert transceiver.get_sync_word() == sync_word
  29. transceiver._spi.xfer.assert_called_once_with([0x04 | 0xC0, 0, 0])
  30. def test_set_sync_word(transceiver):
  31. transceiver._spi.xfer.return_value = [15, 15, 15]
  32. transceiver.set_sync_word(b"\x12\x34")
  33. transceiver._spi.xfer.assert_called_once_with([0x04 | 0x40, 0x12, 0x34])
  34. @pytest.mark.parametrize("sync_word", [b"", b"\0", "\x12\x34\x56"])
  35. def test_set_sync_word_invalid_length(transceiver, sync_word):
  36. with pytest.raises(ValueError, match=r"\bexpected two bytes\b"):
  37. transceiver.set_sync_word(sync_word)
  38. _FREQUENCY_CONTROL_WORD_HERTZ_PARAMS = [
  39. ([0x10, 0xA7, 0x62], 433000000),
  40. ([0x10, 0xAB, 0x85], 433420000),
  41. ([0x10, 0xB1, 0x3B], 434000000),
  42. ([0x21, 0x62, 0x76], 868000000),
  43. ]
  44. @pytest.mark.parametrize(
  45. ("control_word", "hertz"), _FREQUENCY_CONTROL_WORD_HERTZ_PARAMS
  46. )
  47. def test__frequency_control_word_to_hertz(control_word, hertz):
  48. assert cc1101.CC1101._frequency_control_word_to_hertz(
  49. control_word
  50. ) == pytest.approx(hertz, abs=200)
  51. @pytest.mark.parametrize(
  52. ("control_word", "hertz"), _FREQUENCY_CONTROL_WORD_HERTZ_PARAMS
  53. )
  54. def test__hertz_to_frequency_control_word(control_word, hertz):
  55. assert cc1101.CC1101._hertz_to_frequency_control_word(hertz) == control_word
  56. _FILTER_BANDWIDTH_MANTISSA_EXPONENT_REAL_PARAMS = [
  57. # > The default values give 203 kHz channel filter bandwidth,
  58. # > assuming a 26.0 MHz crystal.
  59. (0, 2, 203e3),
  60. # "Table 26: Channel Filter Bandwidths [kHz] (assuming a 26 MHz crystal)"
  61. (0, 0, 812e3),
  62. (0, 1, 406e3),
  63. (0, 2, 203e3),
  64. (1, 0, 650e3),
  65. (1, 1, 325e3),
  66. (3, 0, 464e3),
  67. (3, 1, 232e3),
  68. (3, 2, 116e3),
  69. (3, 3, 58e3),
  70. ]
  71. @pytest.mark.parametrize(
  72. ("mantissa", "exponent", "real"), _FILTER_BANDWIDTH_MANTISSA_EXPONENT_REAL_PARAMS
  73. )
  74. def test__filter_bandwidth_floating_point_to_real(mantissa, exponent, real):
  75. assert cc1101.CC1101._filter_bandwidth_floating_point_to_real(
  76. mantissa=mantissa, exponent=exponent
  77. ) == pytest.approx(real, rel=1e-3)
  78. @pytest.mark.parametrize(
  79. ("mdmcfg4", "real"),
  80. [
  81. (0b10001100, 203e3),
  82. (0b10001010, 203e3),
  83. (0b10001110, 203e3),
  84. (0b11111100, 58e3),
  85. (0b01011100, 325e3),
  86. ],
  87. )
  88. def test__get_filter_bandwidth_hertz(transceiver, mdmcfg4, real):
  89. transceiver._spi.xfer.return_value = [15, mdmcfg4]
  90. assert transceiver._get_filter_bandwidth_hertz() == pytest.approx(real, rel=1e-3)
  91. transceiver._spi.xfer.assert_called_once_with([0x10 | 0x80, 0])
  92. @pytest.mark.parametrize(
  93. ("mdmcfg4_before", "mdmcfg4_after", "exponent", "mantissa"),
  94. [
  95. (0b00001010, 0b10111010, 0b10, 0b11),
  96. (0b00001100, 0b01001100, 0b01, 0b00),
  97. (0b00001100, 0b10111100, 0b10, 0b11),
  98. (0b00001100, 0b11011100, 0b11, 0b01),
  99. (0b01011100, 0b11011100, 0b11, 0b01),
  100. (0b11111100, 0b11011100, 0b11, 0b01),
  101. ],
  102. )
  103. def test__set_filter_bandwidth(
  104. transceiver, mdmcfg4_before, mdmcfg4_after, exponent, mantissa
  105. ):
  106. transceiver._spi.xfer.return_value = [15, 15]
  107. with unittest.mock.patch.object(
  108. transceiver, "_read_single_byte", return_value=mdmcfg4_before
  109. ):
  110. transceiver._set_filter_bandwidth(mantissa=mantissa, exponent=exponent)
  111. transceiver._spi.xfer.assert_called_once_with([0x10 | 0x40, mdmcfg4_after])
  112. @pytest.mark.parametrize(
  113. ("mdmcfg4", "symbol_rate_exponent"), [(0b1001100, 12), (0b10011001, 9)]
  114. )
  115. def test__get_symbol_rate_exponent(transceiver, mdmcfg4, symbol_rate_exponent):
  116. transceiver._spi.xfer.return_value = [15, mdmcfg4]
  117. assert transceiver._get_symbol_rate_exponent() == symbol_rate_exponent
  118. transceiver._spi.xfer.assert_called_once_with([0x10 | 0x80, 0])
  119. @pytest.mark.parametrize(
  120. ("mdmcfg3", "symbol_rate_mantissa"), [(0b00100010, 34), (0b10101010, 170)]
  121. )
  122. def test__get_symbol_rate_mantissa(transceiver, mdmcfg3, symbol_rate_mantissa):
  123. transceiver._spi.xfer.return_value = [15, mdmcfg3]
  124. assert transceiver._get_symbol_rate_mantissa() == symbol_rate_mantissa
  125. transceiver._spi.xfer.assert_called_once_with([0x11 | 0x80, 0])
  126. _SYMBOL_RATE_MANTISSA_EXPONENT_REAL_PARAMS = [
  127. # > The default values give a data rate of 115.051 kBaud
  128. # > (closest setting to 115.2 kBaud), assuming a 26.0 MHz crystal.
  129. (34, 12, 115051),
  130. (34, 12 + 1, 115051 * 2),
  131. (34, 12 - 1, 115051 / 2),
  132. ]
  133. @pytest.mark.parametrize(
  134. ("mantissa", "exponent", "real"), _SYMBOL_RATE_MANTISSA_EXPONENT_REAL_PARAMS
  135. )
  136. def test__symbol_rate_floating_point_to_real(mantissa, exponent, real):
  137. assert cc1101.CC1101._symbol_rate_floating_point_to_real(
  138. mantissa=mantissa, exponent=exponent
  139. ) == pytest.approx(real, rel=1e-5)
  140. @pytest.mark.parametrize(
  141. ("mantissa", "exponent", "real"), _SYMBOL_RATE_MANTISSA_EXPONENT_REAL_PARAMS
  142. )
  143. def test__symbol_rate_real_to_floating_point(mantissa, exponent, real):
  144. assert cc1101.CC1101._symbol_rate_real_to_floating_point(real) == (
  145. mantissa,
  146. exponent,
  147. )
  148. @pytest.mark.parametrize(
  149. ("mdmcfg2", "sync_mode"),
  150. [
  151. (0b00000000, SyncMode.NO_PREAMBLE_AND_SYNC_WORD),
  152. (0b00000001, SyncMode.TRANSMIT_16_MATCH_15_BITS),
  153. (0b00000010, SyncMode.TRANSMIT_16_MATCH_16_BITS),
  154. (0b00000011, SyncMode.TRANSMIT_32_MATCH_30_BITS),
  155. (0b00000110, SyncMode.TRANSMIT_16_MATCH_16_BITS),
  156. (0b00000111, SyncMode.TRANSMIT_32_MATCH_30_BITS),
  157. (0b00001100, SyncMode.NO_PREAMBLE_AND_SYNC_WORD),
  158. (0b01101011, SyncMode.TRANSMIT_32_MATCH_30_BITS),
  159. (0b01101111, SyncMode.TRANSMIT_32_MATCH_30_BITS),
  160. ],
  161. )
  162. def test_get_sync_mode(transceiver, mdmcfg2, sync_mode):
  163. transceiver._spi.xfer.return_value = [15, mdmcfg2]
  164. assert transceiver.get_sync_mode() == sync_mode
  165. transceiver._spi.xfer.assert_called_once_with([0x12 | 0x80, 0])
  166. @pytest.mark.parametrize(
  167. ("mdmcfg2_before", "mdmcfg2_after", "sync_mode", "threshold_enabled"),
  168. [
  169. (0b00000010, 0b00000000, SyncMode.NO_PREAMBLE_AND_SYNC_WORD, None),
  170. (0b00000010, 0b00000001, SyncMode.TRANSMIT_16_MATCH_15_BITS, None),
  171. (0b00000010, 0b00000010, SyncMode.TRANSMIT_16_MATCH_16_BITS, None),
  172. (0b00000010, 0b00000011, SyncMode.TRANSMIT_32_MATCH_30_BITS, None),
  173. (0b01101110, 0b01101111, SyncMode.TRANSMIT_32_MATCH_30_BITS, None),
  174. (0b00000010, 0b00000110, SyncMode.TRANSMIT_16_MATCH_16_BITS, True),
  175. (0b00000010, 0b00000111, SyncMode.TRANSMIT_32_MATCH_30_BITS, True),
  176. (0b01101110, 0b01101111, SyncMode.TRANSMIT_32_MATCH_30_BITS, True),
  177. (0b00000010, 0b00000010, SyncMode.TRANSMIT_16_MATCH_16_BITS, False),
  178. (0b00000010, 0b00000011, SyncMode.TRANSMIT_32_MATCH_30_BITS, False),
  179. (0b01101110, 0b01101011, SyncMode.TRANSMIT_32_MATCH_30_BITS, False),
  180. ],
  181. )
  182. def test_set_sync_mode(
  183. transceiver, mdmcfg2_before, mdmcfg2_after, sync_mode, threshold_enabled
  184. ):
  185. transceiver._spi.xfer.return_value = [15, 15]
  186. with unittest.mock.patch.object(
  187. transceiver, "_read_single_byte", return_value=mdmcfg2_before
  188. ):
  189. transceiver.set_sync_mode(
  190. sync_mode, _carrier_sense_threshold_enabled=threshold_enabled
  191. )
  192. transceiver._spi.xfer.assert_called_once_with([0x12 | 0x40, mdmcfg2_after])
  193. @pytest.mark.parametrize(
  194. ("mdmcfg1", "length"),
  195. [
  196. (0b00000010, 2),
  197. (0b00010010, 3),
  198. (0b00100010, 4),
  199. (0b00110010, 6),
  200. (0b01000010, 8),
  201. (0b01010010, 12),
  202. (0b01100010, 16),
  203. (0b01110010, 24),
  204. ],
  205. )
  206. def test_get_preamble_length_bytes(transceiver, mdmcfg1, length):
  207. transceiver._spi.xfer.return_value = [0, mdmcfg1]
  208. assert transceiver.get_preamble_length_bytes() == length
  209. transceiver._spi.xfer.assert_called_once_with([0x13 | 0x80, 0])
  210. @pytest.mark.parametrize(
  211. ("mdmcfg1_before", "mdmcfg1_after", "length"),
  212. [
  213. (0b00000010, 0b00000010, 2),
  214. (0b00000010, 0b00010010, 3),
  215. (0b00000010, 0b00100010, 4),
  216. (0b00000010, 0b00110010, 6),
  217. (0b00000010, 0b01000010, 8),
  218. (0b00000010, 0b01010010, 12),
  219. (0b00000010, 0b01100010, 16),
  220. (0b00000010, 0b01110010, 24),
  221. (0b01010010, 0b01100010, 16),
  222. (0b01110010, 0b00000010, 2),
  223. (0b01110010, 0b01000010, 8),
  224. (0b11011010, 0b11101010, 16),
  225. (0b11110111, 0b11000111, 8),
  226. (0b11111110, 0b10001110, 2),
  227. ],
  228. )
  229. def test_set_preamble_length_bytes(transceiver, mdmcfg1_before, mdmcfg1_after, length):
  230. transceiver._spi.xfer.return_value = [15, 15]
  231. with unittest.mock.patch.object(
  232. transceiver, "_read_single_byte", return_value=mdmcfg1_before
  233. ):
  234. transceiver.set_preamble_length_bytes(length)
  235. transceiver._spi.xfer.assert_called_once_with([0x13 | 0x40, mdmcfg1_after])
  236. @pytest.mark.parametrize(
  237. "length", [-21, 0, 1, 5, 7, 9, 10, 11, 13, 14, 15, 17, 20, 23, 25, 32, 42]
  238. )
  239. def test_set_preamble_length_bytes_invalid(transceiver, length):
  240. with pytest.raises(ValueError, match=r"\bpreamble length\b"):
  241. transceiver.set_preamble_length_bytes(length)
  242. def test_get_packet_length_bytes(transceiver):
  243. xfer_mock = transceiver._spi.xfer
  244. xfer_mock.return_value = [0, 8]
  245. assert transceiver.get_packet_length_bytes() == 8
  246. xfer_mock.assert_called_once_with([0x06 | 0x80, 0])
  247. @pytest.mark.parametrize("packet_length", [21])
  248. def test_set_packet_length_bytes(transceiver, packet_length):
  249. xfer_mock = transceiver._spi.xfer
  250. xfer_mock.return_value = [15, 15]
  251. transceiver.set_packet_length_bytes(packet_length)
  252. xfer_mock.assert_called_once_with([0x06 | 0x40, packet_length])
  253. @pytest.mark.parametrize("packet_length", [-21, 0, 256, 1024])
  254. def test_set_packet_length_bytes_fail(transceiver, packet_length):
  255. with pytest.raises(Exception):
  256. transceiver.set_packet_length_bytes(packet_length)
  257. transceiver._spi.xfer.assert_not_called()
  258. @pytest.mark.parametrize(
  259. ("pktctrl0_before", "pktctrl0_after"),
  260. (
  261. # unchanged
  262. (0b00000000, 0b00000000),
  263. (0b00010000, 0b00010000),
  264. (0b00010001, 0b00010001),
  265. (0b01000000, 0b01000000),
  266. (0b01000010, 0b01000010),
  267. (0b01110000, 0b01110000),
  268. (0b01110010, 0b01110010),
  269. # disabled
  270. (0b00010100, 0b00010000),
  271. (0b01000100, 0b01000000),
  272. (0b01000110, 0b01000010),
  273. (0b01110110, 0b01110010),
  274. ),
  275. )
  276. def test_disable_checksum(transceiver, pktctrl0_before, pktctrl0_after):
  277. xfer_mock = transceiver._spi.xfer
  278. xfer_mock.return_value = [15, 15]
  279. with unittest.mock.patch.object(
  280. transceiver, "_read_single_byte", return_value=pktctrl0_before
  281. ):
  282. transceiver.disable_checksum()
  283. xfer_mock.assert_called_once_with([0x08 | 0x40, pktctrl0_after])
  284. @pytest.mark.parametrize(
  285. ("pktctrl0", "expected_mode"),
  286. (
  287. (0b00000000, PacketLengthMode.FIXED),
  288. (0b00000001, PacketLengthMode.VARIABLE),
  289. (0b01000100, PacketLengthMode.FIXED),
  290. (0b01000101, PacketLengthMode.VARIABLE),
  291. ),
  292. )
  293. def test_get_packet_length_mode(transceiver, pktctrl0, expected_mode):
  294. xfer_mock = transceiver._spi.xfer
  295. xfer_mock.return_value = [0, pktctrl0]
  296. assert transceiver.get_packet_length_mode() == expected_mode
  297. xfer_mock.assert_called_once_with([0x08 | 0x80, 0])
  298. @pytest.mark.parametrize(
  299. ("pktctrl0_before", "pktctrl0_after", "mode"),
  300. (
  301. (0b00000000, 0b00000000, PacketLengthMode.FIXED),
  302. (0b00000001, 0b00000000, PacketLengthMode.FIXED),
  303. (0b00000001, 0b00000001, PacketLengthMode.VARIABLE),
  304. (0b00000010, 0b00000000, PacketLengthMode.FIXED),
  305. (0b00000010, 0b00000001, PacketLengthMode.VARIABLE),
  306. (0b01000100, 0b01000100, PacketLengthMode.FIXED),
  307. (0b01000100, 0b01000101, PacketLengthMode.VARIABLE),
  308. (0b01000101, 0b01000100, PacketLengthMode.FIXED),
  309. (0b01000101, 0b01000101, PacketLengthMode.VARIABLE),
  310. ),
  311. )
  312. def test_set_packet_length_mode(transceiver, pktctrl0_before, pktctrl0_after, mode):
  313. xfer_mock = transceiver._spi.xfer
  314. xfer_mock.return_value = [15, 15]
  315. with unittest.mock.patch.object(
  316. transceiver, "_read_single_byte", return_value=pktctrl0_before
  317. ):
  318. transceiver.set_packet_length_mode(mode)
  319. xfer_mock.assert_called_once_with([0x08 | 0x40, pktctrl0_after])