modtronix H / SX1276_terminal

Terminal for sending and receiving data via Semtech SX1276 chip. It uses the FRDM-KL25Z board, with a Modtronix inAir9 SX1276 board, and Modtronix SHD3I shield. The inAir9 module is mounted in iMod port 3 of the SHD3I module. The SHD3I shield is mounted on the FRDM-KL25Z board.

Dependencies:   SX127x_modtronix mbed

Fork of chat_sx127x by wayne roberts

main.cpp@4:7a9007dfc0e5, 2014-05-20 (annotated)

Committer:
dudmuck
Date:
Tue May 20 17:18:47 2014 +0000
Revision:
4:7a9007dfc0e5
Parent:
3:ab386fa756cc
Child:
5:d6e7fb9446ff
added ability to change lora preamble length

Who changed what in which revision?

UserRevisionLine numberNew contents of line
dudmuck 1:1cd0afbed23c 1 #include "sx127x_lora.h"
dudmuck 1:1cd0afbed23c 2 #include "sx127x_fsk.h"
dudmuck 0:be215de91a68 3
dudmuck 0:be215de91a68 4 /*
dudmuck 0:be215de91a68 5 * http://mbed.org/handbook/mbed-FRDM-KL25Z
dudmuck 0:be215de91a68 6 */
dudmuck 0:be215de91a68 7
dudmuck 0:be215de91a68 8 DigitalOut green(LED_GREEN);
dudmuck 0:be215de91a68 9
dudmuck 0:be215de91a68 10 Serial pc(USBTX, USBRX);
dudmuck 0:be215de91a68 11
dudmuck 0:be215de91a68 12 uint8_t tx_cnt;
dudmuck 0:be215de91a68 13 char pcbuf[64];
dudmuck 0:be215de91a68 14
dudmuck 0:be215de91a68 15 typedef enum {
dudmuck 0:be215de91a68 16 APP_NONE = 0,
dudmuck 0:be215de91a68 17 APP_CHAT
dudmuck 0:be215de91a68 18 } app_e;
dudmuck 0:be215de91a68 19
dudmuck 0:be215de91a68 20 app_e app = APP_NONE;
dudmuck 0:be215de91a68 21
dudmuck 0:be215de91a68 22
dudmuck 3:ab386fa756cc 23 const uint32_t frfs[] = { /* frequency hopping table */
dudmuck 0:be215de91a68 24 MHZ_TO_FRF(903.0),
dudmuck 0:be215de91a68 25 MHZ_TO_FRF(904.0),
dudmuck 0:be215de91a68 26 MHZ_TO_FRF(905.0),
dudmuck 0:be215de91a68 27 MHZ_TO_FRF(906.0),
dudmuck 0:be215de91a68 28 MHZ_TO_FRF(907.0),
dudmuck 0:be215de91a68 29 MHZ_TO_FRF(908.0),
dudmuck 0:be215de91a68 30 MHZ_TO_FRF(909.0),
dudmuck 0:be215de91a68 31 MHZ_TO_FRF(910.0),
dudmuck 0:be215de91a68 32 MHZ_TO_FRF(911.0),
dudmuck 0:be215de91a68 33 MHZ_TO_FRF(912.0),
dudmuck 0:be215de91a68 34 MHZ_TO_FRF(913.0),
dudmuck 0:be215de91a68 35 MHZ_TO_FRF(914.0),
dudmuck 0:be215de91a68 36 MHZ_TO_FRF(915.0)
dudmuck 0:be215de91a68 37 };
dudmuck 0:be215de91a68 38
dudmuck 1:1cd0afbed23c 39 #define FSK_LARGE_PKT_THRESHOLD 0x3f
dudmuck 1:1cd0afbed23c 40
dudmuck 0:be215de91a68 41 /******************************************************************************/
dudmuck 0:be215de91a68 42
dudmuck 1:1cd0afbed23c 43 // pin: 3 8 1 7 10 12 5 20 18
dudmuck 0:be215de91a68 44 // mosi, miso, sclk, cs, rst, dio0, dio1, fctx, fcps
dudmuck 0:be215de91a68 45 SX127x radio(PTD2, PTD3, PTD1, PTD0, PTD5, PTA13, PTD4, PTC9, PTC8);
dudmuck 1:1cd0afbed23c 46 SX127x_fsk fsk(radio);
dudmuck 1:1cd0afbed23c 47 SX127x_lora lora(radio);
dudmuck 0:be215de91a68 48
dudmuck 0:be215de91a68 49 void printLoraIrqs_(bool clear)
dudmuck 0:be215de91a68 50 {
dudmuck 0:be215de91a68 51 //in radio class -- RegIrqFlags_t RegIrqFlags;
dudmuck 0:be215de91a68 52
dudmuck 0:be215de91a68 53 //already read RegIrqFlags.octet = radio.read_reg(REG_LR_IRQFLAGS);
dudmuck 0:be215de91a68 54 printf("\r\nIrqFlags:");
dudmuck 1:1cd0afbed23c 55 if (lora.RegIrqFlags.bits.CadDetected)
dudmuck 0:be215de91a68 56 printf("CadDetected ");
dudmuck 1:1cd0afbed23c 57 if (lora.RegIrqFlags.bits.FhssChangeChannel) {
dudmuck 0:be215de91a68 58 //radio.RegHopChannel.octet = radio.read_reg(REG_LR_HOPCHANNEL);
dudmuck 1:1cd0afbed23c 59 printf("FhssChangeChannel:%d ", lora.RegHopChannel.bits.FhssPresentChannel);
dudmuck 0:be215de91a68 60 }
dudmuck 1:1cd0afbed23c 61 if (lora.RegIrqFlags.bits.CadDone)
dudmuck 0:be215de91a68 62 printf("CadDone ");
dudmuck 1:1cd0afbed23c 63 if (lora.RegIrqFlags.bits.TxDone)
dudmuck 0:be215de91a68 64 printf("TxDone ");
dudmuck 1:1cd0afbed23c 65 if (lora.RegIrqFlags.bits.ValidHeader)
dudmuck 0:be215de91a68 66 printf("ValidHeader ");
dudmuck 1:1cd0afbed23c 67 if (lora.RegIrqFlags.bits.PayloadCrcError)
dudmuck 0:be215de91a68 68 printf("PayloadCrcError ");
dudmuck 1:1cd0afbed23c 69 if (lora.RegIrqFlags.bits.RxDone)
dudmuck 0:be215de91a68 70 printf("RxDone ");
dudmuck 1:1cd0afbed23c 71 if (lora.RegIrqFlags.bits.RxTimeout)
dudmuck 0:be215de91a68 72 printf("RxTimeout ");
dudmuck 0:be215de91a68 73
dudmuck 0:be215de91a68 74 printf("\r\n");
dudmuck 0:be215de91a68 75
dudmuck 0:be215de91a68 76 if (clear)
dudmuck 1:1cd0afbed23c 77 radio.write_reg(REG_LR_IRQFLAGS, lora.RegIrqFlags.octet);
dudmuck 0:be215de91a68 78
dudmuck 0:be215de91a68 79 }
dudmuck 0:be215de91a68 80
dudmuck 1:1cd0afbed23c 81 void lora_printCodingRate(bool from_rx)
dudmuck 0:be215de91a68 82 {
dudmuck 1:1cd0afbed23c 83 uint8_t d = lora.getCodingRate(from_rx);
dudmuck 0:be215de91a68 84 printf("CodingRate:");
dudmuck 0:be215de91a68 85 switch (d) {
dudmuck 0:be215de91a68 86 case 1: printf("4/5 "); break;
dudmuck 0:be215de91a68 87 case 2: printf("4/6 "); break;
dudmuck 0:be215de91a68 88 case 3: printf("4/7 "); break;
dudmuck 0:be215de91a68 89 case 4: printf("4/8 "); break;
dudmuck 0:be215de91a68 90 default:
dudmuck 0:be215de91a68 91 printf("%d ", d);
dudmuck 0:be215de91a68 92 break;
dudmuck 0:be215de91a68 93 }
dudmuck 0:be215de91a68 94 }
dudmuck 0:be215de91a68 95
dudmuck 1:1cd0afbed23c 96 void lora_printHeaderMode()
dudmuck 0:be215de91a68 97 {
dudmuck 1:1cd0afbed23c 98 if (lora.getHeaderMode())
dudmuck 0:be215de91a68 99 printf("implicit ");
dudmuck 0:be215de91a68 100 else
dudmuck 0:be215de91a68 101 printf("explicit ");
dudmuck 0:be215de91a68 102 }
dudmuck 0:be215de91a68 103
dudmuck 1:1cd0afbed23c 104 void lora_printBw()
dudmuck 0:be215de91a68 105 {
dudmuck 1:1cd0afbed23c 106 uint8_t bw = lora.getBw();
dudmuck 0:be215de91a68 107
dudmuck 0:be215de91a68 108 printf("Bw:");
dudmuck 0:be215de91a68 109 if (radio.type == SX1276) {
dudmuck 1:1cd0afbed23c 110 switch (lora.RegModemConfig.sx1276bits.Bw) {
dudmuck 0:be215de91a68 111 case 0: printf("7.8KHz "); break;
dudmuck 0:be215de91a68 112 case 1: printf("10.4KHz "); break;
dudmuck 0:be215de91a68 113 case 2: printf("15.6KHz "); break;
dudmuck 0:be215de91a68 114 case 3: printf("20.8KHz "); break;
dudmuck 0:be215de91a68 115 case 4: printf("31.25KHz "); break;
dudmuck 0:be215de91a68 116 case 5: printf("41.7KHz "); break;
dudmuck 0:be215de91a68 117 case 6: printf("62.5KHz "); break;
dudmuck 0:be215de91a68 118 case 7: printf("125KHz "); break;
dudmuck 0:be215de91a68 119 case 8: printf("250KHz "); break;
dudmuck 0:be215de91a68 120 case 9: printf("500KHz "); break;
dudmuck 1:1cd0afbed23c 121 default: printf("%x ", lora.RegModemConfig.sx1276bits.Bw); break;
dudmuck 0:be215de91a68 122 }
dudmuck 0:be215de91a68 123 } else if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 124 switch (lora.RegModemConfig.sx1272bits.Bw) {
dudmuck 0:be215de91a68 125 case 0: printf("125KHz "); break;
dudmuck 0:be215de91a68 126 case 1: printf("250KHz "); break;
dudmuck 0:be215de91a68 127 case 2: printf("500KHz "); break;
dudmuck 0:be215de91a68 128 case 3: printf("11b "); break;
dudmuck 0:be215de91a68 129 }
dudmuck 0:be215de91a68 130 }
dudmuck 0:be215de91a68 131 }
dudmuck 0:be215de91a68 132
dudmuck 1:1cd0afbed23c 133 void lora_printAllBw()
dudmuck 0:be215de91a68 134 {
dudmuck 0:be215de91a68 135 int i, s;
dudmuck 0:be215de91a68 136
dudmuck 0:be215de91a68 137 if (radio.type == SX1276) {
dudmuck 1:1cd0afbed23c 138 s = lora.RegModemConfig.sx1276bits.Bw;
dudmuck 0:be215de91a68 139 for (i = 0; i < 10; i++ ) {
dudmuck 1:1cd0afbed23c 140 lora.RegModemConfig.sx1276bits.Bw = i;
dudmuck 0:be215de91a68 141 printf("%d ", i);
dudmuck 1:1cd0afbed23c 142 lora_printBw();
dudmuck 0:be215de91a68 143 printf("\r\n");
dudmuck 0:be215de91a68 144 }
dudmuck 1:1cd0afbed23c 145 lora.RegModemConfig.sx1276bits.Bw = s;
dudmuck 0:be215de91a68 146 } else if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 147 s = lora.RegModemConfig.sx1272bits.Bw;
dudmuck 0:be215de91a68 148 for (i = 0; i < 3; i++ ) {
dudmuck 1:1cd0afbed23c 149 lora.RegModemConfig.sx1272bits.Bw = i;
dudmuck 0:be215de91a68 150 printf("%d ", i);
dudmuck 1:1cd0afbed23c 151 lora_printBw();
dudmuck 0:be215de91a68 152 printf("\r\n");
dudmuck 0:be215de91a68 153 }
dudmuck 1:1cd0afbed23c 154 lora.RegModemConfig.sx1272bits.Bw = s;
dudmuck 0:be215de91a68 155 }
dudmuck 0:be215de91a68 156 }
dudmuck 0:be215de91a68 157
dudmuck 1:1cd0afbed23c 158 void lora_printSf()
dudmuck 0:be215de91a68 159 {
dudmuck 0:be215de91a68 160 // spreading factor same between sx127[26]
dudmuck 1:1cd0afbed23c 161 printf("sf:%d ", lora.getSf());
dudmuck 0:be215de91a68 162 }
dudmuck 0:be215de91a68 163
dudmuck 1:1cd0afbed23c 164 void lora_printRxPayloadCrcOn()
dudmuck 0:be215de91a68 165 {
dudmuck 1:1cd0afbed23c 166 bool on = lora.getRxPayloadCrcOn();
dudmuck 0:be215de91a68 167 //printf("RxPayloadCrcOn:%s ", on ? "on" : "off");
dudmuck 0:be215de91a68 168 if (on)
dudmuck 0:be215de91a68 169 printf("RxPayloadCrcOn:1 = Tx CRC Enabled\r\n");
dudmuck 0:be215de91a68 170 else
dudmuck 0:be215de91a68 171 printf("RxPayloadCrcOn:1 = no Tx CRC\r\n");
dudmuck 0:be215de91a68 172 }
dudmuck 0:be215de91a68 173
dudmuck 1:1cd0afbed23c 174 void lora_printTxContinuousMode()
dudmuck 0:be215de91a68 175 {
dudmuck 1:1cd0afbed23c 176 printf("TxContinuousMode:%d ", lora.RegModemConfig2.sx1276bits.TxContinuousMode); // same for sx1272 and sx1276
dudmuck 0:be215de91a68 177 }
dudmuck 0:be215de91a68 178
dudmuck 1:1cd0afbed23c 179 void lora_printAgcAutoOn()
dudmuck 0:be215de91a68 180 {
dudmuck 1:1cd0afbed23c 181 printf("AgcAutoOn:%d", lora.getAgcAutoOn());
dudmuck 0:be215de91a68 182 }
dudmuck 0:be215de91a68 183
dudmuck 1:1cd0afbed23c 184 void lora_print_dio()
dudmuck 0:be215de91a68 185 {
dudmuck 1:1cd0afbed23c 186 radio.RegDioMapping2.octet = radio.read_reg(REG_DIOMAPPING2);
dudmuck 0:be215de91a68 187 printf("DIO5:");
dudmuck 0:be215de91a68 188 switch (radio.RegDioMapping2.bits.Dio5Mapping) {
dudmuck 0:be215de91a68 189 case 0: printf("ModeReady"); break;
dudmuck 0:be215de91a68 190 case 1: printf("ClkOut"); break;
dudmuck 0:be215de91a68 191 case 2: printf("ClkOut"); break;
dudmuck 0:be215de91a68 192 }
dudmuck 0:be215de91a68 193 printf(" DIO4:");
dudmuck 0:be215de91a68 194 switch (radio.RegDioMapping2.bits.Dio4Mapping) {
dudmuck 0:be215de91a68 195 case 0: printf("CadDetected"); break;
dudmuck 0:be215de91a68 196 case 1: printf("PllLock"); break;
dudmuck 0:be215de91a68 197 case 2: printf("PllLock"); break;
dudmuck 0:be215de91a68 198 }
dudmuck 0:be215de91a68 199 radio.RegDioMapping1.octet = radio.read_reg(REG_DIOMAPPING1);
dudmuck 0:be215de91a68 200 printf(" DIO3:");
dudmuck 0:be215de91a68 201 switch (radio.RegDioMapping1.bits.Dio3Mapping) {
dudmuck 0:be215de91a68 202 case 0: printf("CadDone"); break;
dudmuck 0:be215de91a68 203 case 1: printf("ValidHeader"); break;
dudmuck 0:be215de91a68 204 case 2: printf("PayloadCrcError"); break;
dudmuck 0:be215de91a68 205 }
dudmuck 0:be215de91a68 206 printf(" DIO2:");
dudmuck 0:be215de91a68 207 switch (radio.RegDioMapping1.bits.Dio2Mapping) {
dudmuck 0:be215de91a68 208 case 0:
dudmuck 0:be215de91a68 209 case 1:
dudmuck 0:be215de91a68 210 case 2:
dudmuck 0:be215de91a68 211 printf("FhssChangeChannel");
dudmuck 0:be215de91a68 212 break;
dudmuck 0:be215de91a68 213 }
dudmuck 0:be215de91a68 214 printf(" DIO1:");
dudmuck 0:be215de91a68 215 switch (radio.RegDioMapping1.bits.Dio1Mapping) {
dudmuck 0:be215de91a68 216 case 0: printf("RxTimeout"); break;
dudmuck 0:be215de91a68 217 case 1: printf("FhssChangeChannel"); break;
dudmuck 0:be215de91a68 218 case 2: printf("CadDetected"); break;
dudmuck 0:be215de91a68 219 }
dudmuck 0:be215de91a68 220 printf(" DIO0:");
dudmuck 0:be215de91a68 221 switch (radio.RegDioMapping1.bits.Dio0Mapping) {
dudmuck 0:be215de91a68 222 case 0: printf("RxDone"); break;
dudmuck 0:be215de91a68 223 case 1: printf("TxDone"); break;
dudmuck 0:be215de91a68 224 case 2: printf("CadDone"); break;
dudmuck 0:be215de91a68 225 }
dudmuck 0:be215de91a68 226
dudmuck 0:be215de91a68 227 printf("\r\n");
dudmuck 0:be215de91a68 228 }
dudmuck 0:be215de91a68 229
dudmuck 1:1cd0afbed23c 230 void fsk_print_dio()
dudmuck 1:1cd0afbed23c 231 {
dudmuck 1:1cd0afbed23c 232 radio.RegDioMapping2.octet = radio.read_reg(REG_DIOMAPPING2);
dudmuck 1:1cd0afbed23c 233
dudmuck 2:c6b23a43a9d9 234 printf("DIO5:");
dudmuck 1:1cd0afbed23c 235 switch (radio.RegDioMapping2.bits.Dio5Mapping) {
dudmuck 1:1cd0afbed23c 236 case 0: printf("ClkOut"); break;
dudmuck 1:1cd0afbed23c 237 case 1: printf("PllLock"); break;
dudmuck 1:1cd0afbed23c 238 case 2:
dudmuck 1:1cd0afbed23c 239 if (fsk.RegPktConfig2.bits.DataModePacket)
dudmuck 1:1cd0afbed23c 240 printf("data");
dudmuck 1:1cd0afbed23c 241 else {
dudmuck 1:1cd0afbed23c 242 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 243 printf("preamble");
dudmuck 1:1cd0afbed23c 244 else
dudmuck 1:1cd0afbed23c 245 printf("rssi");
dudmuck 1:1cd0afbed23c 246 }
dudmuck 1:1cd0afbed23c 247 break;
dudmuck 1:1cd0afbed23c 248 case 3: printf("ModeReady"); break;
dudmuck 1:1cd0afbed23c 249 }
dudmuck 1:1cd0afbed23c 250
dudmuck 2:c6b23a43a9d9 251 printf(" DIO4:");
dudmuck 1:1cd0afbed23c 252 switch (radio.RegDioMapping2.bits.Dio4Mapping) {
dudmuck 1:1cd0afbed23c 253 case 0: printf("temp/eol"); break;
dudmuck 1:1cd0afbed23c 254 case 1: printf("PllLock"); break;
dudmuck 1:1cd0afbed23c 255 case 2: printf("TimeOut"); break;
dudmuck 1:1cd0afbed23c 256 case 3:
dudmuck 1:1cd0afbed23c 257 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 258 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 259 printf("preamble");
dudmuck 1:1cd0afbed23c 260 else
dudmuck 1:1cd0afbed23c 261 printf("rssi");
dudmuck 1:1cd0afbed23c 262 } else
dudmuck 1:1cd0afbed23c 263 printf("ModeReady");
dudmuck 1:1cd0afbed23c 264 break;
dudmuck 1:1cd0afbed23c 265 }
dudmuck 1:1cd0afbed23c 266
dudmuck 1:1cd0afbed23c 267 radio.RegDioMapping1.octet = radio.read_reg(REG_DIOMAPPING1);
dudmuck 1:1cd0afbed23c 268
dudmuck 2:c6b23a43a9d9 269 printf(" DIO3:");
dudmuck 1:1cd0afbed23c 270 switch (radio.RegDioMapping1.bits.Dio3Mapping) {
dudmuck 1:1cd0afbed23c 271 case 0: printf("Timeout"); break;
dudmuck 1:1cd0afbed23c 272 case 1:
dudmuck 1:1cd0afbed23c 273 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 274 printf("preamble");
dudmuck 1:1cd0afbed23c 275 else
dudmuck 1:1cd0afbed23c 276 printf("rssi");
dudmuck 1:1cd0afbed23c 277 break;
dudmuck 1:1cd0afbed23c 278 case 2: printf("?automode_status?"); break;
dudmuck 1:1cd0afbed23c 279 case 3: printf("TempChange/LowBat"); break;
dudmuck 1:1cd0afbed23c 280 }
dudmuck 1:1cd0afbed23c 281
dudmuck 2:c6b23a43a9d9 282 printf(" DIO2:");
dudmuck 1:1cd0afbed23c 283 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 284 switch (radio.RegDioMapping1.bits.Dio2Mapping) {
dudmuck 1:1cd0afbed23c 285 case 0: printf("FifoFull"); break;
dudmuck 1:1cd0afbed23c 286 case 1: printf("RxReady"); break;
dudmuck 1:1cd0afbed23c 287 case 2: printf("FifoFull/rx-timeout"); break;
dudmuck 1:1cd0afbed23c 288 case 3: printf("FifoFull/rx-syncadrs"); break;
dudmuck 1:1cd0afbed23c 289 }
dudmuck 1:1cd0afbed23c 290 } else {
dudmuck 1:1cd0afbed23c 291 printf("Data");
dudmuck 1:1cd0afbed23c 292 }
dudmuck 1:1cd0afbed23c 293
dudmuck 2:c6b23a43a9d9 294 printf(" DIO1:");
dudmuck 1:1cd0afbed23c 295 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 296 switch (radio.RegDioMapping1.bits.Dio1Mapping) {
dudmuck 1:1cd0afbed23c 297 case 0: printf("FifoThresh"); break;
dudmuck 1:1cd0afbed23c 298 case 1: printf("FifoEmpty"); break;
dudmuck 1:1cd0afbed23c 299 case 2: printf("FifoFull"); break;
dudmuck 1:1cd0afbed23c 300 case 3: printf("-3-"); break;
dudmuck 1:1cd0afbed23c 301 }
dudmuck 1:1cd0afbed23c 302 } else {
dudmuck 1:1cd0afbed23c 303 switch (radio.RegDioMapping1.bits.Dio1Mapping) {
dudmuck 1:1cd0afbed23c 304 case 0: printf("Dclk"); break;
dudmuck 1:1cd0afbed23c 305 case 1:
dudmuck 1:1cd0afbed23c 306 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 307 printf("preamble");
dudmuck 1:1cd0afbed23c 308 else
dudmuck 1:1cd0afbed23c 309 printf("rssi");
dudmuck 1:1cd0afbed23c 310 break;
dudmuck 1:1cd0afbed23c 311 case 2: printf("-2-"); break;
dudmuck 1:1cd0afbed23c 312 case 3: printf("-3-"); break;
dudmuck 1:1cd0afbed23c 313 }
dudmuck 1:1cd0afbed23c 314 }
dudmuck 1:1cd0afbed23c 315
dudmuck 2:c6b23a43a9d9 316 printf(" DIO0:");
dudmuck 1:1cd0afbed23c 317 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 318 switch (radio.RegDioMapping1.bits.Dio0Mapping) {
dudmuck 1:1cd0afbed23c 319 case 0: printf("PayloadReady/PacketSent"); break;
dudmuck 1:1cd0afbed23c 320 case 1: printf("CrcOk"); break;
dudmuck 1:1cd0afbed23c 321 case 2: printf("-2-"); break;
dudmuck 1:1cd0afbed23c 322 case 3: printf("TempChange/LowBat"); break;
dudmuck 1:1cd0afbed23c 323 }
dudmuck 1:1cd0afbed23c 324 } else {
dudmuck 1:1cd0afbed23c 325 switch (radio.RegDioMapping1.bits.Dio0Mapping) {
dudmuck 1:1cd0afbed23c 326 case 0: printf("SyncAdrs/TxReady"); break;
dudmuck 1:1cd0afbed23c 327 case 1:
dudmuck 1:1cd0afbed23c 328 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 329 printf("preamble");
dudmuck 1:1cd0afbed23c 330 else
dudmuck 1:1cd0afbed23c 331 printf("rssi");
dudmuck 1:1cd0afbed23c 332 break;
dudmuck 1:1cd0afbed23c 333 case 2: printf("RxReady"); break;
dudmuck 1:1cd0afbed23c 334 case 3: printf("-3-"); break;
dudmuck 1:1cd0afbed23c 335 }
dudmuck 1:1cd0afbed23c 336 }
dudmuck 1:1cd0afbed23c 337 printf("\r\n");
dudmuck 1:1cd0afbed23c 338 }
dudmuck 1:1cd0afbed23c 339
dudmuck 0:be215de91a68 340 void lora_print_status()
dudmuck 0:be215de91a68 341 {
dudmuck 0:be215de91a68 342 uint8_t d;
dudmuck 0:be215de91a68 343
dudmuck 0:be215de91a68 344 if (radio.type == SX1276)
dudmuck 0:be215de91a68 345 printf("\r\nSX1276 ");
dudmuck 0:be215de91a68 346 else if (radio.type == SX1272)
dudmuck 0:be215de91a68 347 printf("\r\nSX1272 ");
dudmuck 0:be215de91a68 348
dudmuck 0:be215de91a68 349 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:be215de91a68 350 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 351 printf("FSK\r\n");
dudmuck 0:be215de91a68 352 return;
dudmuck 0:be215de91a68 353 }
dudmuck 0:be215de91a68 354
dudmuck 1:1cd0afbed23c 355 lora_print_dio();
dudmuck 0:be215de91a68 356 printf("LoRa ");
dudmuck 0:be215de91a68 357
dudmuck 0:be215de91a68 358 // printing LoRa registers at 0x0d -> 0x3f
dudmuck 0:be215de91a68 359
dudmuck 1:1cd0afbed23c 360 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 361 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 0:be215de91a68 362
dudmuck 1:1cd0afbed23c 363 lora_printCodingRate(false); // false: transmitted coding rate
dudmuck 1:1cd0afbed23c 364 lora_printHeaderMode();
dudmuck 1:1cd0afbed23c 365 lora_printBw();
dudmuck 1:1cd0afbed23c 366 lora_printSf();
dudmuck 1:1cd0afbed23c 367 lora_printRxPayloadCrcOn();
dudmuck 0:be215de91a68 368 // RegModemStat
dudmuck 0:be215de91a68 369 printf("ModemStat:0x%02x\r\n", radio.read_reg(REG_LR_MODEMSTAT));
dudmuck 0:be215de91a68 370
dudmuck 0:be215de91a68 371 // fifo ptrs:
dudmuck 1:1cd0afbed23c 372 lora.RegPayloadLength = radio.read_reg(REG_LR_PAYLOADLENGTH);
dudmuck 1:1cd0afbed23c 373 lora.RegRxMaxPayloadLength = radio.read_reg(REG_LR_RX_MAX_PAYLOADLENGTH);
dudmuck 0:be215de91a68 374 printf("fifoptr=0x%02x txbase=0x%02x rxbase=0x%02x payloadLength=0x%02x maxlen=0x%02x",
dudmuck 0:be215de91a68 375 radio.read_reg(REG_LR_FIFOADDRPTR),
dudmuck 0:be215de91a68 376 radio.read_reg(REG_LR_FIFOTXBASEADDR),
dudmuck 0:be215de91a68 377 radio.read_reg(REG_LR_FIFORXBASEADDR),
dudmuck 1:1cd0afbed23c 378 lora.RegPayloadLength,
dudmuck 1:1cd0afbed23c 379 lora.RegRxMaxPayloadLength
dudmuck 0:be215de91a68 380 );
dudmuck 0:be215de91a68 381
dudmuck 1:1cd0afbed23c 382 lora.RegIrqFlags.octet = radio.read_reg(REG_LR_IRQFLAGS);
dudmuck 0:be215de91a68 383 printLoraIrqs_(false);
dudmuck 0:be215de91a68 384
dudmuck 1:1cd0afbed23c 385 lora.RegHopPeriod = radio.read_reg(REG_LR_HOPPERIOD);
dudmuck 1:1cd0afbed23c 386 if (lora.RegHopPeriod != 0) {
dudmuck 1:1cd0afbed23c 387 printf("\r\nHopPeriod:0x%02x\r\n", lora.RegHopPeriod);
dudmuck 0:be215de91a68 388 }
dudmuck 0:be215de91a68 389
dudmuck 0:be215de91a68 390 printf("SymbTimeout:0x%03x ", radio.read_u16(REG_LR_MODEMCONFIG2) & 0x3ff);
dudmuck 0:be215de91a68 391
dudmuck 1:1cd0afbed23c 392 lora.RegPreamble = radio.read_u16(REG_LR_PREAMBLEMSB);
dudmuck 4:7a9007dfc0e5 393 printf("PreambleLength:%d ", lora.RegPreamble);
dudmuck 0:be215de91a68 394
dudmuck 0:be215de91a68 395 if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER || radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER_SINGLE) {
dudmuck 0:be215de91a68 396 d = radio.read_reg(REG_LR_RSSIVALUE);
dudmuck 0:be215de91a68 397 printf("rssi:%ddBm ", d-120);
dudmuck 0:be215de91a68 398 }
dudmuck 0:be215de91a68 399
dudmuck 1:1cd0afbed23c 400 lora_printTxContinuousMode();
dudmuck 0:be215de91a68 401
dudmuck 0:be215de91a68 402 printf("\r\n");
dudmuck 1:1cd0afbed23c 403 lora_printAgcAutoOn();
dudmuck 0:be215de91a68 404 if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 405 printf(" LowDataRateOptimize:%d\r\n", lora.RegModemConfig.sx1272bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 406 }
dudmuck 0:be215de91a68 407
dudmuck 0:be215de91a68 408 printf("\r\nHeaderCount:%d PacketCount:%d, ",
dudmuck 0:be215de91a68 409 radio.read_u16(REG_LR_RXHEADERCNTVALUE_MSB), radio.read_u16(REG_LR_RXPACKETCNTVALUE_MSB));
dudmuck 0:be215de91a68 410
dudmuck 0:be215de91a68 411 printf("Lora detection threshold:%02x\r\n", radio.read_reg(REG_LR_DETECTION_THRESHOLD));
dudmuck 1:1cd0afbed23c 412 lora.RegTest31.octet = radio.read_reg(REG_LR_TEST31);
dudmuck 1:1cd0afbed23c 413 printf("detect_trig_same_peaks_nb:%d\r\n", lora.RegTest31.bits.detect_trig_same_peaks_nb);
dudmuck 0:be215de91a68 414
dudmuck 0:be215de91a68 415 if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 416 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 417 printf("LowDataRateOptimize:%d\r\n", lora.RegModemConfig.sx1272bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 418 } else if (radio.type == SX1276) {
dudmuck 1:1cd0afbed23c 419 lora.RegModemConfig3.octet = radio.read_reg(REG_LR_MODEMCONFIG3);
dudmuck 1:1cd0afbed23c 420 printf("LowDataRateOptimize:%d\r\n", lora.RegModemConfig3.sx1276bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 421 }
dudmuck 0:be215de91a68 422
dudmuck 0:be215de91a68 423 printf("\r\n");
dudmuck 0:be215de91a68 424 //printf("A %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 0:be215de91a68 425 }
dudmuck 0:be215de91a68 426
dudmuck 1:1cd0afbed23c 427 uint16_t
dudmuck 1:1cd0afbed23c 428 fsk_get_PayloadLength(void)
dudmuck 1:1cd0afbed23c 429 {
dudmuck 1:1cd0afbed23c 430 fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
dudmuck 1:1cd0afbed23c 431
dudmuck 1:1cd0afbed23c 432 return fsk.RegPktConfig2.bits.PayloadLength;
dudmuck 1:1cd0afbed23c 433 }
dudmuck 1:1cd0afbed23c 434
dudmuck 1:1cd0afbed23c 435 void fsk_printAddressFiltering()
dudmuck 1:1cd0afbed23c 436 {
dudmuck 1:1cd0afbed23c 437 uint8_t FSKRegNodeAdrs, FSKRegBroadcastAdrs;
dudmuck 1:1cd0afbed23c 438
dudmuck 1:1cd0afbed23c 439 printf(" AddressFiltering:");
dudmuck 1:1cd0afbed23c 440 switch (fsk.RegPktConfig1.bits.AddressFiltering) {
dudmuck 1:1cd0afbed23c 441 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 442 case 1: // NodeAddress
dudmuck 1:1cd0afbed23c 443 FSKRegNodeAdrs = radio.read_reg(REG_FSK_NODEADRS);
dudmuck 1:1cd0afbed23c 444 printf("NodeAdrs:%02x\n", FSKRegNodeAdrs);
dudmuck 1:1cd0afbed23c 445 break;
dudmuck 1:1cd0afbed23c 446 case 2: // NodeAddress & BroadcastAddress
dudmuck 1:1cd0afbed23c 447 FSKRegNodeAdrs = radio.read_reg(REG_FSK_NODEADRS);
dudmuck 1:1cd0afbed23c 448 printf("NodeAdrs:%02x ", FSKRegNodeAdrs);
dudmuck 1:1cd0afbed23c 449 FSKRegBroadcastAdrs = radio.read_reg(REG_FSK_BROADCASTADRS);
dudmuck 1:1cd0afbed23c 450 printf("BroadcastAdrs:%02x\n", FSKRegBroadcastAdrs );
dudmuck 1:1cd0afbed23c 451 break;
dudmuck 1:1cd0afbed23c 452 default:
dudmuck 1:1cd0afbed23c 453 printf("%d", fsk.RegPktConfig1.bits.AddressFiltering);
dudmuck 1:1cd0afbed23c 454 break;
dudmuck 1:1cd0afbed23c 455 }
dudmuck 1:1cd0afbed23c 456 }
dudmuck 1:1cd0afbed23c 457
dudmuck 1:1cd0afbed23c 458 void fsk_print_IrqFlags2()
dudmuck 1:1cd0afbed23c 459 {
dudmuck 2:c6b23a43a9d9 460 RegIrqFlags2_t RegIrqFlags2;
dudmuck 1:1cd0afbed23c 461
dudmuck 1:1cd0afbed23c 462 printf("IrqFlags2: ");
dudmuck 2:c6b23a43a9d9 463 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 464 if (RegIrqFlags2.bits.FifoFull)
dudmuck 1:1cd0afbed23c 465 printf("FifoFull ");
dudmuck 2:c6b23a43a9d9 466 if (RegIrqFlags2.bits.FifoEmpty)
dudmuck 1:1cd0afbed23c 467 printf("FifoEmpty ");
dudmuck 2:c6b23a43a9d9 468 if (RegIrqFlags2.bits.FifoLevel)
dudmuck 1:1cd0afbed23c 469 printf("FifoLevel ");
dudmuck 2:c6b23a43a9d9 470 if (RegIrqFlags2.bits.FifoOverrun)
dudmuck 1:1cd0afbed23c 471 printf("FifoOverrun ");
dudmuck 2:c6b23a43a9d9 472 if (RegIrqFlags2.bits.PacketSent)
dudmuck 1:1cd0afbed23c 473 printf("PacketSent ");
dudmuck 2:c6b23a43a9d9 474 if (RegIrqFlags2.bits.PayloadReady)
dudmuck 1:1cd0afbed23c 475 printf("PayloadReady ");
dudmuck 2:c6b23a43a9d9 476 if (RegIrqFlags2.bits.CrcOk)
dudmuck 1:1cd0afbed23c 477 printf("CrcOk ");
dudmuck 2:c6b23a43a9d9 478 if (RegIrqFlags2.bits.LowBat)
dudmuck 1:1cd0afbed23c 479 printf("LowBat ");
dudmuck 2:c6b23a43a9d9 480 printf("\r\n");
dudmuck 1:1cd0afbed23c 481 }
dudmuck 1:1cd0afbed23c 482
dudmuck 1:1cd0afbed23c 483 void
dudmuck 1:1cd0afbed23c 484 fsk_print_status()
dudmuck 1:1cd0afbed23c 485 {
dudmuck 1:1cd0afbed23c 486 //uint16_t s;
dudmuck 2:c6b23a43a9d9 487 RegIrqFlags1_t RegIrqFlags1;
dudmuck 1:1cd0afbed23c 488
dudmuck 1:1cd0afbed23c 489 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 490 printf("LoRa\r\n");
dudmuck 1:1cd0afbed23c 491 return;
dudmuck 1:1cd0afbed23c 492 }
dudmuck 1:1cd0afbed23c 493
dudmuck 1:1cd0afbed23c 494 if (radio.RegOpMode.bits.ModulationType == 0) {
dudmuck 1:1cd0afbed23c 495 printf("FSK ");
dudmuck 1:1cd0afbed23c 496 switch (radio.RegOpMode.bits.ModulationShaping) {
dudmuck 1:1cd0afbed23c 497 case 1: printf("BT1.0 "); break;
dudmuck 1:1cd0afbed23c 498 case 2: printf("BT0.5 "); break;
dudmuck 1:1cd0afbed23c 499 case 3: printf("BT0.3 "); break;
dudmuck 1:1cd0afbed23c 500 }
dudmuck 1:1cd0afbed23c 501 } else if (radio.RegOpMode.bits.ModulationType == 1) {
dudmuck 1:1cd0afbed23c 502 printf("OOK ");
dudmuck 1:1cd0afbed23c 503 }
dudmuck 1:1cd0afbed23c 504
dudmuck 3:ab386fa756cc 505 printf("%dbps fdev:%dHz\r\n", fsk.get_bitrate(), fsk.get_tx_fdev_hz());
dudmuck 1:1cd0afbed23c 506
dudmuck 1:1cd0afbed23c 507 fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
dudmuck 1:1cd0afbed23c 508
dudmuck 1:1cd0afbed23c 509 fsk_print_dio();
dudmuck 1:1cd0afbed23c 510
dudmuck 1:1cd0afbed23c 511 printf("rxbw:%dHz ", fsk.get_rx_bw_hz(REG_FSK_RXBW));
dudmuck 1:1cd0afbed23c 512 printf("afcbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_AFCBW));
dudmuck 1:1cd0afbed23c 513
dudmuck 1:1cd0afbed23c 514 fsk.RegRssiConfig.octet = radio.read_reg(REG_FSK_RSSICONFIG);
dudmuck 1:1cd0afbed23c 515 printf("RssiOffset:%ddB smoothing:%dsamples\r\n", fsk.RegRssiConfig.bits.RssiOffset, 1 << (fsk.RegRssiConfig.bits.RssiSmoothing+1));
dudmuck 1:1cd0afbed23c 516
dudmuck 1:1cd0afbed23c 517
dudmuck 1:1cd0afbed23c 518 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 1:1cd0afbed23c 519
dudmuck 1:1cd0afbed23c 520 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 521 uint16_t len;
dudmuck 1:1cd0afbed23c 522 /* packet mode */
dudmuck 1:1cd0afbed23c 523 len = fsk_get_PayloadLength();
dudmuck 1:1cd0afbed23c 524 printf("packet RegPayloadLength:0x%03x ", len);
dudmuck 1:1cd0afbed23c 525
dudmuck 1:1cd0afbed23c 526 if (fsk.RegPktConfig2.bits.BeaconOn)
dudmuck 1:1cd0afbed23c 527 printf("BeaconOn ");
dudmuck 1:1cd0afbed23c 528
dudmuck 1:1cd0afbed23c 529 fsk.RegFifoThreshold.octet = radio.read_reg(REG_FSK_FIFOTHRESH);
dudmuck 1:1cd0afbed23c 530 printf("FifoThreshold:%d TxStartCondition:", fsk.RegFifoThreshold.bits.FifoThreshold);
dudmuck 1:1cd0afbed23c 531 if (fsk.RegFifoThreshold.bits.TxStartCondition)
dudmuck 1:1cd0afbed23c 532 printf("!FifoEmpty");
dudmuck 1:1cd0afbed23c 533 else
dudmuck 1:1cd0afbed23c 534 printf("FifoLevel");
dudmuck 1:1cd0afbed23c 535
dudmuck 1:1cd0afbed23c 536 printf("\r\nAutoRestartRxMode:");
dudmuck 1:1cd0afbed23c 537 switch (fsk.RegSyncConfig.bits.AutoRestartRxMode) {
dudmuck 1:1cd0afbed23c 538 case 0: printf("off "); break;
dudmuck 1:1cd0afbed23c 539 case 1: printf("no-pll-wait "); break;
dudmuck 1:1cd0afbed23c 540 case 2: printf("pll-wait "); break;
dudmuck 1:1cd0afbed23c 541 case 3: printf("3 "); break;
dudmuck 1:1cd0afbed23c 542 }
dudmuck 1:1cd0afbed23c 543 //...todo
dudmuck 1:1cd0afbed23c 544
dudmuck 1:1cd0afbed23c 545 printf("PreambleSize:%d ", radio.read_u16(REG_FSK_PREAMBLEMSB));
dudmuck 1:1cd0afbed23c 546
dudmuck 1:1cd0afbed23c 547 fsk.RegOokPeak.octet = radio.read_reg(REG_FSK_OOKPEAK);
dudmuck 1:1cd0afbed23c 548 if (fsk.RegOokPeak.bits.barker_en)
dudmuck 1:1cd0afbed23c 549 printf("barker ");
dudmuck 1:1cd0afbed23c 550 if (!fsk.RegOokPeak.bits.BitSyncOn)
dudmuck 1:1cd0afbed23c 551 printf("BitSyncOff ");
dudmuck 1:1cd0afbed23c 552 //...todo
dudmuck 1:1cd0afbed23c 553
dudmuck 1:1cd0afbed23c 554 fsk.RegPktConfig1.octet = radio.read_reg(REG_FSK_PACKETCONFIG1);
dudmuck 1:1cd0afbed23c 555 if (fsk.RegPktConfig1.bits.PacketFormatVariable)
dudmuck 1:1cd0afbed23c 556 printf("variable");
dudmuck 1:1cd0afbed23c 557 else
dudmuck 1:1cd0afbed23c 558 printf("fixed");
dudmuck 1:1cd0afbed23c 559 printf("-length\r\ncrc");
dudmuck 1:1cd0afbed23c 560 if (fsk.RegPktConfig1.bits.CrcOn) {
dudmuck 1:1cd0afbed23c 561 printf("On");
dudmuck 1:1cd0afbed23c 562 } else
dudmuck 1:1cd0afbed23c 563 printf("Off");
dudmuck 1:1cd0afbed23c 564 printf(" crctype:");
dudmuck 1:1cd0afbed23c 565 if (fsk.RegPktConfig1.bits.CrCWhiteningType)
dudmuck 1:1cd0afbed23c 566 printf("IBM");
dudmuck 1:1cd0afbed23c 567 else
dudmuck 1:1cd0afbed23c 568 printf("CCITT");
dudmuck 1:1cd0afbed23c 569 printf(" dcFree:");
dudmuck 1:1cd0afbed23c 570 switch (fsk.RegPktConfig1.bits.DcFree) {
dudmuck 1:1cd0afbed23c 571 case 0: printf("none "); break;
dudmuck 1:1cd0afbed23c 572 case 1: printf("Manchester "); break;
dudmuck 1:1cd0afbed23c 573 case 2: printf("Whitening "); break;
dudmuck 1:1cd0afbed23c 574 case 3: printf("reserved "); break;
dudmuck 1:1cd0afbed23c 575 }
dudmuck 1:1cd0afbed23c 576 fsk_printAddressFiltering();
dudmuck 1:1cd0afbed23c 577
dudmuck 1:1cd0afbed23c 578 printf("\r\n");
dudmuck 1:1cd0afbed23c 579 fsk_print_IrqFlags2();
dudmuck 1:1cd0afbed23c 580 } else {
dudmuck 1:1cd0afbed23c 581 /* continuous mode */
dudmuck 1:1cd0afbed23c 582 printf("continuous ");
dudmuck 1:1cd0afbed23c 583 }
dudmuck 1:1cd0afbed23c 584
dudmuck 1:1cd0afbed23c 585 fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
dudmuck 1:1cd0afbed23c 586 printf("PreambleDetect:");
dudmuck 1:1cd0afbed23c 587 if (fsk.RegPreambleDetect.bits.PreambleDetectorOn) {
dudmuck 1:1cd0afbed23c 588 printf("size=%d,tol=%d ",
dudmuck 1:1cd0afbed23c 589 fsk.RegPreambleDetect.bits.PreambleDetectorSize,
dudmuck 1:1cd0afbed23c 590 fsk.RegPreambleDetect.bits.PreambleDetectorTol);
dudmuck 1:1cd0afbed23c 591 } else
dudmuck 1:1cd0afbed23c 592 printf("Off ");
dudmuck 1:1cd0afbed23c 593
dudmuck 1:1cd0afbed23c 594 printf(" syncsize:%d ", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 1:1cd0afbed23c 595 printf(" : %02x ", radio.read_reg(REG_FSK_SYNCVALUE1));
dudmuck 1:1cd0afbed23c 596 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE2));
dudmuck 1:1cd0afbed23c 597 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE3));
dudmuck 1:1cd0afbed23c 598 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE4));
dudmuck 1:1cd0afbed23c 599 printf("\r\n"); // end sync config
dudmuck 1:1cd0afbed23c 600
dudmuck 1:1cd0afbed23c 601 fsk.RegAfcFei.octet = radio.read_reg(REG_FSK_AFCFEI);
dudmuck 1:1cd0afbed23c 602 printf("afcAutoClear:");
dudmuck 1:1cd0afbed23c 603 if (fsk.RegAfcFei.bits.AfcAutoClearOn)
dudmuck 1:1cd0afbed23c 604 printf("On");
dudmuck 1:1cd0afbed23c 605 else
dudmuck 1:1cd0afbed23c 606 printf("OFF");
dudmuck 1:1cd0afbed23c 607 printf(" afc:%dHz ", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_AFCMSB)));
dudmuck 1:1cd0afbed23c 608
dudmuck 1:1cd0afbed23c 609 printf("fei:%dHz\r\n", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_FEIMSB)));
dudmuck 1:1cd0afbed23c 610
dudmuck 1:1cd0afbed23c 611 fsk.RegRxConfig.octet = radio.read_reg(REG_FSK_RXCONFIG);
dudmuck 1:1cd0afbed23c 612 printf("RxTrigger:");
dudmuck 1:1cd0afbed23c 613 switch (fsk.RegRxConfig.bits.RxTrigger) {
dudmuck 1:1cd0afbed23c 614 case 0: printf("none "); break;
dudmuck 1:1cd0afbed23c 615 case 1: printf("rssi "); break;
dudmuck 1:1cd0afbed23c 616 case 6: printf("preamble "); break;
dudmuck 1:1cd0afbed23c 617 case 7: printf("both "); break;
dudmuck 1:1cd0afbed23c 618 default: printf("-%d- ", fsk.RegRxConfig.bits.RxTrigger); break;
dudmuck 1:1cd0afbed23c 619 }
dudmuck 1:1cd0afbed23c 620 printf("AfcAuto:");
dudmuck 1:1cd0afbed23c 621 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 1:1cd0afbed23c 622 printf("On ");
dudmuck 1:1cd0afbed23c 623 else
dudmuck 1:1cd0afbed23c 624 printf("OFF ");
dudmuck 1:1cd0afbed23c 625 if (!fsk.RegRxConfig.bits.AgcAutoOn) {
dudmuck 1:1cd0afbed23c 626 radio.RegLna.octet = radio.read_reg(REG_LNA);
dudmuck 1:1cd0afbed23c 627 printf("AgcAutoOff:G%d ", radio.RegLna.bits.LnaGain);
dudmuck 1:1cd0afbed23c 628 }
dudmuck 1:1cd0afbed23c 629
dudmuck 1:1cd0afbed23c 630 fsk.RegTimerResol.octet = radio.read_reg(REG_FSK_TIMERRESOL);
dudmuck 1:1cd0afbed23c 631 if (fsk.RegTimerResol.bits.hlm_started)
dudmuck 1:1cd0afbed23c 632 printf("hlm_started ");
dudmuck 1:1cd0afbed23c 633 else
dudmuck 1:1cd0afbed23c 634 printf("hlm_stopped ");
dudmuck 1:1cd0afbed23c 635
dudmuck 1:1cd0afbed23c 636 fsk.RegRssiThresh = radio.read_reg(REG_FSK_RSSITHRESH);
dudmuck 1:1cd0afbed23c 637 printf("rssiThreshold:-%.1f@%02x ", fsk.RegRssiThresh / 2.0, REG_FSK_RSSITHRESH);
dudmuck 1:1cd0afbed23c 638
dudmuck 1:1cd0afbed23c 639 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 1:1cd0afbed23c 640 if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER ||
dudmuck 1:1cd0afbed23c 641 radio.RegOpMode.bits.Mode == RF_OPMODE_SYNTHESIZER_RX)
dudmuck 1:1cd0afbed23c 642 {
dudmuck 1:1cd0afbed23c 643 printf("rssi:-%.1f ", radio.read_reg(REG_FSK_RSSIVALUE) / 2.0);
dudmuck 1:1cd0afbed23c 644 }
dudmuck 1:1cd0afbed23c 645
dudmuck 1:1cd0afbed23c 646 fsk.RegSeqConfig1.octet = radio.read_reg(REG_FSK_SEQCONFIG1);
dudmuck 1:1cd0afbed23c 647 printf("\r\nsequencer: ");
dudmuck 1:1cd0afbed23c 648 printf("FromStart:");
dudmuck 1:1cd0afbed23c 649 switch (fsk.RegSeqConfig1.bits.FromStart) {
dudmuck 1:1cd0afbed23c 650 case 0:
dudmuck 1:1cd0afbed23c 651 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 652 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 653 printf("idle");
dudmuck 1:1cd0afbed23c 654 else
dudmuck 1:1cd0afbed23c 655 printf("sequencerOff");
dudmuck 1:1cd0afbed23c 656 break;
dudmuck 1:1cd0afbed23c 657 case 1: printf("rx"); break;
dudmuck 1:1cd0afbed23c 658 case 2: printf("tx"); break;
dudmuck 1:1cd0afbed23c 659 case 3: printf("tx on fifolevel"); break;
dudmuck 1:1cd0afbed23c 660 }
dudmuck 1:1cd0afbed23c 661 printf(" lowPowerSelection:");
dudmuck 1:1cd0afbed23c 662 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 663 printf("idle");
dudmuck 1:1cd0afbed23c 664 else
dudmuck 1:1cd0afbed23c 665 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 666 if (fsk.RegSeqConfig1.bits.FromStart != 0 &&
dudmuck 1:1cd0afbed23c 667 fsk.RegSeqConfig1.bits.LowPowerSelection != 0)
dudmuck 1:1cd0afbed23c 668 { // if sequencer enabled:
dudmuck 1:1cd0afbed23c 669 printf("\r\nsequencer: IdleMode:");
dudmuck 1:1cd0afbed23c 670 if (fsk.RegSeqConfig1.bits.IdleMode)
dudmuck 1:1cd0afbed23c 671 printf("Sleep");
dudmuck 1:1cd0afbed23c 672 else
dudmuck 1:1cd0afbed23c 673 printf("standby");
dudmuck 1:1cd0afbed23c 674 printf("\r\nsequencer: FromIdle to:");
dudmuck 1:1cd0afbed23c 675 if (fsk.RegSeqConfig1.bits.FromIdle)
dudmuck 1:1cd0afbed23c 676 printf("rx");
dudmuck 1:1cd0afbed23c 677 else
dudmuck 1:1cd0afbed23c 678 printf("tx");
dudmuck 1:1cd0afbed23c 679 printf("\r\nsequencer: FromTransmit to:");
dudmuck 1:1cd0afbed23c 680 if (fsk.RegSeqConfig1.bits.FromTransmit)
dudmuck 1:1cd0afbed23c 681 printf("rx-on-PacketSent");
dudmuck 1:1cd0afbed23c 682 else {
dudmuck 1:1cd0afbed23c 683 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 684 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 685 printf("idle");
dudmuck 1:1cd0afbed23c 686 else
dudmuck 1:1cd0afbed23c 687 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 688 printf("-on-PacketSent");
dudmuck 1:1cd0afbed23c 689 }
dudmuck 1:1cd0afbed23c 690 fsk.RegSeqConfig2.octet = radio.read_reg(REG_FSK_SEQCONFIG2);
dudmuck 1:1cd0afbed23c 691 printf("\r\nsequencer: FromReceive:");
dudmuck 1:1cd0afbed23c 692 switch (fsk.RegSeqConfig2.bits.FromReceive) {
dudmuck 1:1cd0afbed23c 693 case 1: printf("PacketRecevied on PayloadReady"); break;
dudmuck 1:1cd0afbed23c 694 case 2:
dudmuck 1:1cd0afbed23c 695 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 696 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 697 printf("idle");
dudmuck 1:1cd0afbed23c 698 else
dudmuck 1:1cd0afbed23c 699 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 700 printf("-on-payloadReady");
dudmuck 1:1cd0afbed23c 701 break;
dudmuck 1:1cd0afbed23c 702 case 3: printf("PacketRecevied-on-CrcOk"); break;
dudmuck 1:1cd0afbed23c 703 case 4: printf("SequencerOff-on-Rssi"); break;
dudmuck 1:1cd0afbed23c 704 case 5: printf("SequencerOff-on-SyncAddress"); break;
dudmuck 1:1cd0afbed23c 705 case 6: printf("SequencerOff-PreambleDetect"); break;
dudmuck 1:1cd0afbed23c 706 default: printf("-%d-", fsk.RegSeqConfig2.bits.FromReceive); break;
dudmuck 1:1cd0afbed23c 707 }
dudmuck 1:1cd0afbed23c 708 printf("\r\nsequencer: FromRxTimeout:");
dudmuck 1:1cd0afbed23c 709 switch (fsk.RegSeqConfig2.bits.FromRxTimeout) {
dudmuck 1:1cd0afbed23c 710 case 0: printf("rx"); break;
dudmuck 1:1cd0afbed23c 711 case 1: printf("tx"); break;
dudmuck 1:1cd0afbed23c 712 case 2:
dudmuck 1:1cd0afbed23c 713 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 714 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 715 printf("idle");
dudmuck 1:1cd0afbed23c 716 else
dudmuck 1:1cd0afbed23c 717 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 718 break;
dudmuck 1:1cd0afbed23c 719 case 3: printf("SequencerOff"); break;
dudmuck 1:1cd0afbed23c 720 }
dudmuck 1:1cd0afbed23c 721 printf("\r\nsequencer: FromPacketReceived to:");
dudmuck 1:1cd0afbed23c 722 switch (fsk.RegSeqConfig2.bits.FromPacketReceived) {
dudmuck 1:1cd0afbed23c 723 case 0: printf("SequencerOff"); break;
dudmuck 1:1cd0afbed23c 724 case 1: printf("tx on FifoEmpty"); break;
dudmuck 1:1cd0afbed23c 725 case 2:
dudmuck 1:1cd0afbed23c 726 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 727 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 728 printf("idle");
dudmuck 1:1cd0afbed23c 729 else
dudmuck 1:1cd0afbed23c 730 printf("sequencerOff");
dudmuck 1:1cd0afbed23c 731 break;
dudmuck 1:1cd0afbed23c 732 case 3: printf("rx via fs"); break;
dudmuck 1:1cd0afbed23c 733 case 4: printf("rx"); break;
dudmuck 1:1cd0afbed23c 734 }
dudmuck 1:1cd0afbed23c 735
dudmuck 1:1cd0afbed23c 736 fsk.RegTimerResol.octet = radio.read_reg(REG_FSK_TIMERRESOL);
dudmuck 1:1cd0afbed23c 737 printf("\r\nsequencer: timer1:");
dudmuck 1:1cd0afbed23c 738 switch (fsk.RegTimerResol.bits.timer1_resol) {
dudmuck 1:1cd0afbed23c 739 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 740 case 1: printf("%dus", radio.read_reg(REG_FSK_TIMER1COEF) * 64); break;
dudmuck 1:1cd0afbed23c 741 case 2: printf("%.1fms", radio.read_reg(REG_FSK_TIMER1COEF) * 4.1); break;
dudmuck 1:1cd0afbed23c 742 case 3: printf("%.1fs", radio.read_reg(REG_FSK_TIMER1COEF) * 0.262); break;
dudmuck 1:1cd0afbed23c 743 }
dudmuck 1:1cd0afbed23c 744
dudmuck 1:1cd0afbed23c 745 printf(" timer2:");
dudmuck 1:1cd0afbed23c 746 switch (fsk.RegTimerResol.bits.timer2_resol) {
dudmuck 1:1cd0afbed23c 747 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 748 case 1: printf("%dus", radio.read_reg(REG_FSK_TIMER2COEF) * 64); break;
dudmuck 1:1cd0afbed23c 749 case 2: printf("%.1fms", radio.read_reg(REG_FSK_TIMER2COEF) * 4.1); break;
dudmuck 1:1cd0afbed23c 750 case 3: printf("%.1fs", radio.read_reg(REG_FSK_TIMER2COEF) * 0.262); break;
dudmuck 1:1cd0afbed23c 751 }
dudmuck 1:1cd0afbed23c 752 } // ..if sequencer enabled
dudmuck 1:1cd0afbed23c 753
dudmuck 1:1cd0afbed23c 754 printf("\r\nIrqFlags1:");
dudmuck 2:c6b23a43a9d9 755 RegIrqFlags1.octet = radio.read_reg(REG_FSK_IRQFLAGS1);
dudmuck 2:c6b23a43a9d9 756 if (RegIrqFlags1.bits.ModeReady)
dudmuck 1:1cd0afbed23c 757 printf("ModeReady ");
dudmuck 2:c6b23a43a9d9 758 if (RegIrqFlags1.bits.RxReady)
dudmuck 1:1cd0afbed23c 759 printf("RxReady ");
dudmuck 2:c6b23a43a9d9 760 if (RegIrqFlags1.bits.TxReady)
dudmuck 1:1cd0afbed23c 761 printf("TxReady ");
dudmuck 2:c6b23a43a9d9 762 if (RegIrqFlags1.bits.PllLock)
dudmuck 1:1cd0afbed23c 763 printf("PllLock ");
dudmuck 2:c6b23a43a9d9 764 if (RegIrqFlags1.bits.Rssi)
dudmuck 1:1cd0afbed23c 765 printf("Rssi ");
dudmuck 2:c6b23a43a9d9 766 if (RegIrqFlags1.bits.Timeout)
dudmuck 1:1cd0afbed23c 767 printf("Timeout ");
dudmuck 2:c6b23a43a9d9 768 if (RegIrqFlags1.bits.PreambleDetect)
dudmuck 1:1cd0afbed23c 769 printf("PreambleDetect ");
dudmuck 2:c6b23a43a9d9 770 if (RegIrqFlags1.bits.SyncAddressMatch)
dudmuck 1:1cd0afbed23c 771 printf("SyncAddressMatch ");
dudmuck 1:1cd0afbed23c 772
dudmuck 1:1cd0afbed23c 773 printf("\r\n");
dudmuck 1:1cd0afbed23c 774
dudmuck 1:1cd0afbed23c 775 /* TODO if (!SX1272FSK->RegPktConfig1.bits.PacketFormatVariable) { // if fixed-length packet format:
dudmuck 1:1cd0afbed23c 776 s = fsk_get_PayloadLength();
dudmuck 1:1cd0afbed23c 777 if (s > FSK_LARGE_PKT_THRESHOLD)
dudmuck 1:1cd0afbed23c 778 flags.fifo_flow_ctl = 1;
dudmuck 1:1cd0afbed23c 779 else
dudmuck 1:1cd0afbed23c 780 flags.fifo_flow_ctl = 0;
dudmuck 1:1cd0afbed23c 781 }*/
dudmuck 1:1cd0afbed23c 782
dudmuck 1:1cd0afbed23c 783 fsk.RegImageCal.octet = radio.read_reg(REG_FSK_IMAGECAL);
dudmuck 1:1cd0afbed23c 784 if (fsk.RegImageCal.bits.TempMonitorOff) {
dudmuck 1:1cd0afbed23c 785 printf("TempMonitorOff[\r0m\n");
dudmuck 1:1cd0afbed23c 786 } else {
dudmuck 1:1cd0afbed23c 787 printf("TempThreshold:");
dudmuck 1:1cd0afbed23c 788 switch (fsk.RegImageCal.bits.TempThreshold) {
dudmuck 1:1cd0afbed23c 789 case 0: printf("5C"); break;
dudmuck 1:1cd0afbed23c 790 case 1: printf("10C"); break;
dudmuck 1:1cd0afbed23c 791 case 2: printf("15C"); break;
dudmuck 1:1cd0afbed23c 792 case 3: printf("20C"); break;
dudmuck 1:1cd0afbed23c 793 }
dudmuck 1:1cd0afbed23c 794 printf("\r\n");
dudmuck 1:1cd0afbed23c 795 }
dudmuck 1:1cd0afbed23c 796 if (fsk.RegImageCal.bits.ImageCalRunning)
dudmuck 1:1cd0afbed23c 797 printf("ImageCalRunning[\r0m\n");
dudmuck 1:1cd0afbed23c 798
dudmuck 1:1cd0afbed23c 799 /* printf("flags.fifo_flow_ctl:%d pktidx:%d rx_pktlen:%d", flags.fifo_flow_ctl, pktidx, rx_pktlen);
dudmuck 1:1cd0afbed23c 800 printf("\n");
dudmuck 1:1cd0afbed23c 801
dudmuck 1:1cd0afbed23c 802 //printf("DIO0_PIN:%d\n", digitalRead(DIO0_PIN));
dudmuck 1:1cd0afbed23c 803 printf("pkt_buf_len=%d remaining=%d\n", pk*/
dudmuck 1:1cd0afbed23c 804 }
dudmuck 1:1cd0afbed23c 805
dudmuck 0:be215de91a68 806 void printOpMode()
dudmuck 0:be215de91a68 807 {
dudmuck 0:be215de91a68 808 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:be215de91a68 809 switch (radio.RegOpMode.bits.Mode) {
dudmuck 0:be215de91a68 810 case RF_OPMODE_SLEEP: printf("sleep"); break;
dudmuck 0:be215de91a68 811 case RF_OPMODE_STANDBY: printf("stby"); break;
dudmuck 0:be215de91a68 812 case RF_OPMODE_SYNTHESIZER_TX: printf("fstx"); break;
dudmuck 0:be215de91a68 813 case RF_OPMODE_TRANSMITTER: printf("tx"); break;
dudmuck 0:be215de91a68 814 case RF_OPMODE_SYNTHESIZER_RX: printf("fsrx"); break;
dudmuck 0:be215de91a68 815 case RF_OPMODE_RECEIVER: printf("rx"); break;
dudmuck 0:be215de91a68 816 case 6:
dudmuck 0:be215de91a68 817 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:be215de91a68 818 printf("rxs");
dudmuck 0:be215de91a68 819 else
dudmuck 0:be215de91a68 820 printf("-6-");
dudmuck 0:be215de91a68 821 break; // todo: different lora/fsk
dudmuck 0:be215de91a68 822 case 7:
dudmuck 0:be215de91a68 823 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:be215de91a68 824 printf("cad");
dudmuck 0:be215de91a68 825 else
dudmuck 0:be215de91a68 826 printf("-7-");
dudmuck 0:be215de91a68 827 break; // todo: different lora/fsk
dudmuck 0:be215de91a68 828 }
dudmuck 0:be215de91a68 829 }
dudmuck 0:be215de91a68 830
dudmuck 0:be215de91a68 831 void
dudmuck 0:be215de91a68 832 printPa()
dudmuck 0:be215de91a68 833 {
dudmuck 0:be215de91a68 834 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:be215de91a68 835 if (radio.RegPaConfig.bits.PaSelect) {
dudmuck 0:be215de91a68 836 float output_dBm = 17 - (15-radio.RegPaConfig.bits.OutputPower);
dudmuck 0:be215de91a68 837 printf(" PABOOST OutputPower=%.1fdBm", output_dBm);
dudmuck 0:be215de91a68 838 } else {
dudmuck 0:be215de91a68 839 float pmax = (0.6*radio.RegPaConfig.bits.MaxPower) + 10.8;
dudmuck 0:be215de91a68 840 float output_dBm = pmax - (15-radio.RegPaConfig.bits.OutputPower);
dudmuck 0:be215de91a68 841 printf(" RFO pmax=%.1fdBm OutputPower=%.1fdBm", pmax, output_dBm);
dudmuck 0:be215de91a68 842 }
dudmuck 0:be215de91a68 843 }
dudmuck 0:be215de91a68 844
dudmuck 0:be215de91a68 845 void /* things always present, whether lora or fsk */
dudmuck 0:be215de91a68 846 common_print_status()
dudmuck 0:be215de91a68 847 {
dudmuck 0:be215de91a68 848 printf("version:0x%02x %.3fMHz ", radio.read_reg(REG_VERSION), radio.get_frf_MHz());
dudmuck 0:be215de91a68 849 printOpMode();
dudmuck 0:be215de91a68 850
dudmuck 0:be215de91a68 851 printPa();
dudmuck 0:be215de91a68 852
dudmuck 0:be215de91a68 853 radio.RegOcp.octet = radio.read_reg(REG_OCP);
dudmuck 0:be215de91a68 854 if (radio.RegOcp.bits.OcpOn) {
dudmuck 0:be215de91a68 855 int imax = 0;
dudmuck 0:be215de91a68 856 if (radio.RegOcp.bits.OcpTrim < 16)
dudmuck 0:be215de91a68 857 imax = 45 + (5 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:be215de91a68 858 else if (radio.RegOcp.bits.OcpTrim < 28)
dudmuck 0:be215de91a68 859 imax = -30 + (10 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:be215de91a68 860 else
dudmuck 0:be215de91a68 861 imax = 240;
dudmuck 0:be215de91a68 862 printf(" OcpOn %dmA ", imax);
dudmuck 0:be215de91a68 863 } else
dudmuck 0:be215de91a68 864 printf(" OcpOFF ");
dudmuck 0:be215de91a68 865
dudmuck 0:be215de91a68 866 printf("\r\n");
dudmuck 0:be215de91a68 867
dudmuck 0:be215de91a68 868 }
dudmuck 0:be215de91a68 869
dudmuck 0:be215de91a68 870 void print_rx_buf(int len)
dudmuck 0:be215de91a68 871 {
dudmuck 0:be215de91a68 872 int i;
dudmuck 0:be215de91a68 873
dudmuck 0:be215de91a68 874 printf("000:");
dudmuck 0:be215de91a68 875 for (i = 0; i < len; i++) {
dudmuck 0:be215de91a68 876 //printf("(%d)%02x ", i % 16, rx_buf[i]);
dudmuck 0:be215de91a68 877 printf("%02x ", radio.rx_buf[i]);
dudmuck 0:be215de91a68 878 if (i % 16 == 15 && i != len-1)
dudmuck 0:be215de91a68 879 printf("\r\n%03d:", i+1);
dudmuck 0:be215de91a68 880
dudmuck 0:be215de91a68 881 }
dudmuck 0:be215de91a68 882 printf("\r\n");
dudmuck 0:be215de91a68 883 }
dudmuck 0:be215de91a68 884
dudmuck 0:be215de91a68 885 void
dudmuck 0:be215de91a68 886 service_radio()
dudmuck 0:be215de91a68 887 {
dudmuck 1:1cd0afbed23c 888 service_action_e act;
dudmuck 1:1cd0afbed23c 889
dudmuck 1:1cd0afbed23c 890 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 4:7a9007dfc0e5 891
dudmuck 1:1cd0afbed23c 892 act = lora.service();
dudmuck 0:be215de91a68 893
dudmuck 1:1cd0afbed23c 894 switch (act) {
dudmuck 1:1cd0afbed23c 895 case SERVICE_READ_FIFO:
dudmuck 1:1cd0afbed23c 896 float dbm;
dudmuck 1:1cd0afbed23c 897 if (app == APP_NONE) {
dudmuck 1:1cd0afbed23c 898 printLoraIrqs_(false);
dudmuck 1:1cd0afbed23c 899 if (lora.RegHopPeriod > 0) {
dudmuck 1:1cd0afbed23c 900 lora.RegHopChannel.octet = radio.read_reg(REG_LR_HOPCHANNEL);
dudmuck 1:1cd0afbed23c 901 printf("HopCH:%d ", lora.RegHopChannel.bits.FhssPresentChannel);
dudmuck 1:1cd0afbed23c 902 }
dudmuck 1:1cd0afbed23c 903 lora_printCodingRate(true); // true: of received packet
dudmuck 1:1cd0afbed23c 904 dbm = lora.get_pkt_rssi();
dudmuck 1:1cd0afbed23c 905 printf(" crc%s %.1fdB %.1fdBm\r\n",
dudmuck 1:1cd0afbed23c 906 lora.RegHopChannel.bits.RxPayloadCrcOn ? "On" : "OFF",
dudmuck 1:1cd0afbed23c 907 lora.RegPktSnrValue / 4.0,
dudmuck 1:1cd0afbed23c 908 dbm
dudmuck 1:1cd0afbed23c 909 );
dudmuck 1:1cd0afbed23c 910 print_rx_buf(lora.RegRxNbBytes);
dudmuck 1:1cd0afbed23c 911 } else if (app == APP_CHAT) {
dudmuck 1:1cd0afbed23c 912 if (lora.RegHopChannel.bits.RxPayloadCrcOn) {
dudmuck 1:1cd0afbed23c 913 if (lora.RegIrqFlags.bits.PayloadCrcError)
dudmuck 1:1cd0afbed23c 914 printf("crcError\r\n");
dudmuck 1:1cd0afbed23c 915 else {
dudmuck 1:1cd0afbed23c 916 int n = lora.RegRxNbBytes;
dudmuck 1:1cd0afbed23c 917 radio.rx_buf[n++] = '\r';
dudmuck 1:1cd0afbed23c 918 radio.rx_buf[n++] = '\n';
dudmuck 1:1cd0afbed23c 919 radio.rx_buf[n] = 0; // null terminate
dudmuck 1:1cd0afbed23c 920 printf((char *)radio.rx_buf);
dudmuck 1:1cd0afbed23c 921 }
dudmuck 1:1cd0afbed23c 922 } else
dudmuck 1:1cd0afbed23c 923 printf("crcOff\r\n");
dudmuck 1:1cd0afbed23c 924
dudmuck 1:1cd0afbed23c 925 // clear Irq flags
dudmuck 1:1cd0afbed23c 926 radio.write_reg(REG_LR_IRQFLAGS, lora.RegIrqFlags.octet);
dudmuck 1:1cd0afbed23c 927 // should still be in receive mode
dudmuck 0:be215de91a68 928 }
dudmuck 1:1cd0afbed23c 929 break;
dudmuck 1:1cd0afbed23c 930 case SERVICE_TX_DONE:
dudmuck 1:1cd0afbed23c 931 if (app == APP_CHAT) {
dudmuck 1:1cd0afbed23c 932 lora.start_rx();
dudmuck 1:1cd0afbed23c 933 }
dudmuck 1:1cd0afbed23c 934 break;
dudmuck 1:1cd0afbed23c 935 case SERVICE_ERROR:
dudmuck 1:1cd0afbed23c 936 printf("error\r\n");
dudmuck 1:1cd0afbed23c 937 break;
dudmuck 1:1cd0afbed23c 938 } // ...switch (act)
dudmuck 1:1cd0afbed23c 939 } else {
dudmuck 1:1cd0afbed23c 940 /* FSK: */
dudmuck 1:1cd0afbed23c 941 act = fsk.service();
dudmuck 1:1cd0afbed23c 942
dudmuck 1:1cd0afbed23c 943 switch (act) {
dudmuck 1:1cd0afbed23c 944 case SERVICE_READ_FIFO:
dudmuck 2:c6b23a43a9d9 945 if (app == APP_CHAT) {
dudmuck 2:c6b23a43a9d9 946 int n = fsk.rx_buf_length;
dudmuck 2:c6b23a43a9d9 947 radio.rx_buf[n++] = '\r';
dudmuck 2:c6b23a43a9d9 948 radio.rx_buf[n++] = '\n';
dudmuck 2:c6b23a43a9d9 949 radio.rx_buf[n] = 0; // null terminate
dudmuck 2:c6b23a43a9d9 950 printf((char *)radio.rx_buf);
dudmuck 2:c6b23a43a9d9 951 } else {
dudmuck 2:c6b23a43a9d9 952 int i;
dudmuck 2:c6b23a43a9d9 953 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 2:c6b23a43a9d9 954 printf("%dHz ", (int)(FREQ_STEP_HZ * fsk.RegAfcValue));
dudmuck 2:c6b23a43a9d9 955 printf("%d: ", fsk.rx_buf_length);
dudmuck 2:c6b23a43a9d9 956 for (i = 0; i < fsk.rx_buf_length; i++)
dudmuck 2:c6b23a43a9d9 957 printf("%02x ", radio.rx_buf[i]);
dudmuck 2:c6b23a43a9d9 958 printf("\r\n");
dudmuck 2:c6b23a43a9d9 959 }
dudmuck 1:1cd0afbed23c 960 break;
dudmuck 2:c6b23a43a9d9 961 case SERVICE_TX_DONE:
dudmuck 2:c6b23a43a9d9 962 if (app == APP_CHAT) {
dudmuck 2:c6b23a43a9d9 963 fsk.start_rx();
dudmuck 2:c6b23a43a9d9 964 }
dudmuck 2:c6b23a43a9d9 965 break;
dudmuck 1:1cd0afbed23c 966 } // ...switch (act)
dudmuck 1:1cd0afbed23c 967 }
dudmuck 0:be215de91a68 968 }
dudmuck 0:be215de91a68 969
dudmuck 0:be215de91a68 970 int get_kbd_str(char* buf, int size)
dudmuck 0:be215de91a68 971 {
dudmuck 0:be215de91a68 972 char c;
dudmuck 0:be215de91a68 973 int i;
dudmuck 0:be215de91a68 974 static int prev_len;
dudmuck 0:be215de91a68 975
dudmuck 0:be215de91a68 976 for (i = 0;;) {
dudmuck 0:be215de91a68 977 if (pc.readable()) {
dudmuck 0:be215de91a68 978 c = pc.getc();
dudmuck 0:be215de91a68 979 if (c == 8 && i > 0) {
dudmuck 0:be215de91a68 980 pc.putc(8);
dudmuck 0:be215de91a68 981 pc.putc(' ');
dudmuck 0:be215de91a68 982 pc.putc(8);
dudmuck 0:be215de91a68 983 i--;
dudmuck 0:be215de91a68 984 } else if (c == '\r') {
dudmuck 0:be215de91a68 985 if (i == 0) {
dudmuck 0:be215de91a68 986 return prev_len; // repeat previous
dudmuck 0:be215de91a68 987 } else {
dudmuck 0:be215de91a68 988 buf[i] = 0; // null terminate
dudmuck 0:be215de91a68 989 prev_len = i;
dudmuck 0:be215de91a68 990 return i;
dudmuck 0:be215de91a68 991 }
dudmuck 0:be215de91a68 992 } else if (c == 3) {
dudmuck 0:be215de91a68 993 // ctrl-C abort
dudmuck 0:be215de91a68 994 return -1;
dudmuck 0:be215de91a68 995 } else if (i < size) {
dudmuck 0:be215de91a68 996 buf[i++] = c;
dudmuck 0:be215de91a68 997 pc.putc(c);
dudmuck 0:be215de91a68 998 }
dudmuck 4:7a9007dfc0e5 999 } else {
dudmuck 0:be215de91a68 1000 service_radio();
dudmuck 4:7a9007dfc0e5 1001 }
dudmuck 0:be215de91a68 1002 } // ...for()
dudmuck 0:be215de91a68 1003 }
dudmuck 0:be215de91a68 1004
dudmuck 0:be215de91a68 1005 void
dudmuck 0:be215de91a68 1006 console_chat()
dudmuck 0:be215de91a68 1007 {
dudmuck 0:be215de91a68 1008 int i, len = get_kbd_str(pcbuf, sizeof(pcbuf));
dudmuck 0:be215de91a68 1009 if (len < 0) {
dudmuck 0:be215de91a68 1010 printf("chat abort\r\n");
dudmuck 0:be215de91a68 1011 app = APP_NONE;
dudmuck 0:be215de91a68 1012 return;
dudmuck 0:be215de91a68 1013 } else {
dudmuck 0:be215de91a68 1014 for (i = 0; i < len; i++)
dudmuck 0:be215de91a68 1015 radio.tx_buf[i] = pcbuf[i];
dudmuck 1:1cd0afbed23c 1016 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1017 lora.RegPayloadLength = len;
dudmuck 1:1cd0afbed23c 1018 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 1:1cd0afbed23c 1019 lora.start_tx(len);
dudmuck 2:c6b23a43a9d9 1020 } else {
dudmuck 2:c6b23a43a9d9 1021 fsk.start_tx(len);
dudmuck 2:c6b23a43a9d9 1022 }
dudmuck 0:be215de91a68 1023 printf("\r\n");
dudmuck 0:be215de91a68 1024 }
dudmuck 0:be215de91a68 1025 }
dudmuck 0:be215de91a68 1026
dudmuck 0:be215de91a68 1027 void
dudmuck 0:be215de91a68 1028 console()
dudmuck 0:be215de91a68 1029 {
dudmuck 0:be215de91a68 1030 int len, i;
dudmuck 2:c6b23a43a9d9 1031 uint32_t ui;
dudmuck 0:be215de91a68 1032 uint8_t a, d;
dudmuck 1:1cd0afbed23c 1033 static uint16_t fsk_tx_length;
dudmuck 0:be215de91a68 1034
dudmuck 0:be215de91a68 1035 len = get_kbd_str(pcbuf, sizeof(pcbuf));
dudmuck 0:be215de91a68 1036 if (len < 0) {
dudmuck 0:be215de91a68 1037 printf("abort\r\n");
dudmuck 0:be215de91a68 1038 return;
dudmuck 0:be215de91a68 1039 }
dudmuck 0:be215de91a68 1040
dudmuck 0:be215de91a68 1041 printf("\r\n");
dudmuck 0:be215de91a68 1042 if (len == 1) {
dudmuck 0:be215de91a68 1043 switch (pcbuf[0]) {
dudmuck 0:be215de91a68 1044 case 'i':
dudmuck 3:ab386fa756cc 1045 printf("init\r\n");
dudmuck 0:be215de91a68 1046 radio.init();
dudmuck 3:ab386fa756cc 1047 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1048 fsk.init(); // put FSK modem to some functioning default
dudmuck 3:ab386fa756cc 1049 } else {
dudmuck 3:ab386fa756cc 1050 // lora configuration is more simple
dudmuck 3:ab386fa756cc 1051 }
dudmuck 0:be215de91a68 1052 break;
dudmuck 0:be215de91a68 1053 case 'h':
dudmuck 0:be215de91a68 1054 printf("hw_reset()\r\n");
dudmuck 0:be215de91a68 1055 radio.hw_reset();
dudmuck 0:be215de91a68 1056 break;
dudmuck 0:be215de91a68 1057 case 'R':
dudmuck 0:be215de91a68 1058 // read all registers
dudmuck 0:be215de91a68 1059 for (a = 1; a < 0x71; a++) {
dudmuck 0:be215de91a68 1060 d = radio.read_reg(a);
dudmuck 0:be215de91a68 1061 //update_shadow_regs(selected_radio, a, d);
dudmuck 0:be215de91a68 1062 printf("%02x: %02x\r\n", a, d);
dudmuck 0:be215de91a68 1063 }
dudmuck 0:be215de91a68 1064 break;
dudmuck 0:be215de91a68 1065 case 'T':
dudmuck 1:1cd0afbed23c 1066 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1067 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 1:1cd0afbed23c 1068 //printf("a %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1069 lora.RegModemConfig2.sx1276bits.TxContinuousMode ^= 1; // same for sx1272 and sx1276
dudmuck 1:1cd0afbed23c 1070 //printf("b %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1071 radio.write_reg(REG_LR_MODEMCONFIG2, lora.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1072 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1073 //printf("c %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1074 lora_printTxContinuousMode();
dudmuck 1:1cd0afbed23c 1075 printf("\r\n");
dudmuck 1:1cd0afbed23c 1076 }
dudmuck 0:be215de91a68 1077 break;
dudmuck 0:be215de91a68 1078 case 'C':
dudmuck 2:c6b23a43a9d9 1079 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1080 lora.setRxPayloadCrcOn(!lora.getRxPayloadCrcOn());
dudmuck 2:c6b23a43a9d9 1081 lora_printRxPayloadCrcOn();
dudmuck 2:c6b23a43a9d9 1082 } else {
dudmuck 2:c6b23a43a9d9 1083 printf("CrcOn:");
dudmuck 2:c6b23a43a9d9 1084 fsk.RegPktConfig1.bits.CrcOn ^= 1;
dudmuck 2:c6b23a43a9d9 1085 radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
dudmuck 2:c6b23a43a9d9 1086 if (fsk.RegPktConfig1.bits.CrcOn)
dudmuck 2:c6b23a43a9d9 1087 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1088 else
dudmuck 2:c6b23a43a9d9 1089 printf("Off\r\n");
dudmuck 2:c6b23a43a9d9 1090 if (fsk.RegPktConfig2.bits.DataModePacket && radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER) {
dudmuck 2:c6b23a43a9d9 1091 fsk.config_dio0_for_pktmode_rx();
dudmuck 2:c6b23a43a9d9 1092 }
dudmuck 2:c6b23a43a9d9 1093 }
dudmuck 0:be215de91a68 1094 printf("\r\n");
dudmuck 0:be215de91a68 1095 break;
dudmuck 0:be215de91a68 1096 case 'B':
dudmuck 0:be215de91a68 1097 radio.RegPaConfig.bits.PaSelect ^= 1;
dudmuck 0:be215de91a68 1098 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:be215de91a68 1099 printPa();
dudmuck 0:be215de91a68 1100 printf("\r\n");
dudmuck 1:1cd0afbed23c 1101 break;
dudmuck 1:1cd0afbed23c 1102 case 'L':
dudmuck 1:1cd0afbed23c 1103 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1104 fsk.enable();
dudmuck 1:1cd0afbed23c 1105 else
dudmuck 1:1cd0afbed23c 1106 lora.enable();
dudmuck 1:1cd0afbed23c 1107
dudmuck 1:1cd0afbed23c 1108 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 1:1cd0afbed23c 1109 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1110 printf("LoRa\r\n");
dudmuck 1:1cd0afbed23c 1111 else
dudmuck 1:1cd0afbed23c 1112 printf("FSK\r\n");
dudmuck 2:c6b23a43a9d9 1113 break;
dudmuck 2:c6b23a43a9d9 1114 case 's':
dudmuck 2:c6b23a43a9d9 1115 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1116 fsk.RegFifoThreshold.bits.TxStartCondition ^= 1;
dudmuck 2:c6b23a43a9d9 1117 radio.write_reg(REG_FSK_FIFOTHRESH, fsk.RegFifoThreshold.octet);
dudmuck 2:c6b23a43a9d9 1118 printf("TxStartCondition:");
dudmuck 2:c6b23a43a9d9 1119 if (fsk.RegFifoThreshold.bits.TxStartCondition)
dudmuck 2:c6b23a43a9d9 1120 printf("!FifoEmpty\r\n");
dudmuck 2:c6b23a43a9d9 1121 else
dudmuck 2:c6b23a43a9d9 1122 printf("FifoLevel\r\n");
dudmuck 2:c6b23a43a9d9 1123 }
dudmuck 2:c6b23a43a9d9 1124 break;
dudmuck 2:c6b23a43a9d9 1125 case 'f':
dudmuck 2:c6b23a43a9d9 1126 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1127 printf("PacketFormat:");
dudmuck 2:c6b23a43a9d9 1128 fsk.RegPktConfig1.bits.PacketFormatVariable ^= 1;
dudmuck 2:c6b23a43a9d9 1129 radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
dudmuck 2:c6b23a43a9d9 1130 if (fsk.RegPktConfig1.bits.PacketFormatVariable)
dudmuck 2:c6b23a43a9d9 1131 printf("variable\r\n");
dudmuck 2:c6b23a43a9d9 1132 else
dudmuck 2:c6b23a43a9d9 1133 printf("fixed\r\n");
dudmuck 2:c6b23a43a9d9 1134 /*if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER)
dudmuck 2:c6b23a43a9d9 1135 reset_flow();*/
dudmuck 2:c6b23a43a9d9 1136 }
dudmuck 2:c6b23a43a9d9 1137 break;
dudmuck 2:c6b23a43a9d9 1138 case 'E':
dudmuck 2:c6b23a43a9d9 1139 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1140 RegIrqFlags2_t RegIrqFlags2;
dudmuck 2:c6b23a43a9d9 1141 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 1142 while (!RegIrqFlags2.bits.FifoEmpty) {
dudmuck 2:c6b23a43a9d9 1143 if (pc.readable())
dudmuck 2:c6b23a43a9d9 1144 break;
dudmuck 2:c6b23a43a9d9 1145 printf("%02x\r\n", radio.read_reg(REG_FIFO));
dudmuck 2:c6b23a43a9d9 1146 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 1147 }
dudmuck 2:c6b23a43a9d9 1148 }
dudmuck 2:c6b23a43a9d9 1149 break;
dudmuck 2:c6b23a43a9d9 1150 case 'A':
dudmuck 2:c6b23a43a9d9 1151 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1152 fsk.RegRxConfig.bits.AfcAutoOn ^= 1;
dudmuck 2:c6b23a43a9d9 1153 radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
dudmuck 2:c6b23a43a9d9 1154 printf("AfcAuto:");
dudmuck 2:c6b23a43a9d9 1155 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 2:c6b23a43a9d9 1156 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1157 else
dudmuck 2:c6b23a43a9d9 1158 printf("OFF\r\n");
dudmuck 2:c6b23a43a9d9 1159 break;
dudmuck 2:c6b23a43a9d9 1160 }
dudmuck 2:c6b23a43a9d9 1161 break;
dudmuck 0:be215de91a68 1162 case '?':
dudmuck 1:1cd0afbed23c 1163 printf("L toggle LongRangeMode/FSK\r\n");
dudmuck 0:be215de91a68 1164 printf("i radio_init\r\n");
dudmuck 0:be215de91a68 1165 printf("h hw_reset\r\n");
dudmuck 2:c6b23a43a9d9 1166 printf("tx[%%d] transmit\r\n");
dudmuck 1:1cd0afbed23c 1167 printf("rx receive\r\n");
dudmuck 0:be215de91a68 1168 printf("C toggle crcOn\r\n");
dudmuck 2:c6b23a43a9d9 1169 printf("op[%%d] get/set output power\r\n");
dudmuck 1:1cd0afbed23c 1170 printf("d[0-5] change DIO pin assignment\r\n");
dudmuck 3:ab386fa756cc 1171 printf("frf[%%f} get/set operating frequency (MHz)\r\n");
dudmuck 1:1cd0afbed23c 1172 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1173 printf("pl[%%d] LORA get/set RegPayloadLength\r\n");
dudmuck 1:1cd0afbed23c 1174 printf("cr[1234] LORA set coding rate \r\n");
dudmuck 2:c6b23a43a9d9 1175 printf("bw[%%d] LORA get/set bandwidth\r\n");
dudmuck 2:c6b23a43a9d9 1176 printf("sf[%%d] LORA get/set spreading factor\r\n");
dudmuck 1:1cd0afbed23c 1177 printf("T LORA toggle TxContinuousMode\r\n");
dudmuck 2:c6b23a43a9d9 1178 printf("hp[%%d] LORA get/set hop period\r\n");
dudmuck 1:1cd0afbed23c 1179 printf("hm LORA toggle explicit/explicit header mode\r\n");
dudmuck 1:1cd0afbed23c 1180 } else {
dudmuck 2:c6b23a43a9d9 1181 printf("bw[a][%%d] FSK get-set rxbw (bwa=afcbw)\r\n");
dudmuck 3:ab386fa756cc 1182 printf("br[%%d] FSK get-set bitrate\r\n");
dudmuck 3:ab386fa756cc 1183 printf("fdev[%%d] FSK get-set TX frequency deviation (hz)\r\n");
dudmuck 2:c6b23a43a9d9 1184 printf("rt FSK change RxTrigger\r\n");
dudmuck 2:c6b23a43a9d9 1185 printf("pd FSK enable/disable preamble detector\r\n");
dudmuck 2:c6b23a43a9d9 1186 printf("pt FSK get-set PreambleDetectorTol\r\n");
dudmuck 2:c6b23a43a9d9 1187 printf("ss[%%d] FSK get-set SyncSize\r\n");
dudmuck 2:c6b23a43a9d9 1188 printf("S[%%x] FSK get-set sync word\r\n");
dudmuck 2:c6b23a43a9d9 1189 printf("s FSK toggle TxStartCondition\r\n");
dudmuck 2:c6b23a43a9d9 1190 printf("f FSK toggle PacketFormat fixed-variable\r\n");
dudmuck 2:c6b23a43a9d9 1191 printf("E FSK empty out the fifo\r\n");
dudmuck 2:c6b23a43a9d9 1192 printf("ac FSK AfcClear\r\n");
dudmuck 2:c6b23a43a9d9 1193 printf("A FSK toggle AfcAutoOn\r\n");
dudmuck 2:c6b23a43a9d9 1194 printf("mp FSK toggle MapPreambleDetect\r\n");
dudmuck 2:c6b23a43a9d9 1195 printf("ar FSK change AutoRestartRxMode\r\n");
dudmuck 2:c6b23a43a9d9 1196 printf("alc FSK toggle AfcAutoClearOn\r\n");
dudmuck 3:ab386fa756cc 1197 printf("pre[%%d} FSK get-set TX preamble length\r\n");
dudmuck 1:1cd0afbed23c 1198 }
dudmuck 0:be215de91a68 1199 break;
dudmuck 0:be215de91a68 1200 case '.':
dudmuck 1:1cd0afbed23c 1201 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1202 lora_print_status();
dudmuck 1:1cd0afbed23c 1203 else
dudmuck 1:1cd0afbed23c 1204 fsk_print_status();
dudmuck 0:be215de91a68 1205 common_print_status();
dudmuck 0:be215de91a68 1206 break;
dudmuck 0:be215de91a68 1207 } // ...switch (pcbuf[0])
dudmuck 0:be215de91a68 1208 } else {
dudmuck 0:be215de91a68 1209 if (pcbuf[0] == 't' && pcbuf[1] == 'x') { // TX
dudmuck 1:1cd0afbed23c 1210 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1211 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1212 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1213 lora.RegPayloadLength = i;
dudmuck 1:1cd0afbed23c 1214 }
dudmuck 1:1cd0afbed23c 1215 tx_cnt++;
dudmuck 1:1cd0afbed23c 1216 for (i = 0; i < lora.RegPayloadLength; i++)
dudmuck 1:1cd0afbed23c 1217 radio.tx_buf[i] = tx_cnt;
dudmuck 1:1cd0afbed23c 1218 lora.start_tx(lora.RegPayloadLength);
dudmuck 2:c6b23a43a9d9 1219 } else { // FSK:
dudmuck 1:1cd0afbed23c 1220 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1221 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1222 fsk_tx_length = i;
dudmuck 1:1cd0afbed23c 1223 }
dudmuck 2:c6b23a43a9d9 1224 if (radio.RegOpMode.bits.Mode != RF_OPMODE_TRANSMITTER) { // if not already busy transmitting
dudmuck 2:c6b23a43a9d9 1225 tx_cnt++;
dudmuck 2:c6b23a43a9d9 1226 for (i = 0; i < fsk_tx_length; i++) {
dudmuck 2:c6b23a43a9d9 1227 radio.tx_buf[i] = tx_cnt;
dudmuck 2:c6b23a43a9d9 1228 }
dudmuck 2:c6b23a43a9d9 1229 fsk.start_tx(fsk_tx_length);
dudmuck 2:c6b23a43a9d9 1230 }
dudmuck 0:be215de91a68 1231 }
dudmuck 1:1cd0afbed23c 1232 } else if (pcbuf[0] == 'h' && pcbuf[1] == 'p' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1233 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1234 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1235 lora.RegHopPeriod = i;
dudmuck 1:1cd0afbed23c 1236 radio.write_reg(REG_LR_HOPPERIOD, lora.RegHopPeriod);
dudmuck 0:be215de91a68 1237 if (radio.RegDioMapping1.bits.Dio1Mapping != 1) {
dudmuck 0:be215de91a68 1238 radio.RegDioMapping1.bits.Dio1Mapping = 1;
dudmuck 0:be215de91a68 1239 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1240 }
dudmuck 0:be215de91a68 1241 }
dudmuck 1:1cd0afbed23c 1242 lora.RegHopPeriod = radio.read_reg(REG_LR_HOPPERIOD);
dudmuck 1:1cd0afbed23c 1243 printf("HopPeriod:0x%02x\r\n", lora.RegHopPeriod);
dudmuck 2:c6b23a43a9d9 1244 } else if (pcbuf[0] == 'r' && pcbuf[1] == 't' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1245 printf("RxTrigger:");
dudmuck 2:c6b23a43a9d9 1246 switch (fsk.RegRxConfig.bits.RxTrigger) {
dudmuck 2:c6b23a43a9d9 1247 case 0: fsk.RegRxConfig.bits.RxTrigger = 1;
dudmuck 2:c6b23a43a9d9 1248 printf("rssi\r\n");
dudmuck 2:c6b23a43a9d9 1249 break;
dudmuck 2:c6b23a43a9d9 1250 case 1: fsk.RegRxConfig.bits.RxTrigger = 6;
dudmuck 2:c6b23a43a9d9 1251 printf("preamble\r\n");
dudmuck 2:c6b23a43a9d9 1252 break;
dudmuck 2:c6b23a43a9d9 1253 case 6: fsk.RegRxConfig.bits.RxTrigger = 7;
dudmuck 2:c6b23a43a9d9 1254 printf("both\r\n");
dudmuck 2:c6b23a43a9d9 1255 break;
dudmuck 2:c6b23a43a9d9 1256 case 7: fsk.RegRxConfig.bits.RxTrigger = 0;
dudmuck 2:c6b23a43a9d9 1257 printf("none\r\n");
dudmuck 2:c6b23a43a9d9 1258 break;
dudmuck 2:c6b23a43a9d9 1259 default: fsk.RegRxConfig.bits.RxTrigger = 0;
dudmuck 2:c6b23a43a9d9 1260 printf("none\r\n");
dudmuck 2:c6b23a43a9d9 1261 break;
dudmuck 2:c6b23a43a9d9 1262 }
dudmuck 2:c6b23a43a9d9 1263 radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
dudmuck 0:be215de91a68 1264 } else if (pcbuf[0] == 'r' && pcbuf[1] == 'x') { // RX
dudmuck 2:c6b23a43a9d9 1265 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 2:c6b23a43a9d9 1266 lora.start_rx();
dudmuck 2:c6b23a43a9d9 1267 else
dudmuck 2:c6b23a43a9d9 1268 fsk.start_rx();
dudmuck 0:be215de91a68 1269 } else if (pcbuf[0] == 'r' && pcbuf[1] == ' ') { // read single register
dudmuck 0:be215de91a68 1270 sscanf(pcbuf+2, "%x", &i);
dudmuck 0:be215de91a68 1271 printf("%02x: %02x\r\n", i, radio.read_reg(i));
dudmuck 0:be215de91a68 1272 } else if (pcbuf[0] == 'w' && pcbuf[1] == ' ') { // write single register
dudmuck 0:be215de91a68 1273 sscanf(pcbuf+2, "%x %x", &i, &len);
dudmuck 0:be215de91a68 1274 radio.write_reg(i, len);
dudmuck 0:be215de91a68 1275 printf("%02x: %02x\r\n", i, radio.read_reg(i));
dudmuck 2:c6b23a43a9d9 1276 } else if (pcbuf[0] == 'm' && pcbuf[1] == 'p' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1277 radio.RegDioMapping2.bits.MapPreambleDetect ^= 1;
dudmuck 2:c6b23a43a9d9 1278 radio.write_reg(REG_DIOMAPPING2, radio.RegDioMapping2.octet);
dudmuck 2:c6b23a43a9d9 1279 printf("MapPreambleDetect:");
dudmuck 2:c6b23a43a9d9 1280 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 2:c6b23a43a9d9 1281 printf("preamble\r\n");
dudmuck 2:c6b23a43a9d9 1282 else
dudmuck 2:c6b23a43a9d9 1283 printf("rssi\r\n");
dudmuck 0:be215de91a68 1284 } else if (pcbuf[0] == 'o' && pcbuf[1] == 'p') {
dudmuck 0:be215de91a68 1285 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1286 sscanf(pcbuf+2, "%d", &i);
dudmuck 0:be215de91a68 1287 radio.RegPaConfig.bits.OutputPower = i;
dudmuck 0:be215de91a68 1288 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:be215de91a68 1289 }
dudmuck 0:be215de91a68 1290 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:be215de91a68 1291 printf("OutputPower:%d\r\n", radio.RegPaConfig.bits.OutputPower);
dudmuck 1:1cd0afbed23c 1292 } else if (pcbuf[0] == 'c' && pcbuf[1] == 'r' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1293 if (pcbuf[2] >= '0' && pcbuf[2] <= '9')
dudmuck 1:1cd0afbed23c 1294 lora.setCodingRate(pcbuf[2] - '0');
dudmuck 1:1cd0afbed23c 1295 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1296 lora_printCodingRate(false); // false: transmitted
dudmuck 0:be215de91a68 1297 printf("\r\n");
dudmuck 1:1cd0afbed23c 1298 } else if (pcbuf[0] == 'h' && pcbuf[1] == 'm' && radio.RegOpMode.bits.LongRangeMode) { // toggle implicit/explicit
dudmuck 1:1cd0afbed23c 1299 lora.setHeaderMode(!lora.getHeaderMode());
dudmuck 1:1cd0afbed23c 1300 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1301 lora_printHeaderMode();
dudmuck 0:be215de91a68 1302 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1303 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'l' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1304 fsk.RegAfcFei.bits.AfcAutoClearOn ^= 1;
dudmuck 2:c6b23a43a9d9 1305 printf("AfcAutoClearOn: ");
dudmuck 2:c6b23a43a9d9 1306 radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
dudmuck 2:c6b23a43a9d9 1307 if (fsk.RegAfcFei.bits.AfcAutoClearOn)
dudmuck 2:c6b23a43a9d9 1308 printf("ON\r\n");
dudmuck 2:c6b23a43a9d9 1309 else
dudmuck 2:c6b23a43a9d9 1310 printf("off\r\n");
dudmuck 2:c6b23a43a9d9 1311 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'r' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1312 fsk.RegSyncConfig.bits.AutoRestartRxMode++;
dudmuck 2:c6b23a43a9d9 1313 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1314 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1315 printf("AutoRestartRxMode:");
dudmuck 2:c6b23a43a9d9 1316 switch (fsk.RegSyncConfig.bits.AutoRestartRxMode) {
dudmuck 2:c6b23a43a9d9 1317 case 0: printf("off "); break;
dudmuck 2:c6b23a43a9d9 1318 case 1: printf("no-pll-wait "); break;
dudmuck 2:c6b23a43a9d9 1319 case 2: printf("pll-wait "); break;
dudmuck 2:c6b23a43a9d9 1320 case 3: printf("3 "); break;
dudmuck 2:c6b23a43a9d9 1321 }
dudmuck 2:c6b23a43a9d9 1322 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1323 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'c' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1324 printf("clear afc: ");
dudmuck 2:c6b23a43a9d9 1325 fsk.RegAfcFei.bits.AfcClear = 1;
dudmuck 2:c6b23a43a9d9 1326 radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
dudmuck 2:c6b23a43a9d9 1327 fsk.RegAfcFei.bits.AfcClear = 0;
dudmuck 3:ab386fa756cc 1328 printf("%dHz\r\n", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_AFCMSB)));
dudmuck 3:ab386fa756cc 1329 } else if (pcbuf[0] == 'b' && pcbuf[1] == 'r' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1330 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 3:ab386fa756cc 1331 sscanf(&pcbuf[2], "%d", &i);
dudmuck 3:ab386fa756cc 1332 fsk.set_bitrate(i);
dudmuck 3:ab386fa756cc 1333 }
dudmuck 3:ab386fa756cc 1334 printf("%dbps\r\n", fsk.get_bitrate());
dudmuck 0:be215de91a68 1335 } else if (pcbuf[0] == 'b' && pcbuf[1] == 'w') {
dudmuck 1:1cd0afbed23c 1336 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1337 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 1:1cd0afbed23c 1338 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1339 sscanf(&pcbuf[2], "%d", &i);
dudmuck 1:1cd0afbed23c 1340 lora.setBw(i);
dudmuck 1:1cd0afbed23c 1341 } else
dudmuck 1:1cd0afbed23c 1342 lora_printAllBw();
dudmuck 1:1cd0afbed23c 1343 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1344 printf("current ");
dudmuck 1:1cd0afbed23c 1345 lora_printBw();
dudmuck 1:1cd0afbed23c 1346 printf("\r\n");
dudmuck 1:1cd0afbed23c 1347 } else { // FSK:
dudmuck 1:1cd0afbed23c 1348 if (pcbuf[2] == 'a') {
dudmuck 1:1cd0afbed23c 1349 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 1:1cd0afbed23c 1350 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1351 sscanf(&pcbuf[3], "%d", &i);
dudmuck 1:1cd0afbed23c 1352 fsk.set_rx_dcc_bw_hz(i, 1);
dudmuck 1:1cd0afbed23c 1353 }
dudmuck 1:1cd0afbed23c 1354 printf("afcbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_AFCBW));
dudmuck 1:1cd0afbed23c 1355 } else {
dudmuck 1:1cd0afbed23c 1356 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 1:1cd0afbed23c 1357 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1358 sscanf(&pcbuf[2], "%d", &i);
dudmuck 1:1cd0afbed23c 1359 fsk.set_rx_dcc_bw_hz(i, 0);
dudmuck 1:1cd0afbed23c 1360 }
dudmuck 1:1cd0afbed23c 1361 printf("rxbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_RXBW));
dudmuck 1:1cd0afbed23c 1362 }
dudmuck 1:1cd0afbed23c 1363 }
dudmuck 0:be215de91a68 1364 } else if (pcbuf[0] == 'v' && pcbuf[1] == 'h') {
dudmuck 1:1cd0afbed23c 1365 lora.poll_vh ^= 1;
dudmuck 1:1cd0afbed23c 1366 printf("poll_vh:%d\r\n", lora.poll_vh);
dudmuck 2:c6b23a43a9d9 1367 } else if (pcbuf[0] == 'S' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1368 if (pcbuf[1] == '0') {
dudmuck 2:c6b23a43a9d9 1369 sscanf(pcbuf+1, "%x", &ui);
dudmuck 2:c6b23a43a9d9 1370 if (ui < 0x100) {
dudmuck 2:c6b23a43a9d9 1371 fsk.RegSyncConfig.bits.SyncSize = 0;
dudmuck 2:c6b23a43a9d9 1372 radio.write_reg(REG_FSK_SYNCVALUE1, ui);
dudmuck 2:c6b23a43a9d9 1373 } else if (ui < 0x10000) {
dudmuck 2:c6b23a43a9d9 1374 fsk.RegSyncConfig.bits.SyncSize = 1;
dudmuck 3:ab386fa756cc 1375 radio.write_reg(REG_FSK_SYNCVALUE2, ui & 0xff);
dudmuck 3:ab386fa756cc 1376 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 8);
dudmuck 2:c6b23a43a9d9 1377 } else if (ui < 0x1000000) {
dudmuck 2:c6b23a43a9d9 1378 fsk.RegSyncConfig.bits.SyncSize = 2;
dudmuck 3:ab386fa756cc 1379 radio.write_reg(REG_FSK_SYNCVALUE3, ui & 0xff);
dudmuck 2:c6b23a43a9d9 1380 radio.write_reg(REG_FSK_SYNCVALUE2, (ui >> 8) & 0xff);
dudmuck 3:ab386fa756cc 1381 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 16);
dudmuck 2:c6b23a43a9d9 1382 } else {
dudmuck 2:c6b23a43a9d9 1383 fsk.RegSyncConfig.bits.SyncSize = 3;
dudmuck 3:ab386fa756cc 1384 radio.write_reg(REG_FSK_SYNCVALUE4, ui & 0xff);
dudmuck 3:ab386fa756cc 1385 radio.write_reg(REG_FSK_SYNCVALUE3, (ui >> 8) & 0xff);
dudmuck 3:ab386fa756cc 1386 radio.write_reg(REG_FSK_SYNCVALUE2, (ui >> 16) & 0xff);
dudmuck 3:ab386fa756cc 1387 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 24);
dudmuck 2:c6b23a43a9d9 1388 }
dudmuck 2:c6b23a43a9d9 1389 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1390 }
dudmuck 2:c6b23a43a9d9 1391 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1392 printf("%d: ", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 2:c6b23a43a9d9 1393 for (i = 0; i <= fsk.RegSyncConfig.bits.SyncSize; i++)
dudmuck 2:c6b23a43a9d9 1394 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE1+i));
dudmuck 2:c6b23a43a9d9 1395 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1396 } else if (pcbuf[0] == 's' && pcbuf[1] == 's' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1397 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1398 sscanf(pcbuf+2, "%d", &i);
dudmuck 2:c6b23a43a9d9 1399 fsk.RegSyncConfig.bits.SyncSize = i;
dudmuck 2:c6b23a43a9d9 1400 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1401 }
dudmuck 2:c6b23a43a9d9 1402 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1403 printf("SyncSize:%d\r\n", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 1:1cd0afbed23c 1404 } else if (pcbuf[0] == 's' && pcbuf[1] == 'f' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1405 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1406 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1407 lora.setSf(i);
dudmuck 1:1cd0afbed23c 1408 if (i == 6 && !lora.getHeaderMode()) {
dudmuck 0:be215de91a68 1409 printf("SF6: to implicit header mode\r\n");
dudmuck 1:1cd0afbed23c 1410 lora.setHeaderMode(true);
dudmuck 0:be215de91a68 1411 }
dudmuck 0:be215de91a68 1412 }
dudmuck 1:1cd0afbed23c 1413 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 1:1cd0afbed23c 1414 lora_printSf();
dudmuck 0:be215de91a68 1415 printf("\r\n");
dudmuck 3:ab386fa756cc 1416 } else if (pcbuf[0] == 'f' && pcbuf[1] == 'd' && pcbuf[2] == 'e' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1417 if (pcbuf[4] >= '0' && pcbuf[4] <= '9') {
dudmuck 3:ab386fa756cc 1418 sscanf(pcbuf+4, "%d", &i);
dudmuck 3:ab386fa756cc 1419 fsk.set_tx_fdev_hz(i);
dudmuck 3:ab386fa756cc 1420 }
dudmuck 3:ab386fa756cc 1421 printf("fdev:%dHz\r\n", fsk.get_tx_fdev_hz());
dudmuck 0:be215de91a68 1422 } else if (pcbuf[0] == 'f' && pcbuf[1] == 'r' && pcbuf[2] == 'f') {
dudmuck 0:be215de91a68 1423 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 0:be215de91a68 1424 float MHz;
dudmuck 0:be215de91a68 1425 sscanf(pcbuf+3, "%f", &MHz);
dudmuck 0:be215de91a68 1426 //printf("MHz:%f\r\n", MHz);
dudmuck 0:be215de91a68 1427 radio.set_frf_MHz(MHz);
dudmuck 3:ab386fa756cc 1428 }
dudmuck 3:ab386fa756cc 1429 printf("%fMHz\r\n", radio.get_frf_MHz());
dudmuck 4:7a9007dfc0e5 1430 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'r' && pcbuf[2] == 'e') {
dudmuck 4:7a9007dfc0e5 1431 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 4:7a9007dfc0e5 1432 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 4:7a9007dfc0e5 1433 sscanf(pcbuf+3, "%d", &i);
dudmuck 4:7a9007dfc0e5 1434 radio.write_u16(REG_LR_PREAMBLEMSB, i);
dudmuck 4:7a9007dfc0e5 1435 }
dudmuck 4:7a9007dfc0e5 1436 lora.RegPreamble = radio.read_u16(REG_LR_PREAMBLEMSB);
dudmuck 4:7a9007dfc0e5 1437 printf("lora PreambleLength:%d\r\n", lora.RegPreamble);
dudmuck 4:7a9007dfc0e5 1438 } else {
dudmuck 4:7a9007dfc0e5 1439 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 4:7a9007dfc0e5 1440 sscanf(pcbuf+3, "%d", &i);
dudmuck 4:7a9007dfc0e5 1441 radio.write_u16(REG_FSK_PREAMBLEMSB, i);
dudmuck 4:7a9007dfc0e5 1442 }
dudmuck 4:7a9007dfc0e5 1443 printf("FSK TX PreambleSize:%d\r\n", radio.read_u16(REG_FSK_PREAMBLEMSB));
dudmuck 3:ab386fa756cc 1444 }
dudmuck 2:c6b23a43a9d9 1445 } else if (pcbuf[0] == 'p' && pcbuf[1] == 't' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1446 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1447 sscanf(pcbuf+2, "%d", &i);
dudmuck 2:c6b23a43a9d9 1448 fsk.RegPreambleDetect.bits.PreambleDetectorTol = i;
dudmuck 2:c6b23a43a9d9 1449 radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
dudmuck 2:c6b23a43a9d9 1450 }
dudmuck 2:c6b23a43a9d9 1451 fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
dudmuck 2:c6b23a43a9d9 1452 printf("PreambleDetectorTol:%d\r\n", fsk.RegPreambleDetect.bits.PreambleDetectorTol);
dudmuck 2:c6b23a43a9d9 1453 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'd' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1454 fsk.RegPreambleDetect.bits.PreambleDetectorOn ^= 1;
dudmuck 2:c6b23a43a9d9 1455 radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
dudmuck 2:c6b23a43a9d9 1456 printf("PreambleDetector:");
dudmuck 2:c6b23a43a9d9 1457 if (fsk.RegPreambleDetect.bits.PreambleDetectorOn)
dudmuck 2:c6b23a43a9d9 1458 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1459 else
dudmuck 2:c6b23a43a9d9 1460 printf("OFF\r\n");
dudmuck 1:1cd0afbed23c 1461 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'l' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1462 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1463 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1464 lora.RegPayloadLength = i;
dudmuck 1:1cd0afbed23c 1465 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 0:be215de91a68 1466 }
dudmuck 1:1cd0afbed23c 1467 lora.RegPayloadLength = radio.read_reg(REG_LR_PAYLOADLENGTH);
dudmuck 1:1cd0afbed23c 1468 printf("PayloadLength:%d\r\n", lora.RegPayloadLength);
dudmuck 0:be215de91a68 1469 } else if (pcbuf[0] == 'd' && pcbuf[1] >= '0' && pcbuf[1] <= '5') {
dudmuck 0:be215de91a68 1470 switch (pcbuf[1]) {
dudmuck 0:be215de91a68 1471 case '0':
dudmuck 0:be215de91a68 1472 radio.RegDioMapping1.bits.Dio0Mapping++;
dudmuck 0:be215de91a68 1473 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1474 break;
dudmuck 0:be215de91a68 1475 case '1':
dudmuck 0:be215de91a68 1476 radio.RegDioMapping1.bits.Dio1Mapping++;
dudmuck 0:be215de91a68 1477 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1478 break;
dudmuck 0:be215de91a68 1479 case '2':
dudmuck 0:be215de91a68 1480 radio.RegDioMapping1.bits.Dio2Mapping++;
dudmuck 0:be215de91a68 1481 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1482 break;
dudmuck 0:be215de91a68 1483 case '3':
dudmuck 0:be215de91a68 1484 radio.RegDioMapping1.bits.Dio3Mapping++;
dudmuck 0:be215de91a68 1485 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1486 break;
dudmuck 0:be215de91a68 1487 case '4':
dudmuck 0:be215de91a68 1488 radio.RegDioMapping2.bits.Dio4Mapping++;
dudmuck 0:be215de91a68 1489 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping2.octet);
dudmuck 0:be215de91a68 1490 break;
dudmuck 0:be215de91a68 1491 case '5':
dudmuck 0:be215de91a68 1492 radio.RegDioMapping2.bits.Dio5Mapping++;
dudmuck 0:be215de91a68 1493 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping2.octet);
dudmuck 0:be215de91a68 1494 break;
dudmuck 0:be215de91a68 1495 } // ...switch (pcbuf[1])
dudmuck 1:1cd0afbed23c 1496 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1497 lora_print_dio();
dudmuck 1:1cd0afbed23c 1498 else
dudmuck 1:1cd0afbed23c 1499 fsk_print_dio();
dudmuck 0:be215de91a68 1500 } else if (pcbuf[0] == 's' && pcbuf[1] == 't' && pcbuf[2] == 'b') {
dudmuck 0:be215de91a68 1501 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 0:be215de91a68 1502 } else if (pcbuf[0] == 's' && pcbuf[1] == 'l' && pcbuf[2] == 'e') {
dudmuck 0:be215de91a68 1503 radio.set_opmode(RF_OPMODE_SLEEP);
dudmuck 0:be215de91a68 1504 } else if (pcbuf[0] == 'c' && pcbuf[1] == 'h' && pcbuf[2] == 'a') {
dudmuck 0:be215de91a68 1505 app = APP_CHAT;
dudmuck 1:1cd0afbed23c 1506 lora.start_rx();
dudmuck 0:be215de91a68 1507 printf("chat start\r\n");
dudmuck 0:be215de91a68 1508 }
dudmuck 0:be215de91a68 1509 }
dudmuck 0:be215de91a68 1510 printf("> ");
dudmuck 0:be215de91a68 1511 fflush(stdout);
dudmuck 0:be215de91a68 1512
dudmuck 0:be215de91a68 1513 }
dudmuck 0:be215de91a68 1514
dudmuck 0:be215de91a68 1515 int main()
dudmuck 0:be215de91a68 1516 {
dudmuck 0:be215de91a68 1517
dudmuck 0:be215de91a68 1518 pc.baud(57600);
dudmuck 0:be215de91a68 1519
dudmuck 0:be215de91a68 1520 radio.frfs = frfs;
dudmuck 0:be215de91a68 1521
dudmuck 0:be215de91a68 1522 while(1) {
dudmuck 0:be215de91a68 1523 switch (app) {
dudmuck 0:be215de91a68 1524 case APP_NONE:
dudmuck 0:be215de91a68 1525 console();
dudmuck 0:be215de91a68 1526 break;
dudmuck 0:be215de91a68 1527 case APP_CHAT:
dudmuck 0:be215de91a68 1528 console_chat();
dudmuck 0:be215de91a68 1529 break;
dudmuck 0:be215de91a68 1530 } // ...switch (app)
dudmuck 0:be215de91a68 1531 } // ...while(1)
dudmuck 0:be215de91a68 1532 }
dudmuck 0:be215de91a68 1533