Implement a secure ICS protocol targeting LoRa Node151 microcontroller for controlling irrigation.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

332 lines
7.0 KiB

  1. /*-
  2. * Copyright 2021 John-Mark Gurney.
  3. *
  4. * Redistribution and use in source and binary forms, with or without
  5. * modification, are permitted provided that the following conditions
  6. * are met:
  7. * 1. Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * 2. Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. *
  13. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23. * SUCH DAMAGE.
  24. *
  25. */
  26. #include <usbd_cdc_if.h>
  27. #include <string.h>
  28. /* LoRaMac headers */
  29. #include <board.h>
  30. #include <adc.h>
  31. #include <radio.h>
  32. #include <delay.h>
  33. /* lora-irr headers */
  34. #include <misc.h>
  35. char *
  36. findeol(char *pos, size_t len)
  37. {
  38. while (len) {
  39. if (*pos == '\r' || *pos == '\n')
  40. return pos;
  41. pos++;
  42. len--;
  43. }
  44. return NULL;
  45. }
  46. void
  47. hexdump(const uint8_t *ptr, size_t len)
  48. {
  49. int i;
  50. for (i = 0; i < len; i++)
  51. usb_printf("%02x", ptr[i]);
  52. }
  53. void
  54. txdone(void)
  55. {
  56. usb_printf("txdone\r\n");
  57. Radio.Rx(0);
  58. }
  59. void
  60. txtimeout(void)
  61. {
  62. usb_printf("txtimeout\r\n");
  63. }
  64. void
  65. rxdone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr)
  66. {
  67. usb_printf("rxdone: size: %hu, rssi: %hd, snr: %d\r\ndata: ", size, rssi, snr);
  68. hexdump(payload, size);
  69. usb_printf("\r\n");
  70. }
  71. void
  72. rxtimeout(void)
  73. {
  74. usb_printf("rxtimeout\r\n");
  75. }
  76. void
  77. rxerr(void)
  78. {
  79. usb_printf("rxerr\r\n");
  80. }
  81. RadioEvents_t revents = {
  82. .TxDone = txdone,
  83. .TxTimeout = txtimeout,
  84. .RxDone = rxdone,
  85. .RxTimeout = rxtimeout,
  86. .RxError = rxerr,
  87. };
  88. static uint8_t
  89. hexchartonib(char s)
  90. {
  91. switch (s) {
  92. case '0'...'9':
  93. return s - '0';
  94. case 'a'...'f':
  95. return s - 'a' + 10;
  96. case 'A'...'F':
  97. return s - 'A' + 10;
  98. default:
  99. return -1;
  100. }
  101. }
  102. static bool
  103. hexdecode(char *buf, size_t len, uint8_t *out)
  104. {
  105. uint8_t topchr, botchr;
  106. if (len % 2)
  107. return false;
  108. /* NB: only needed to silence a bad gcc warning */
  109. topchr = -1;
  110. while (len) {
  111. if (len % 2) {
  112. /* bottom nibble */
  113. botchr = hexchartonib(*buf);
  114. if (topchr == -1 || botchr == -1)
  115. return false;
  116. *out = topchr << 4 | botchr;
  117. out++;
  118. } else {
  119. /* top nibble */
  120. topchr = hexchartonib(*buf);
  121. }
  122. len--;
  123. buf++;
  124. }
  125. return true;
  126. }
  127. static const char pktstart[] = "pkt:";
  128. static const size_t pktstartlen = sizeof pktstart - 1;
  129. static uint8_t pktbuf[128];
  130. static void
  131. process_line(char *start, char *end)
  132. {
  133. size_t len;
  134. /* trim off leading CR/NL */
  135. while (start < end && (*start == '\r' || *start == '\n'))
  136. start++;
  137. len = end - start;
  138. if (len >= pktstartlen && memcmp(start, pktstart, sizeof pktstart - 1) == 0) {
  139. start += pktstartlen;
  140. len -= pktstartlen;
  141. if (len % 2) {
  142. usb_printf("invalid pkt len\r\n");
  143. return;
  144. }
  145. if (!hexdecode(start, len, pktbuf)) {
  146. usb_printf("invalid pkt\r\n");
  147. return;
  148. }
  149. Radio.Send(pktbuf, len / 2);
  150. return;
  151. }
  152. usb_printf("line: %.*s", end - start, start);
  153. fflush(vcp_usb);
  154. }
  155. int
  156. main(void)
  157. {
  158. debug_printf("starting...\n");
  159. BoardInitMcu();
  160. Radio.Init(&revents);
  161. /* turn on LED */
  162. HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
  163. setlinebuf(vcp_usb);
  164. #if 1
  165. wait_for_vcp();
  166. /*
  167. * This is required to use w/ FreeBSD. This is an issue w/ the
  168. * STM32 Core USB library:
  169. * https://github.com/STMicroelectronics/STM32CubeL1/issues/10
  170. */
  171. DelayMs(50);
  172. usb_printf("starting...\r\n");
  173. #endif
  174. uint32_t v;
  175. usb_printf("gs: %#x\r\n", Radio.GetStatus());
  176. usb_printf("set modem\r\n");
  177. Radio.SetModem(MODEM_LORA);
  178. usb_printf("check rffreq: %d\r\n", (int)Radio.CheckRfFrequency(914350 * 1000));
  179. usb_printf("set channel\r\n");
  180. Radio.SetChannel(914350 * 1000);
  181. v = Radio.Random();
  182. usb_printf("rr: %#lx\r\n", v);
  183. usb_printf("rssi: %#hx\r\n", Radio.Rssi(MODEM_LORA));
  184. /* RX/TX parameters */
  185. const uint8_t modem = MODEM_LORA;
  186. const uint8_t bandwidth = 0 /* 128 kHz */;
  187. const uint8_t datarate = 7 /* 128 chips */;
  188. const uint8_t coderate = 1 /* 4/5 */;
  189. const uint8_t preambleLen = 8 /* symbols */;
  190. const uint8_t fixLen = 0 /* variable */;
  191. const uint8_t crcOn = 1 /* on */;
  192. const uint8_t freqHopOn = 0 /* off */;
  193. const bool iqInverted = false /* not inverted */;
  194. Radio.SetRxConfig(modem, bandwidth, datarate, coderate, 0/*afc*/,
  195. preambleLen, 5/*symTimeout*/, fixLen, 0/*payloadlen*/, crcOn,
  196. freqHopOn, 0/*hopPeriod*/, iqInverted, true/*rxcont*/);
  197. Radio.SetTxConfig(modem, 11/*power*/, 0/*fdev*/, bandwidth, datarate,
  198. coderate, preambleLen, fixLen, crcOn, freqHopOn, 0/*hopPeriod*/,
  199. iqInverted, 1000/*timeout*/);
  200. uint8_t sendmsg[] = "testing lora123";
  201. usb_printf("sending...\r\n");
  202. Radio.Send(sendmsg, sizeof sendmsg);
  203. DelayMs(200);
  204. Radio.Send(sendmsg, sizeof sendmsg);
  205. DelayMs(200);
  206. Radio.Send(sendmsg, sizeof sendmsg);
  207. DelayMs(200);
  208. usb_printf("rx(0)...\r\n");
  209. Radio.Rx(0);
  210. char inpbuf[1024];
  211. char *lastcheck;
  212. char *endchr;
  213. int inpbufpos = 0;
  214. int cpylen;
  215. loop:
  216. BoardLowPowerHandler();
  217. if (Radio.IrqProcess != NULL)
  218. Radio.IrqProcess();
  219. /* while we have data */
  220. while (CDC_RX_LEN) {
  221. /* store last position */
  222. lastcheck = &inpbuf[inpbufpos];
  223. /* calculate how much space left */
  224. cpylen = MIN(sizeof inpbuf - inpbufpos, CDC_RX_LEN);
  225. /* copy into buffer */
  226. memcpy(&inpbuf[inpbufpos], CDC_RX_BUFFER, cpylen);
  227. /* and point to end of buffer */
  228. inpbufpos += cpylen;
  229. do {
  230. /* find first end of line characters */
  231. endchr = findeol(lastcheck, cpylen);
  232. if (endchr != NULL) {
  233. /* if so, process it */
  234. process_line(inpbuf, endchr);
  235. /* skip end of line char */
  236. endchr++;
  237. /* move remaining buffer to the beginning */
  238. memmove(inpbuf, endchr, inpbufpos - (endchr - inpbuf));
  239. /* and store new length */
  240. inpbufpos = inpbufpos - (endchr - inpbuf);
  241. /* mark begining of stream as last checked */
  242. lastcheck = inpbuf;
  243. /* and try to process another line */
  244. continue;
  245. } else if (inpbufpos == sizeof inpbuf) {
  246. /* we overflowed the buffer */
  247. /* XXX - best way is to throw away this line */
  248. inpbufpos = 0;
  249. }
  250. } while (0);
  251. /* if we copied all the data */
  252. if (cpylen == CDC_RX_LEN) {
  253. /* declare that we are ready to receive more data */
  254. CDC_RX_LEN = 0;
  255. USBD_CDC_ReceivePacket(&hUsbDeviceFS);
  256. } else {
  257. /* if not, move the remaining to the begining and try again */
  258. memmove(CDC_RX_BUFFER, &CDC_RX_BUFFER[cpylen], CDC_RX_LEN - cpylen);
  259. CDC_RX_LEN -= cpylen;
  260. }
  261. }
  262. goto loop;
  263. }