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@2:c6b23a43a9d9, 2014-05-02 (annotated)

Committer:
dudmuck
Date:
Fri May 02 01:19:17 2014 +0000
Revision:
2:c6b23a43a9d9
Parent:
1:1cd0afbed23c
Child:
3:ab386fa756cc
brought FSK to proper functioning

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 0:be215de91a68 23 const uint32_t frfs[] = {
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 1:1cd0afbed23c 393 printf("PreambleLength:0x%03x ", lora.RegPreamble);
dudmuck 0:be215de91a68 394
dudmuck 0:be215de91a68 395
dudmuck 0:be215de91a68 396 if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER || radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER_SINGLE) {
dudmuck 0:be215de91a68 397 d = radio.read_reg(REG_LR_RSSIVALUE);
dudmuck 0:be215de91a68 398 printf("rssi:%ddBm ", d-120);
dudmuck 0:be215de91a68 399 }
dudmuck 0:be215de91a68 400
dudmuck 1:1cd0afbed23c 401 lora_printTxContinuousMode();
dudmuck 0:be215de91a68 402
dudmuck 0:be215de91a68 403 printf("\r\n");
dudmuck 1:1cd0afbed23c 404 lora_printAgcAutoOn();
dudmuck 0:be215de91a68 405 if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 406 printf(" LowDataRateOptimize:%d\r\n", lora.RegModemConfig.sx1272bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 407 }
dudmuck 0:be215de91a68 408
dudmuck 0:be215de91a68 409 printf("\r\nHeaderCount:%d PacketCount:%d, ",
dudmuck 0:be215de91a68 410 radio.read_u16(REG_LR_RXHEADERCNTVALUE_MSB), radio.read_u16(REG_LR_RXPACKETCNTVALUE_MSB));
dudmuck 0:be215de91a68 411
dudmuck 0:be215de91a68 412 printf("Lora detection threshold:%02x\r\n", radio.read_reg(REG_LR_DETECTION_THRESHOLD));
dudmuck 1:1cd0afbed23c 413 lora.RegTest31.octet = radio.read_reg(REG_LR_TEST31);
dudmuck 1:1cd0afbed23c 414 printf("detect_trig_same_peaks_nb:%d\r\n", lora.RegTest31.bits.detect_trig_same_peaks_nb);
dudmuck 0:be215de91a68 415
dudmuck 0:be215de91a68 416 if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 417 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 418 printf("LowDataRateOptimize:%d\r\n", lora.RegModemConfig.sx1272bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 419 } else if (radio.type == SX1276) {
dudmuck 1:1cd0afbed23c 420 lora.RegModemConfig3.octet = radio.read_reg(REG_LR_MODEMCONFIG3);
dudmuck 1:1cd0afbed23c 421 printf("LowDataRateOptimize:%d\r\n", lora.RegModemConfig3.sx1276bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 422 }
dudmuck 0:be215de91a68 423
dudmuck 0:be215de91a68 424 printf("\r\n");
dudmuck 0:be215de91a68 425 //printf("A %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 0:be215de91a68 426 }
dudmuck 0:be215de91a68 427
dudmuck 1:1cd0afbed23c 428 uint32_t fsk_get_bitrate(void)
dudmuck 1:1cd0afbed23c 429 {
dudmuck 1:1cd0afbed23c 430 uint16_t br = radio.read_u16(REG_FSK_BITRATEMSB);
dudmuck 1:1cd0afbed23c 431
dudmuck 1:1cd0afbed23c 432 if (br == 0)
dudmuck 1:1cd0afbed23c 433 return 0;
dudmuck 1:1cd0afbed23c 434 else
dudmuck 1:1cd0afbed23c 435 return XTAL_FREQ / br;
dudmuck 1:1cd0afbed23c 436 }
dudmuck 1:1cd0afbed23c 437
dudmuck 1:1cd0afbed23c 438 uint32_t fsk_get_tx_fdev_hz(void)
dudmuck 1:1cd0afbed23c 439 {
dudmuck 1:1cd0afbed23c 440 uint16_t fdev = radio.read_u16(REG_FSK_FDEVMSB);
dudmuck 1:1cd0afbed23c 441 return fdev * FREQ_STEP_HZ;
dudmuck 1:1cd0afbed23c 442 }
dudmuck 1:1cd0afbed23c 443
dudmuck 1:1cd0afbed23c 444 uint16_t
dudmuck 1:1cd0afbed23c 445 fsk_get_PayloadLength(void)
dudmuck 1:1cd0afbed23c 446 {
dudmuck 1:1cd0afbed23c 447 fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
dudmuck 1:1cd0afbed23c 448
dudmuck 1:1cd0afbed23c 449 return fsk.RegPktConfig2.bits.PayloadLength;
dudmuck 1:1cd0afbed23c 450 }
dudmuck 1:1cd0afbed23c 451
dudmuck 1:1cd0afbed23c 452 void fsk_printAddressFiltering()
dudmuck 1:1cd0afbed23c 453 {
dudmuck 1:1cd0afbed23c 454 uint8_t FSKRegNodeAdrs, FSKRegBroadcastAdrs;
dudmuck 1:1cd0afbed23c 455
dudmuck 1:1cd0afbed23c 456 printf(" AddressFiltering:");
dudmuck 1:1cd0afbed23c 457 switch (fsk.RegPktConfig1.bits.AddressFiltering) {
dudmuck 1:1cd0afbed23c 458 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 459 case 1: // NodeAddress
dudmuck 1:1cd0afbed23c 460 FSKRegNodeAdrs = radio.read_reg(REG_FSK_NODEADRS);
dudmuck 1:1cd0afbed23c 461 printf("NodeAdrs:%02x\n", FSKRegNodeAdrs);
dudmuck 1:1cd0afbed23c 462 break;
dudmuck 1:1cd0afbed23c 463 case 2: // NodeAddress & BroadcastAddress
dudmuck 1:1cd0afbed23c 464 FSKRegNodeAdrs = radio.read_reg(REG_FSK_NODEADRS);
dudmuck 1:1cd0afbed23c 465 printf("NodeAdrs:%02x ", FSKRegNodeAdrs);
dudmuck 1:1cd0afbed23c 466 FSKRegBroadcastAdrs = radio.read_reg(REG_FSK_BROADCASTADRS);
dudmuck 1:1cd0afbed23c 467 printf("BroadcastAdrs:%02x\n", FSKRegBroadcastAdrs );
dudmuck 1:1cd0afbed23c 468 break;
dudmuck 1:1cd0afbed23c 469 default:
dudmuck 1:1cd0afbed23c 470 printf("%d", fsk.RegPktConfig1.bits.AddressFiltering);
dudmuck 1:1cd0afbed23c 471 break;
dudmuck 1:1cd0afbed23c 472 }
dudmuck 1:1cd0afbed23c 473 }
dudmuck 1:1cd0afbed23c 474
dudmuck 1:1cd0afbed23c 475 void fsk_print_IrqFlags2()
dudmuck 1:1cd0afbed23c 476 {
dudmuck 2:c6b23a43a9d9 477 RegIrqFlags2_t RegIrqFlags2;
dudmuck 1:1cd0afbed23c 478
dudmuck 1:1cd0afbed23c 479 printf("IrqFlags2: ");
dudmuck 2:c6b23a43a9d9 480 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 481 if (RegIrqFlags2.bits.FifoFull)
dudmuck 1:1cd0afbed23c 482 printf("FifoFull ");
dudmuck 2:c6b23a43a9d9 483 if (RegIrqFlags2.bits.FifoEmpty)
dudmuck 1:1cd0afbed23c 484 printf("FifoEmpty ");
dudmuck 2:c6b23a43a9d9 485 if (RegIrqFlags2.bits.FifoLevel)
dudmuck 1:1cd0afbed23c 486 printf("FifoLevel ");
dudmuck 2:c6b23a43a9d9 487 if (RegIrqFlags2.bits.FifoOverrun)
dudmuck 1:1cd0afbed23c 488 printf("FifoOverrun ");
dudmuck 2:c6b23a43a9d9 489 if (RegIrqFlags2.bits.PacketSent)
dudmuck 1:1cd0afbed23c 490 printf("PacketSent ");
dudmuck 2:c6b23a43a9d9 491 if (RegIrqFlags2.bits.PayloadReady)
dudmuck 1:1cd0afbed23c 492 printf("PayloadReady ");
dudmuck 2:c6b23a43a9d9 493 if (RegIrqFlags2.bits.CrcOk)
dudmuck 1:1cd0afbed23c 494 printf("CrcOk ");
dudmuck 2:c6b23a43a9d9 495 if (RegIrqFlags2.bits.LowBat)
dudmuck 1:1cd0afbed23c 496 printf("LowBat ");
dudmuck 2:c6b23a43a9d9 497 printf("\r\n");
dudmuck 1:1cd0afbed23c 498 }
dudmuck 1:1cd0afbed23c 499
dudmuck 1:1cd0afbed23c 500 void
dudmuck 1:1cd0afbed23c 501 fsk_print_status()
dudmuck 1:1cd0afbed23c 502 {
dudmuck 1:1cd0afbed23c 503 //uint16_t s;
dudmuck 2:c6b23a43a9d9 504 RegIrqFlags1_t RegIrqFlags1;
dudmuck 1:1cd0afbed23c 505
dudmuck 1:1cd0afbed23c 506 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 507 printf("LoRa\r\n");
dudmuck 1:1cd0afbed23c 508 return;
dudmuck 1:1cd0afbed23c 509 }
dudmuck 1:1cd0afbed23c 510
dudmuck 1:1cd0afbed23c 511 if (radio.RegOpMode.bits.ModulationType == 0) {
dudmuck 1:1cd0afbed23c 512 printf("FSK ");
dudmuck 1:1cd0afbed23c 513 switch (radio.RegOpMode.bits.ModulationShaping) {
dudmuck 1:1cd0afbed23c 514 case 1: printf("BT1.0 "); break;
dudmuck 1:1cd0afbed23c 515 case 2: printf("BT0.5 "); break;
dudmuck 1:1cd0afbed23c 516 case 3: printf("BT0.3 "); break;
dudmuck 1:1cd0afbed23c 517 }
dudmuck 1:1cd0afbed23c 518 } else if (radio.RegOpMode.bits.ModulationType == 1) {
dudmuck 1:1cd0afbed23c 519 printf("OOK ");
dudmuck 1:1cd0afbed23c 520 }
dudmuck 1:1cd0afbed23c 521
dudmuck 1:1cd0afbed23c 522 printf("%dbps fdev:%dHz\r\n", fsk_get_bitrate(), fsk_get_tx_fdev_hz());
dudmuck 1:1cd0afbed23c 523
dudmuck 1:1cd0afbed23c 524 fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
dudmuck 1:1cd0afbed23c 525
dudmuck 1:1cd0afbed23c 526 fsk_print_dio();
dudmuck 1:1cd0afbed23c 527
dudmuck 1:1cd0afbed23c 528 printf("rxbw:%dHz ", fsk.get_rx_bw_hz(REG_FSK_RXBW));
dudmuck 1:1cd0afbed23c 529 printf("afcbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_AFCBW));
dudmuck 1:1cd0afbed23c 530
dudmuck 1:1cd0afbed23c 531 fsk.RegRssiConfig.octet = radio.read_reg(REG_FSK_RSSICONFIG);
dudmuck 1:1cd0afbed23c 532 printf("RssiOffset:%ddB smoothing:%dsamples\r\n", fsk.RegRssiConfig.bits.RssiOffset, 1 << (fsk.RegRssiConfig.bits.RssiSmoothing+1));
dudmuck 1:1cd0afbed23c 533
dudmuck 1:1cd0afbed23c 534
dudmuck 1:1cd0afbed23c 535 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 1:1cd0afbed23c 536
dudmuck 1:1cd0afbed23c 537 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 538 uint16_t len;
dudmuck 1:1cd0afbed23c 539 /* packet mode */
dudmuck 1:1cd0afbed23c 540 len = fsk_get_PayloadLength();
dudmuck 1:1cd0afbed23c 541 printf("packet RegPayloadLength:0x%03x ", len);
dudmuck 1:1cd0afbed23c 542
dudmuck 1:1cd0afbed23c 543 if (fsk.RegPktConfig2.bits.BeaconOn)
dudmuck 1:1cd0afbed23c 544 printf("BeaconOn ");
dudmuck 1:1cd0afbed23c 545
dudmuck 1:1cd0afbed23c 546 fsk.RegFifoThreshold.octet = radio.read_reg(REG_FSK_FIFOTHRESH);
dudmuck 1:1cd0afbed23c 547 printf("FifoThreshold:%d TxStartCondition:", fsk.RegFifoThreshold.bits.FifoThreshold);
dudmuck 1:1cd0afbed23c 548 if (fsk.RegFifoThreshold.bits.TxStartCondition)
dudmuck 1:1cd0afbed23c 549 printf("!FifoEmpty");
dudmuck 1:1cd0afbed23c 550 else
dudmuck 1:1cd0afbed23c 551 printf("FifoLevel");
dudmuck 1:1cd0afbed23c 552
dudmuck 1:1cd0afbed23c 553 printf("\r\nAutoRestartRxMode:");
dudmuck 1:1cd0afbed23c 554 switch (fsk.RegSyncConfig.bits.AutoRestartRxMode) {
dudmuck 1:1cd0afbed23c 555 case 0: printf("off "); break;
dudmuck 1:1cd0afbed23c 556 case 1: printf("no-pll-wait "); break;
dudmuck 1:1cd0afbed23c 557 case 2: printf("pll-wait "); break;
dudmuck 1:1cd0afbed23c 558 case 3: printf("3 "); break;
dudmuck 1:1cd0afbed23c 559 }
dudmuck 1:1cd0afbed23c 560 //...todo
dudmuck 1:1cd0afbed23c 561
dudmuck 1:1cd0afbed23c 562 printf("PreambleSize:%d ", radio.read_u16(REG_FSK_PREAMBLEMSB));
dudmuck 1:1cd0afbed23c 563
dudmuck 1:1cd0afbed23c 564 fsk.RegOokPeak.octet = radio.read_reg(REG_FSK_OOKPEAK);
dudmuck 1:1cd0afbed23c 565 if (fsk.RegOokPeak.bits.barker_en)
dudmuck 1:1cd0afbed23c 566 printf("barker ");
dudmuck 1:1cd0afbed23c 567 if (!fsk.RegOokPeak.bits.BitSyncOn)
dudmuck 1:1cd0afbed23c 568 printf("BitSyncOff ");
dudmuck 1:1cd0afbed23c 569 //...todo
dudmuck 1:1cd0afbed23c 570
dudmuck 1:1cd0afbed23c 571 fsk.RegPktConfig1.octet = radio.read_reg(REG_FSK_PACKETCONFIG1);
dudmuck 1:1cd0afbed23c 572 if (fsk.RegPktConfig1.bits.PacketFormatVariable)
dudmuck 1:1cd0afbed23c 573 printf("variable");
dudmuck 1:1cd0afbed23c 574 else
dudmuck 1:1cd0afbed23c 575 printf("fixed");
dudmuck 1:1cd0afbed23c 576 printf("-length\r\ncrc");
dudmuck 1:1cd0afbed23c 577 if (fsk.RegPktConfig1.bits.CrcOn) {
dudmuck 1:1cd0afbed23c 578 printf("On");
dudmuck 1:1cd0afbed23c 579 } else
dudmuck 1:1cd0afbed23c 580 printf("Off");
dudmuck 1:1cd0afbed23c 581 printf(" crctype:");
dudmuck 1:1cd0afbed23c 582 if (fsk.RegPktConfig1.bits.CrCWhiteningType)
dudmuck 1:1cd0afbed23c 583 printf("IBM");
dudmuck 1:1cd0afbed23c 584 else
dudmuck 1:1cd0afbed23c 585 printf("CCITT");
dudmuck 1:1cd0afbed23c 586 printf(" dcFree:");
dudmuck 1:1cd0afbed23c 587 switch (fsk.RegPktConfig1.bits.DcFree) {
dudmuck 1:1cd0afbed23c 588 case 0: printf("none "); break;
dudmuck 1:1cd0afbed23c 589 case 1: printf("Manchester "); break;
dudmuck 1:1cd0afbed23c 590 case 2: printf("Whitening "); break;
dudmuck 1:1cd0afbed23c 591 case 3: printf("reserved "); break;
dudmuck 1:1cd0afbed23c 592 }
dudmuck 1:1cd0afbed23c 593 fsk_printAddressFiltering();
dudmuck 1:1cd0afbed23c 594
dudmuck 1:1cd0afbed23c 595 printf("\r\n");
dudmuck 1:1cd0afbed23c 596 fsk_print_IrqFlags2();
dudmuck 1:1cd0afbed23c 597 } else {
dudmuck 1:1cd0afbed23c 598 /* continuous mode */
dudmuck 1:1cd0afbed23c 599 printf("continuous ");
dudmuck 1:1cd0afbed23c 600 }
dudmuck 1:1cd0afbed23c 601
dudmuck 1:1cd0afbed23c 602 fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
dudmuck 1:1cd0afbed23c 603 printf("PreambleDetect:");
dudmuck 1:1cd0afbed23c 604 if (fsk.RegPreambleDetect.bits.PreambleDetectorOn) {
dudmuck 1:1cd0afbed23c 605 printf("size=%d,tol=%d ",
dudmuck 1:1cd0afbed23c 606 fsk.RegPreambleDetect.bits.PreambleDetectorSize,
dudmuck 1:1cd0afbed23c 607 fsk.RegPreambleDetect.bits.PreambleDetectorTol);
dudmuck 1:1cd0afbed23c 608 } else
dudmuck 1:1cd0afbed23c 609 printf("Off ");
dudmuck 1:1cd0afbed23c 610
dudmuck 1:1cd0afbed23c 611 printf(" syncsize:%d ", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 1:1cd0afbed23c 612 printf(" : %02x ", radio.read_reg(REG_FSK_SYNCVALUE1));
dudmuck 1:1cd0afbed23c 613 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE2));
dudmuck 1:1cd0afbed23c 614 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE3));
dudmuck 1:1cd0afbed23c 615 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE4));
dudmuck 1:1cd0afbed23c 616 printf("\r\n"); // end sync config
dudmuck 1:1cd0afbed23c 617
dudmuck 1:1cd0afbed23c 618 fsk.RegAfcFei.octet = radio.read_reg(REG_FSK_AFCFEI);
dudmuck 1:1cd0afbed23c 619 printf("afcAutoClear:");
dudmuck 1:1cd0afbed23c 620 if (fsk.RegAfcFei.bits.AfcAutoClearOn)
dudmuck 1:1cd0afbed23c 621 printf("On");
dudmuck 1:1cd0afbed23c 622 else
dudmuck 1:1cd0afbed23c 623 printf("OFF");
dudmuck 1:1cd0afbed23c 624 printf(" afc:%dHz ", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_AFCMSB)));
dudmuck 1:1cd0afbed23c 625
dudmuck 1:1cd0afbed23c 626 printf("fei:%dHz\r\n", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_FEIMSB)));
dudmuck 1:1cd0afbed23c 627
dudmuck 1:1cd0afbed23c 628 fsk.RegRxConfig.octet = radio.read_reg(REG_FSK_RXCONFIG);
dudmuck 1:1cd0afbed23c 629 printf("RxTrigger:");
dudmuck 1:1cd0afbed23c 630 switch (fsk.RegRxConfig.bits.RxTrigger) {
dudmuck 1:1cd0afbed23c 631 case 0: printf("none "); break;
dudmuck 1:1cd0afbed23c 632 case 1: printf("rssi "); break;
dudmuck 1:1cd0afbed23c 633 case 6: printf("preamble "); break;
dudmuck 1:1cd0afbed23c 634 case 7: printf("both "); break;
dudmuck 1:1cd0afbed23c 635 default: printf("-%d- ", fsk.RegRxConfig.bits.RxTrigger); break;
dudmuck 1:1cd0afbed23c 636 }
dudmuck 1:1cd0afbed23c 637 printf("AfcAuto:");
dudmuck 1:1cd0afbed23c 638 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 1:1cd0afbed23c 639 printf("On ");
dudmuck 1:1cd0afbed23c 640 else
dudmuck 1:1cd0afbed23c 641 printf("OFF ");
dudmuck 1:1cd0afbed23c 642 if (!fsk.RegRxConfig.bits.AgcAutoOn) {
dudmuck 1:1cd0afbed23c 643 radio.RegLna.octet = radio.read_reg(REG_LNA);
dudmuck 1:1cd0afbed23c 644 printf("AgcAutoOff:G%d ", radio.RegLna.bits.LnaGain);
dudmuck 1:1cd0afbed23c 645 }
dudmuck 1:1cd0afbed23c 646
dudmuck 1:1cd0afbed23c 647 fsk.RegTimerResol.octet = radio.read_reg(REG_FSK_TIMERRESOL);
dudmuck 1:1cd0afbed23c 648 if (fsk.RegTimerResol.bits.hlm_started)
dudmuck 1:1cd0afbed23c 649 printf("hlm_started ");
dudmuck 1:1cd0afbed23c 650 else
dudmuck 1:1cd0afbed23c 651 printf("hlm_stopped ");
dudmuck 1:1cd0afbed23c 652
dudmuck 1:1cd0afbed23c 653 fsk.RegRssiThresh = radio.read_reg(REG_FSK_RSSITHRESH);
dudmuck 1:1cd0afbed23c 654 printf("rssiThreshold:-%.1f@%02x ", fsk.RegRssiThresh / 2.0, REG_FSK_RSSITHRESH);
dudmuck 1:1cd0afbed23c 655
dudmuck 1:1cd0afbed23c 656 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 1:1cd0afbed23c 657 if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER ||
dudmuck 1:1cd0afbed23c 658 radio.RegOpMode.bits.Mode == RF_OPMODE_SYNTHESIZER_RX)
dudmuck 1:1cd0afbed23c 659 {
dudmuck 1:1cd0afbed23c 660 printf("rssi:-%.1f ", radio.read_reg(REG_FSK_RSSIVALUE) / 2.0);
dudmuck 1:1cd0afbed23c 661 }
dudmuck 1:1cd0afbed23c 662
dudmuck 1:1cd0afbed23c 663 fsk.RegSeqConfig1.octet = radio.read_reg(REG_FSK_SEQCONFIG1);
dudmuck 1:1cd0afbed23c 664 printf("\r\nsequencer: ");
dudmuck 1:1cd0afbed23c 665 printf("FromStart:");
dudmuck 1:1cd0afbed23c 666 switch (fsk.RegSeqConfig1.bits.FromStart) {
dudmuck 1:1cd0afbed23c 667 case 0:
dudmuck 1:1cd0afbed23c 668 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 669 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 670 printf("idle");
dudmuck 1:1cd0afbed23c 671 else
dudmuck 1:1cd0afbed23c 672 printf("sequencerOff");
dudmuck 1:1cd0afbed23c 673 break;
dudmuck 1:1cd0afbed23c 674 case 1: printf("rx"); break;
dudmuck 1:1cd0afbed23c 675 case 2: printf("tx"); break;
dudmuck 1:1cd0afbed23c 676 case 3: printf("tx on fifolevel"); break;
dudmuck 1:1cd0afbed23c 677 }
dudmuck 1:1cd0afbed23c 678 printf(" lowPowerSelection:");
dudmuck 1:1cd0afbed23c 679 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 680 printf("idle");
dudmuck 1:1cd0afbed23c 681 else
dudmuck 1:1cd0afbed23c 682 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 683 if (fsk.RegSeqConfig1.bits.FromStart != 0 &&
dudmuck 1:1cd0afbed23c 684 fsk.RegSeqConfig1.bits.LowPowerSelection != 0)
dudmuck 1:1cd0afbed23c 685 { // if sequencer enabled:
dudmuck 1:1cd0afbed23c 686 printf("\r\nsequencer: IdleMode:");
dudmuck 1:1cd0afbed23c 687 if (fsk.RegSeqConfig1.bits.IdleMode)
dudmuck 1:1cd0afbed23c 688 printf("Sleep");
dudmuck 1:1cd0afbed23c 689 else
dudmuck 1:1cd0afbed23c 690 printf("standby");
dudmuck 1:1cd0afbed23c 691 printf("\r\nsequencer: FromIdle to:");
dudmuck 1:1cd0afbed23c 692 if (fsk.RegSeqConfig1.bits.FromIdle)
dudmuck 1:1cd0afbed23c 693 printf("rx");
dudmuck 1:1cd0afbed23c 694 else
dudmuck 1:1cd0afbed23c 695 printf("tx");
dudmuck 1:1cd0afbed23c 696 printf("\r\nsequencer: FromTransmit to:");
dudmuck 1:1cd0afbed23c 697 if (fsk.RegSeqConfig1.bits.FromTransmit)
dudmuck 1:1cd0afbed23c 698 printf("rx-on-PacketSent");
dudmuck 1:1cd0afbed23c 699 else {
dudmuck 1:1cd0afbed23c 700 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 701 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 702 printf("idle");
dudmuck 1:1cd0afbed23c 703 else
dudmuck 1:1cd0afbed23c 704 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 705 printf("-on-PacketSent");
dudmuck 1:1cd0afbed23c 706 }
dudmuck 1:1cd0afbed23c 707 fsk.RegSeqConfig2.octet = radio.read_reg(REG_FSK_SEQCONFIG2);
dudmuck 1:1cd0afbed23c 708 printf("\r\nsequencer: FromReceive:");
dudmuck 1:1cd0afbed23c 709 switch (fsk.RegSeqConfig2.bits.FromReceive) {
dudmuck 1:1cd0afbed23c 710 case 1: printf("PacketRecevied on PayloadReady"); break;
dudmuck 1:1cd0afbed23c 711 case 2:
dudmuck 1:1cd0afbed23c 712 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 713 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 714 printf("idle");
dudmuck 1:1cd0afbed23c 715 else
dudmuck 1:1cd0afbed23c 716 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 717 printf("-on-payloadReady");
dudmuck 1:1cd0afbed23c 718 break;
dudmuck 1:1cd0afbed23c 719 case 3: printf("PacketRecevied-on-CrcOk"); break;
dudmuck 1:1cd0afbed23c 720 case 4: printf("SequencerOff-on-Rssi"); break;
dudmuck 1:1cd0afbed23c 721 case 5: printf("SequencerOff-on-SyncAddress"); break;
dudmuck 1:1cd0afbed23c 722 case 6: printf("SequencerOff-PreambleDetect"); break;
dudmuck 1:1cd0afbed23c 723 default: printf("-%d-", fsk.RegSeqConfig2.bits.FromReceive); break;
dudmuck 1:1cd0afbed23c 724 }
dudmuck 1:1cd0afbed23c 725 printf("\r\nsequencer: FromRxTimeout:");
dudmuck 1:1cd0afbed23c 726 switch (fsk.RegSeqConfig2.bits.FromRxTimeout) {
dudmuck 1:1cd0afbed23c 727 case 0: printf("rx"); break;
dudmuck 1:1cd0afbed23c 728 case 1: printf("tx"); break;
dudmuck 1:1cd0afbed23c 729 case 2:
dudmuck 1:1cd0afbed23c 730 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 731 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 732 printf("idle");
dudmuck 1:1cd0afbed23c 733 else
dudmuck 1:1cd0afbed23c 734 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 735 break;
dudmuck 1:1cd0afbed23c 736 case 3: printf("SequencerOff"); break;
dudmuck 1:1cd0afbed23c 737 }
dudmuck 1:1cd0afbed23c 738 printf("\r\nsequencer: FromPacketReceived to:");
dudmuck 1:1cd0afbed23c 739 switch (fsk.RegSeqConfig2.bits.FromPacketReceived) {
dudmuck 1:1cd0afbed23c 740 case 0: printf("SequencerOff"); break;
dudmuck 1:1cd0afbed23c 741 case 1: printf("tx on FifoEmpty"); break;
dudmuck 1:1cd0afbed23c 742 case 2:
dudmuck 1:1cd0afbed23c 743 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 744 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 745 printf("idle");
dudmuck 1:1cd0afbed23c 746 else
dudmuck 1:1cd0afbed23c 747 printf("sequencerOff");
dudmuck 1:1cd0afbed23c 748 break;
dudmuck 1:1cd0afbed23c 749 case 3: printf("rx via fs"); break;
dudmuck 1:1cd0afbed23c 750 case 4: printf("rx"); break;
dudmuck 1:1cd0afbed23c 751 }
dudmuck 1:1cd0afbed23c 752
dudmuck 1:1cd0afbed23c 753 fsk.RegTimerResol.octet = radio.read_reg(REG_FSK_TIMERRESOL);
dudmuck 1:1cd0afbed23c 754 printf("\r\nsequencer: timer1:");
dudmuck 1:1cd0afbed23c 755 switch (fsk.RegTimerResol.bits.timer1_resol) {
dudmuck 1:1cd0afbed23c 756 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 757 case 1: printf("%dus", radio.read_reg(REG_FSK_TIMER1COEF) * 64); break;
dudmuck 1:1cd0afbed23c 758 case 2: printf("%.1fms", radio.read_reg(REG_FSK_TIMER1COEF) * 4.1); break;
dudmuck 1:1cd0afbed23c 759 case 3: printf("%.1fs", radio.read_reg(REG_FSK_TIMER1COEF) * 0.262); break;
dudmuck 1:1cd0afbed23c 760 }
dudmuck 1:1cd0afbed23c 761
dudmuck 1:1cd0afbed23c 762 printf(" timer2:");
dudmuck 1:1cd0afbed23c 763 switch (fsk.RegTimerResol.bits.timer2_resol) {
dudmuck 1:1cd0afbed23c 764 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 765 case 1: printf("%dus", radio.read_reg(REG_FSK_TIMER2COEF) * 64); break;
dudmuck 1:1cd0afbed23c 766 case 2: printf("%.1fms", radio.read_reg(REG_FSK_TIMER2COEF) * 4.1); break;
dudmuck 1:1cd0afbed23c 767 case 3: printf("%.1fs", radio.read_reg(REG_FSK_TIMER2COEF) * 0.262); break;
dudmuck 1:1cd0afbed23c 768 }
dudmuck 1:1cd0afbed23c 769 } // ..if sequencer enabled
dudmuck 1:1cd0afbed23c 770
dudmuck 1:1cd0afbed23c 771 printf("\r\nIrqFlags1:");
dudmuck 2:c6b23a43a9d9 772 RegIrqFlags1.octet = radio.read_reg(REG_FSK_IRQFLAGS1);
dudmuck 2:c6b23a43a9d9 773 if (RegIrqFlags1.bits.ModeReady)
dudmuck 1:1cd0afbed23c 774 printf("ModeReady ");
dudmuck 2:c6b23a43a9d9 775 if (RegIrqFlags1.bits.RxReady)
dudmuck 1:1cd0afbed23c 776 printf("RxReady ");
dudmuck 2:c6b23a43a9d9 777 if (RegIrqFlags1.bits.TxReady)
dudmuck 1:1cd0afbed23c 778 printf("TxReady ");
dudmuck 2:c6b23a43a9d9 779 if (RegIrqFlags1.bits.PllLock)
dudmuck 1:1cd0afbed23c 780 printf("PllLock ");
dudmuck 2:c6b23a43a9d9 781 if (RegIrqFlags1.bits.Rssi)
dudmuck 1:1cd0afbed23c 782 printf("Rssi ");
dudmuck 2:c6b23a43a9d9 783 if (RegIrqFlags1.bits.Timeout)
dudmuck 1:1cd0afbed23c 784 printf("Timeout ");
dudmuck 2:c6b23a43a9d9 785 if (RegIrqFlags1.bits.PreambleDetect)
dudmuck 1:1cd0afbed23c 786 printf("PreambleDetect ");
dudmuck 2:c6b23a43a9d9 787 if (RegIrqFlags1.bits.SyncAddressMatch)
dudmuck 1:1cd0afbed23c 788 printf("SyncAddressMatch ");
dudmuck 1:1cd0afbed23c 789
dudmuck 1:1cd0afbed23c 790 printf("\r\n");
dudmuck 1:1cd0afbed23c 791
dudmuck 1:1cd0afbed23c 792 /* TODO if (!SX1272FSK->RegPktConfig1.bits.PacketFormatVariable) { // if fixed-length packet format:
dudmuck 1:1cd0afbed23c 793 s = fsk_get_PayloadLength();
dudmuck 1:1cd0afbed23c 794 if (s > FSK_LARGE_PKT_THRESHOLD)
dudmuck 1:1cd0afbed23c 795 flags.fifo_flow_ctl = 1;
dudmuck 1:1cd0afbed23c 796 else
dudmuck 1:1cd0afbed23c 797 flags.fifo_flow_ctl = 0;
dudmuck 1:1cd0afbed23c 798 }*/
dudmuck 1:1cd0afbed23c 799
dudmuck 1:1cd0afbed23c 800 fsk.RegImageCal.octet = radio.read_reg(REG_FSK_IMAGECAL);
dudmuck 1:1cd0afbed23c 801 if (fsk.RegImageCal.bits.TempMonitorOff) {
dudmuck 1:1cd0afbed23c 802 printf("TempMonitorOff[\r0m\n");
dudmuck 1:1cd0afbed23c 803 } else {
dudmuck 1:1cd0afbed23c 804 printf("TempThreshold:");
dudmuck 1:1cd0afbed23c 805 switch (fsk.RegImageCal.bits.TempThreshold) {
dudmuck 1:1cd0afbed23c 806 case 0: printf("5C"); break;
dudmuck 1:1cd0afbed23c 807 case 1: printf("10C"); break;
dudmuck 1:1cd0afbed23c 808 case 2: printf("15C"); break;
dudmuck 1:1cd0afbed23c 809 case 3: printf("20C"); break;
dudmuck 1:1cd0afbed23c 810 }
dudmuck 1:1cd0afbed23c 811 printf("\r\n");
dudmuck 1:1cd0afbed23c 812 }
dudmuck 1:1cd0afbed23c 813 if (fsk.RegImageCal.bits.ImageCalRunning)
dudmuck 1:1cd0afbed23c 814 printf("ImageCalRunning[\r0m\n");
dudmuck 1:1cd0afbed23c 815
dudmuck 1:1cd0afbed23c 816 /* printf("flags.fifo_flow_ctl:%d pktidx:%d rx_pktlen:%d", flags.fifo_flow_ctl, pktidx, rx_pktlen);
dudmuck 1:1cd0afbed23c 817 printf("\n");
dudmuck 1:1cd0afbed23c 818
dudmuck 1:1cd0afbed23c 819 //printf("DIO0_PIN:%d\n", digitalRead(DIO0_PIN));
dudmuck 1:1cd0afbed23c 820 printf("pkt_buf_len=%d remaining=%d\n", pk*/
dudmuck 1:1cd0afbed23c 821 }
dudmuck 1:1cd0afbed23c 822
dudmuck 0:be215de91a68 823 void printOpMode()
dudmuck 0:be215de91a68 824 {
dudmuck 0:be215de91a68 825 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:be215de91a68 826 switch (radio.RegOpMode.bits.Mode) {
dudmuck 0:be215de91a68 827 case RF_OPMODE_SLEEP: printf("sleep"); break;
dudmuck 0:be215de91a68 828 case RF_OPMODE_STANDBY: printf("stby"); break;
dudmuck 0:be215de91a68 829 case RF_OPMODE_SYNTHESIZER_TX: printf("fstx"); break;
dudmuck 0:be215de91a68 830 case RF_OPMODE_TRANSMITTER: printf("tx"); break;
dudmuck 0:be215de91a68 831 case RF_OPMODE_SYNTHESIZER_RX: printf("fsrx"); break;
dudmuck 0:be215de91a68 832 case RF_OPMODE_RECEIVER: printf("rx"); break;
dudmuck 0:be215de91a68 833 case 6:
dudmuck 0:be215de91a68 834 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:be215de91a68 835 printf("rxs");
dudmuck 0:be215de91a68 836 else
dudmuck 0:be215de91a68 837 printf("-6-");
dudmuck 0:be215de91a68 838 break; // todo: different lora/fsk
dudmuck 0:be215de91a68 839 case 7:
dudmuck 0:be215de91a68 840 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:be215de91a68 841 printf("cad");
dudmuck 0:be215de91a68 842 else
dudmuck 0:be215de91a68 843 printf("-7-");
dudmuck 0:be215de91a68 844 break; // todo: different lora/fsk
dudmuck 0:be215de91a68 845 }
dudmuck 0:be215de91a68 846 }
dudmuck 0:be215de91a68 847
dudmuck 0:be215de91a68 848 void
dudmuck 0:be215de91a68 849 printPa()
dudmuck 0:be215de91a68 850 {
dudmuck 0:be215de91a68 851 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:be215de91a68 852 if (radio.RegPaConfig.bits.PaSelect) {
dudmuck 0:be215de91a68 853 float output_dBm = 17 - (15-radio.RegPaConfig.bits.OutputPower);
dudmuck 0:be215de91a68 854 printf(" PABOOST OutputPower=%.1fdBm", output_dBm);
dudmuck 0:be215de91a68 855 } else {
dudmuck 0:be215de91a68 856 float pmax = (0.6*radio.RegPaConfig.bits.MaxPower) + 10.8;
dudmuck 0:be215de91a68 857 float output_dBm = pmax - (15-radio.RegPaConfig.bits.OutputPower);
dudmuck 0:be215de91a68 858 printf(" RFO pmax=%.1fdBm OutputPower=%.1fdBm", pmax, output_dBm);
dudmuck 0:be215de91a68 859 }
dudmuck 0:be215de91a68 860 }
dudmuck 0:be215de91a68 861
dudmuck 0:be215de91a68 862 void /* things always present, whether lora or fsk */
dudmuck 0:be215de91a68 863 common_print_status()
dudmuck 0:be215de91a68 864 {
dudmuck 0:be215de91a68 865 printf("version:0x%02x %.3fMHz ", radio.read_reg(REG_VERSION), radio.get_frf_MHz());
dudmuck 0:be215de91a68 866 printOpMode();
dudmuck 0:be215de91a68 867
dudmuck 0:be215de91a68 868 printPa();
dudmuck 0:be215de91a68 869
dudmuck 0:be215de91a68 870 radio.RegOcp.octet = radio.read_reg(REG_OCP);
dudmuck 0:be215de91a68 871 if (radio.RegOcp.bits.OcpOn) {
dudmuck 0:be215de91a68 872 int imax = 0;
dudmuck 0:be215de91a68 873 if (radio.RegOcp.bits.OcpTrim < 16)
dudmuck 0:be215de91a68 874 imax = 45 + (5 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:be215de91a68 875 else if (radio.RegOcp.bits.OcpTrim < 28)
dudmuck 0:be215de91a68 876 imax = -30 + (10 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:be215de91a68 877 else
dudmuck 0:be215de91a68 878 imax = 240;
dudmuck 0:be215de91a68 879 printf(" OcpOn %dmA ", imax);
dudmuck 0:be215de91a68 880 } else
dudmuck 0:be215de91a68 881 printf(" OcpOFF ");
dudmuck 0:be215de91a68 882
dudmuck 0:be215de91a68 883 printf("\r\n");
dudmuck 0:be215de91a68 884
dudmuck 0:be215de91a68 885 }
dudmuck 0:be215de91a68 886
dudmuck 0:be215de91a68 887 void print_rx_buf(int len)
dudmuck 0:be215de91a68 888 {
dudmuck 0:be215de91a68 889 int i;
dudmuck 0:be215de91a68 890
dudmuck 0:be215de91a68 891 printf("000:");
dudmuck 0:be215de91a68 892 for (i = 0; i < len; i++) {
dudmuck 0:be215de91a68 893 //printf("(%d)%02x ", i % 16, rx_buf[i]);
dudmuck 0:be215de91a68 894 printf("%02x ", radio.rx_buf[i]);
dudmuck 0:be215de91a68 895 if (i % 16 == 15 && i != len-1)
dudmuck 0:be215de91a68 896 printf("\r\n%03d:", i+1);
dudmuck 0:be215de91a68 897
dudmuck 0:be215de91a68 898 }
dudmuck 0:be215de91a68 899 printf("\r\n");
dudmuck 0:be215de91a68 900 }
dudmuck 0:be215de91a68 901
dudmuck 0:be215de91a68 902 void
dudmuck 0:be215de91a68 903 service_radio()
dudmuck 0:be215de91a68 904 {
dudmuck 1:1cd0afbed23c 905 service_action_e act;
dudmuck 1:1cd0afbed23c 906
dudmuck 1:1cd0afbed23c 907 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 908 act = lora.service();
dudmuck 0:be215de91a68 909
dudmuck 1:1cd0afbed23c 910 switch (act) {
dudmuck 1:1cd0afbed23c 911 case SERVICE_READ_FIFO:
dudmuck 1:1cd0afbed23c 912 float dbm;
dudmuck 1:1cd0afbed23c 913 if (app == APP_NONE) {
dudmuck 1:1cd0afbed23c 914 printLoraIrqs_(false);
dudmuck 1:1cd0afbed23c 915 if (lora.RegHopPeriod > 0) {
dudmuck 1:1cd0afbed23c 916 lora.RegHopChannel.octet = radio.read_reg(REG_LR_HOPCHANNEL);
dudmuck 1:1cd0afbed23c 917 printf("HopCH:%d ", lora.RegHopChannel.bits.FhssPresentChannel);
dudmuck 1:1cd0afbed23c 918 }
dudmuck 1:1cd0afbed23c 919 lora_printCodingRate(true); // true: of received packet
dudmuck 1:1cd0afbed23c 920 dbm = lora.get_pkt_rssi();
dudmuck 1:1cd0afbed23c 921 printf(" crc%s %.1fdB %.1fdBm\r\n",
dudmuck 1:1cd0afbed23c 922 lora.RegHopChannel.bits.RxPayloadCrcOn ? "On" : "OFF",
dudmuck 1:1cd0afbed23c 923 lora.RegPktSnrValue / 4.0,
dudmuck 1:1cd0afbed23c 924 dbm
dudmuck 1:1cd0afbed23c 925 );
dudmuck 1:1cd0afbed23c 926 print_rx_buf(lora.RegRxNbBytes);
dudmuck 1:1cd0afbed23c 927 } else if (app == APP_CHAT) {
dudmuck 1:1cd0afbed23c 928 if (lora.RegHopChannel.bits.RxPayloadCrcOn) {
dudmuck 1:1cd0afbed23c 929 if (lora.RegIrqFlags.bits.PayloadCrcError)
dudmuck 1:1cd0afbed23c 930 printf("crcError\r\n");
dudmuck 1:1cd0afbed23c 931 else {
dudmuck 1:1cd0afbed23c 932 int n = lora.RegRxNbBytes;
dudmuck 1:1cd0afbed23c 933 radio.rx_buf[n++] = '\r';
dudmuck 1:1cd0afbed23c 934 radio.rx_buf[n++] = '\n';
dudmuck 1:1cd0afbed23c 935 radio.rx_buf[n] = 0; // null terminate
dudmuck 1:1cd0afbed23c 936 printf((char *)radio.rx_buf);
dudmuck 1:1cd0afbed23c 937 }
dudmuck 1:1cd0afbed23c 938 } else
dudmuck 1:1cd0afbed23c 939 printf("crcOff\r\n");
dudmuck 1:1cd0afbed23c 940
dudmuck 1:1cd0afbed23c 941 // clear Irq flags
dudmuck 1:1cd0afbed23c 942 radio.write_reg(REG_LR_IRQFLAGS, lora.RegIrqFlags.octet);
dudmuck 1:1cd0afbed23c 943 // should still be in receive mode
dudmuck 0:be215de91a68 944 }
dudmuck 1:1cd0afbed23c 945 break;
dudmuck 1:1cd0afbed23c 946 case SERVICE_TX_DONE:
dudmuck 1:1cd0afbed23c 947 if (app == APP_CHAT) {
dudmuck 1:1cd0afbed23c 948 lora.start_rx();
dudmuck 1:1cd0afbed23c 949 }
dudmuck 1:1cd0afbed23c 950 break;
dudmuck 1:1cd0afbed23c 951 case SERVICE_ERROR:
dudmuck 1:1cd0afbed23c 952 printf("error\r\n");
dudmuck 1:1cd0afbed23c 953 break;
dudmuck 1:1cd0afbed23c 954 } // ...switch (act)
dudmuck 1:1cd0afbed23c 955 } else {
dudmuck 1:1cd0afbed23c 956 /* FSK: */
dudmuck 1:1cd0afbed23c 957 act = fsk.service();
dudmuck 1:1cd0afbed23c 958
dudmuck 1:1cd0afbed23c 959 switch (act) {
dudmuck 1:1cd0afbed23c 960 case SERVICE_READ_FIFO:
dudmuck 2:c6b23a43a9d9 961 if (app == APP_CHAT) {
dudmuck 2:c6b23a43a9d9 962 int n = fsk.rx_buf_length;
dudmuck 2:c6b23a43a9d9 963 radio.rx_buf[n++] = '\r';
dudmuck 2:c6b23a43a9d9 964 radio.rx_buf[n++] = '\n';
dudmuck 2:c6b23a43a9d9 965 radio.rx_buf[n] = 0; // null terminate
dudmuck 2:c6b23a43a9d9 966 printf((char *)radio.rx_buf);
dudmuck 2:c6b23a43a9d9 967 } else {
dudmuck 2:c6b23a43a9d9 968 int i;
dudmuck 2:c6b23a43a9d9 969 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 2:c6b23a43a9d9 970 printf("%dHz ", (int)(FREQ_STEP_HZ * fsk.RegAfcValue));
dudmuck 2:c6b23a43a9d9 971 printf("%d: ", fsk.rx_buf_length);
dudmuck 2:c6b23a43a9d9 972 for (i = 0; i < fsk.rx_buf_length; i++)
dudmuck 2:c6b23a43a9d9 973 printf("%02x ", radio.rx_buf[i]);
dudmuck 2:c6b23a43a9d9 974 printf("\r\n");
dudmuck 2:c6b23a43a9d9 975 }
dudmuck 1:1cd0afbed23c 976 break;
dudmuck 2:c6b23a43a9d9 977 case SERVICE_TX_DONE:
dudmuck 2:c6b23a43a9d9 978 if (app == APP_CHAT) {
dudmuck 2:c6b23a43a9d9 979 fsk.start_rx();
dudmuck 2:c6b23a43a9d9 980 }
dudmuck 2:c6b23a43a9d9 981 break;
dudmuck 1:1cd0afbed23c 982 } // ...switch (act)
dudmuck 1:1cd0afbed23c 983 }
dudmuck 0:be215de91a68 984 }
dudmuck 0:be215de91a68 985
dudmuck 0:be215de91a68 986 void user_init(void)
dudmuck 0:be215de91a68 987 {
dudmuck 0:be215de91a68 988 // set desired spreadingfactor, bandwidth, MHz, etc.
dudmuck 0:be215de91a68 989 }
dudmuck 0:be215de91a68 990
dudmuck 0:be215de91a68 991 int get_kbd_str(char* buf, int size)
dudmuck 0:be215de91a68 992 {
dudmuck 0:be215de91a68 993 char c;
dudmuck 0:be215de91a68 994 int i;
dudmuck 0:be215de91a68 995 static int prev_len;
dudmuck 0:be215de91a68 996
dudmuck 0:be215de91a68 997 for (i = 0;;) {
dudmuck 0:be215de91a68 998 if (pc.readable()) {
dudmuck 0:be215de91a68 999 c = pc.getc();
dudmuck 0:be215de91a68 1000 if (c == 8 && i > 0) {
dudmuck 0:be215de91a68 1001 pc.putc(8);
dudmuck 0:be215de91a68 1002 pc.putc(' ');
dudmuck 0:be215de91a68 1003 pc.putc(8);
dudmuck 0:be215de91a68 1004 i--;
dudmuck 0:be215de91a68 1005 } else if (c == '\r') {
dudmuck 0:be215de91a68 1006 if (i == 0) {
dudmuck 0:be215de91a68 1007 return prev_len; // repeat previous
dudmuck 0:be215de91a68 1008 } else {
dudmuck 0:be215de91a68 1009 buf[i] = 0; // null terminate
dudmuck 0:be215de91a68 1010 prev_len = i;
dudmuck 0:be215de91a68 1011 return i;
dudmuck 0:be215de91a68 1012 }
dudmuck 0:be215de91a68 1013 } else if (c == 3) {
dudmuck 0:be215de91a68 1014 // ctrl-C abort
dudmuck 0:be215de91a68 1015 return -1;
dudmuck 0:be215de91a68 1016 } else if (i < size) {
dudmuck 0:be215de91a68 1017 buf[i++] = c;
dudmuck 0:be215de91a68 1018 pc.putc(c);
dudmuck 0:be215de91a68 1019 }
dudmuck 0:be215de91a68 1020 } else
dudmuck 0:be215de91a68 1021 service_radio();
dudmuck 0:be215de91a68 1022 } // ...for()
dudmuck 0:be215de91a68 1023 }
dudmuck 0:be215de91a68 1024
dudmuck 0:be215de91a68 1025 void
dudmuck 0:be215de91a68 1026 console_chat()
dudmuck 0:be215de91a68 1027 {
dudmuck 0:be215de91a68 1028 int i, len = get_kbd_str(pcbuf, sizeof(pcbuf));
dudmuck 0:be215de91a68 1029 if (len < 0) {
dudmuck 0:be215de91a68 1030 printf("chat abort\r\n");
dudmuck 0:be215de91a68 1031 app = APP_NONE;
dudmuck 0:be215de91a68 1032 return;
dudmuck 0:be215de91a68 1033 } else {
dudmuck 0:be215de91a68 1034 for (i = 0; i < len; i++)
dudmuck 0:be215de91a68 1035 radio.tx_buf[i] = pcbuf[i];
dudmuck 1:1cd0afbed23c 1036 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1037 lora.RegPayloadLength = len;
dudmuck 1:1cd0afbed23c 1038 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 1:1cd0afbed23c 1039 lora.start_tx(len);
dudmuck 2:c6b23a43a9d9 1040 } else {
dudmuck 2:c6b23a43a9d9 1041 fsk.start_tx(len);
dudmuck 2:c6b23a43a9d9 1042 }
dudmuck 0:be215de91a68 1043 printf("\r\n");
dudmuck 0:be215de91a68 1044 }
dudmuck 0:be215de91a68 1045 }
dudmuck 0:be215de91a68 1046
dudmuck 0:be215de91a68 1047 void
dudmuck 0:be215de91a68 1048 console()
dudmuck 0:be215de91a68 1049 {
dudmuck 0:be215de91a68 1050 int len, i;
dudmuck 2:c6b23a43a9d9 1051 uint32_t ui;
dudmuck 0:be215de91a68 1052 uint8_t a, d;
dudmuck 1:1cd0afbed23c 1053 static uint16_t fsk_tx_length;
dudmuck 0:be215de91a68 1054
dudmuck 0:be215de91a68 1055 len = get_kbd_str(pcbuf, sizeof(pcbuf));
dudmuck 0:be215de91a68 1056 if (len < 0) {
dudmuck 0:be215de91a68 1057 printf("abort\r\n");
dudmuck 0:be215de91a68 1058 return;
dudmuck 0:be215de91a68 1059 }
dudmuck 0:be215de91a68 1060
dudmuck 0:be215de91a68 1061 printf("\r\n");
dudmuck 0:be215de91a68 1062 if (len == 1) {
dudmuck 0:be215de91a68 1063 switch (pcbuf[0]) {
dudmuck 0:be215de91a68 1064 case 'i':
dudmuck 0:be215de91a68 1065 radio.init();
dudmuck 0:be215de91a68 1066 user_init();
dudmuck 0:be215de91a68 1067 break;
dudmuck 0:be215de91a68 1068 case 'h':
dudmuck 0:be215de91a68 1069 printf("hw_reset()\r\n");
dudmuck 0:be215de91a68 1070 radio.hw_reset();
dudmuck 0:be215de91a68 1071 break;
dudmuck 0:be215de91a68 1072 case 'R':
dudmuck 0:be215de91a68 1073 // read all registers
dudmuck 0:be215de91a68 1074 for (a = 1; a < 0x71; a++) {
dudmuck 0:be215de91a68 1075 d = radio.read_reg(a);
dudmuck 0:be215de91a68 1076 //update_shadow_regs(selected_radio, a, d);
dudmuck 0:be215de91a68 1077 printf("%02x: %02x\r\n", a, d);
dudmuck 0:be215de91a68 1078 }
dudmuck 0:be215de91a68 1079 break;
dudmuck 0:be215de91a68 1080 case 'T':
dudmuck 1:1cd0afbed23c 1081 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1082 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 1:1cd0afbed23c 1083 //printf("a %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1084 lora.RegModemConfig2.sx1276bits.TxContinuousMode ^= 1; // same for sx1272 and sx1276
dudmuck 1:1cd0afbed23c 1085 //printf("b %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1086 radio.write_reg(REG_LR_MODEMCONFIG2, lora.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1087 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1088 //printf("c %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1089 lora_printTxContinuousMode();
dudmuck 1:1cd0afbed23c 1090 printf("\r\n");
dudmuck 1:1cd0afbed23c 1091 }
dudmuck 0:be215de91a68 1092 break;
dudmuck 0:be215de91a68 1093 case 'C':
dudmuck 2:c6b23a43a9d9 1094 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1095 lora.setRxPayloadCrcOn(!lora.getRxPayloadCrcOn());
dudmuck 2:c6b23a43a9d9 1096 lora_printRxPayloadCrcOn();
dudmuck 2:c6b23a43a9d9 1097 } else {
dudmuck 2:c6b23a43a9d9 1098 printf("CrcOn:");
dudmuck 2:c6b23a43a9d9 1099 fsk.RegPktConfig1.bits.CrcOn ^= 1;
dudmuck 2:c6b23a43a9d9 1100 radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
dudmuck 2:c6b23a43a9d9 1101 if (fsk.RegPktConfig1.bits.CrcOn)
dudmuck 2:c6b23a43a9d9 1102 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1103 else
dudmuck 2:c6b23a43a9d9 1104 printf("Off\r\n");
dudmuck 2:c6b23a43a9d9 1105 if (fsk.RegPktConfig2.bits.DataModePacket && radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER) {
dudmuck 2:c6b23a43a9d9 1106 fsk.config_dio0_for_pktmode_rx();
dudmuck 2:c6b23a43a9d9 1107 }
dudmuck 2:c6b23a43a9d9 1108 }
dudmuck 0:be215de91a68 1109 printf("\r\n");
dudmuck 0:be215de91a68 1110 break;
dudmuck 0:be215de91a68 1111 case 'B':
dudmuck 0:be215de91a68 1112 radio.RegPaConfig.bits.PaSelect ^= 1;
dudmuck 0:be215de91a68 1113 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:be215de91a68 1114 printPa();
dudmuck 0:be215de91a68 1115 printf("\r\n");
dudmuck 1:1cd0afbed23c 1116 break;
dudmuck 1:1cd0afbed23c 1117 case 'L':
dudmuck 1:1cd0afbed23c 1118 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1119 fsk.enable();
dudmuck 1:1cd0afbed23c 1120 else
dudmuck 1:1cd0afbed23c 1121 lora.enable();
dudmuck 1:1cd0afbed23c 1122
dudmuck 1:1cd0afbed23c 1123 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 1:1cd0afbed23c 1124 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1125 printf("LoRa\r\n");
dudmuck 1:1cd0afbed23c 1126 else
dudmuck 1:1cd0afbed23c 1127 printf("FSK\r\n");
dudmuck 2:c6b23a43a9d9 1128 break;
dudmuck 2:c6b23a43a9d9 1129 case 's':
dudmuck 2:c6b23a43a9d9 1130 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1131 fsk.RegFifoThreshold.bits.TxStartCondition ^= 1;
dudmuck 2:c6b23a43a9d9 1132 radio.write_reg(REG_FSK_FIFOTHRESH, fsk.RegFifoThreshold.octet);
dudmuck 2:c6b23a43a9d9 1133 printf("TxStartCondition:");
dudmuck 2:c6b23a43a9d9 1134 if (fsk.RegFifoThreshold.bits.TxStartCondition)
dudmuck 2:c6b23a43a9d9 1135 printf("!FifoEmpty\r\n");
dudmuck 2:c6b23a43a9d9 1136 else
dudmuck 2:c6b23a43a9d9 1137 printf("FifoLevel\r\n");
dudmuck 2:c6b23a43a9d9 1138 }
dudmuck 2:c6b23a43a9d9 1139 break;
dudmuck 2:c6b23a43a9d9 1140 case 'f':
dudmuck 2:c6b23a43a9d9 1141 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1142 printf("PacketFormat:");
dudmuck 2:c6b23a43a9d9 1143 fsk.RegPktConfig1.bits.PacketFormatVariable ^= 1;
dudmuck 2:c6b23a43a9d9 1144 radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
dudmuck 2:c6b23a43a9d9 1145 if (fsk.RegPktConfig1.bits.PacketFormatVariable)
dudmuck 2:c6b23a43a9d9 1146 printf("variable\r\n");
dudmuck 2:c6b23a43a9d9 1147 else
dudmuck 2:c6b23a43a9d9 1148 printf("fixed\r\n");
dudmuck 2:c6b23a43a9d9 1149 /*if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER)
dudmuck 2:c6b23a43a9d9 1150 reset_flow();*/
dudmuck 2:c6b23a43a9d9 1151 }
dudmuck 2:c6b23a43a9d9 1152 break;
dudmuck 2:c6b23a43a9d9 1153 case 'E':
dudmuck 2:c6b23a43a9d9 1154 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1155 RegIrqFlags2_t RegIrqFlags2;
dudmuck 2:c6b23a43a9d9 1156 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 1157 while (!RegIrqFlags2.bits.FifoEmpty) {
dudmuck 2:c6b23a43a9d9 1158 if (pc.readable())
dudmuck 2:c6b23a43a9d9 1159 break;
dudmuck 2:c6b23a43a9d9 1160 printf("%02x\r\n", radio.read_reg(REG_FIFO));
dudmuck 2:c6b23a43a9d9 1161 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 1162 }
dudmuck 2:c6b23a43a9d9 1163 }
dudmuck 2:c6b23a43a9d9 1164 break;
dudmuck 2:c6b23a43a9d9 1165 case 'A':
dudmuck 2:c6b23a43a9d9 1166 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1167 fsk.RegRxConfig.bits.AfcAutoOn ^= 1;
dudmuck 2:c6b23a43a9d9 1168 radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
dudmuck 2:c6b23a43a9d9 1169 printf("AfcAuto:");
dudmuck 2:c6b23a43a9d9 1170 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 2:c6b23a43a9d9 1171 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1172 else
dudmuck 2:c6b23a43a9d9 1173 printf("OFF\r\n");
dudmuck 2:c6b23a43a9d9 1174 break;
dudmuck 2:c6b23a43a9d9 1175 }
dudmuck 2:c6b23a43a9d9 1176 break;
dudmuck 0:be215de91a68 1177 case '?':
dudmuck 1:1cd0afbed23c 1178 printf("L toggle LongRangeMode/FSK\r\n");
dudmuck 0:be215de91a68 1179 printf("i radio_init\r\n");
dudmuck 0:be215de91a68 1180 printf("h hw_reset\r\n");
dudmuck 2:c6b23a43a9d9 1181 printf("tx[%%d] transmit\r\n");
dudmuck 1:1cd0afbed23c 1182 printf("rx receive\r\n");
dudmuck 0:be215de91a68 1183 printf("C toggle crcOn\r\n");
dudmuck 2:c6b23a43a9d9 1184 printf("op[%%d] get/set output power\r\n");
dudmuck 1:1cd0afbed23c 1185 printf("d[0-5] change DIO pin assignment\r\n");
dudmuck 1:1cd0afbed23c 1186 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1187 printf("pl[%%d] LORA get/set RegPayloadLength\r\n");
dudmuck 1:1cd0afbed23c 1188 printf("cr[1234] LORA set coding rate \r\n");
dudmuck 2:c6b23a43a9d9 1189 printf("bw[%%d] LORA get/set bandwidth\r\n");
dudmuck 2:c6b23a43a9d9 1190 printf("sf[%%d] LORA get/set spreading factor\r\n");
dudmuck 1:1cd0afbed23c 1191 printf("T LORA toggle TxContinuousMode\r\n");
dudmuck 2:c6b23a43a9d9 1192 printf("hp[%%d] LORA get/set hop period\r\n");
dudmuck 1:1cd0afbed23c 1193 printf("hm LORA toggle explicit/explicit header mode\r\n");
dudmuck 1:1cd0afbed23c 1194 } else {
dudmuck 2:c6b23a43a9d9 1195 printf("bw[a][%%d] FSK get-set rxbw (bwa=afcbw)\r\n");
dudmuck 2:c6b23a43a9d9 1196 printf("rt FSK change RxTrigger\r\n");
dudmuck 2:c6b23a43a9d9 1197 printf("pd FSK enable/disable preamble detector\r\n");
dudmuck 2:c6b23a43a9d9 1198 printf("pt FSK get-set PreambleDetectorTol\r\n");
dudmuck 2:c6b23a43a9d9 1199 printf("ss[%%d] FSK get-set SyncSize\r\n");
dudmuck 2:c6b23a43a9d9 1200 printf("S[%%x] FSK get-set sync word\r\n");
dudmuck 2:c6b23a43a9d9 1201 printf("s FSK toggle TxStartCondition\r\n");
dudmuck 2:c6b23a43a9d9 1202 printf("f FSK toggle PacketFormat fixed-variable\r\n");
dudmuck 2:c6b23a43a9d9 1203 printf("E FSK empty out the fifo\r\n");
dudmuck 2:c6b23a43a9d9 1204 printf("ac FSK AfcClear\r\n");
dudmuck 2:c6b23a43a9d9 1205 printf("A FSK toggle AfcAutoOn\r\n");
dudmuck 2:c6b23a43a9d9 1206 printf("mp FSK toggle MapPreambleDetect\r\n");
dudmuck 2:c6b23a43a9d9 1207 printf("ar FSK change AutoRestartRxMode\r\n");
dudmuck 2:c6b23a43a9d9 1208 printf("alc FSK toggle AfcAutoClearOn\r\n");
dudmuck 1:1cd0afbed23c 1209 }
dudmuck 0:be215de91a68 1210 break;
dudmuck 0:be215de91a68 1211 case '.':
dudmuck 1:1cd0afbed23c 1212 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1213 lora_print_status();
dudmuck 1:1cd0afbed23c 1214 else
dudmuck 1:1cd0afbed23c 1215 fsk_print_status();
dudmuck 0:be215de91a68 1216 common_print_status();
dudmuck 0:be215de91a68 1217 break;
dudmuck 0:be215de91a68 1218 } // ...switch (pcbuf[0])
dudmuck 0:be215de91a68 1219 } else {
dudmuck 0:be215de91a68 1220 if (pcbuf[0] == 't' && pcbuf[1] == 'x') { // TX
dudmuck 1:1cd0afbed23c 1221 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1222 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1223 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1224 lora.RegPayloadLength = i;
dudmuck 1:1cd0afbed23c 1225 }
dudmuck 1:1cd0afbed23c 1226 tx_cnt++;
dudmuck 1:1cd0afbed23c 1227 for (i = 0; i < lora.RegPayloadLength; i++)
dudmuck 1:1cd0afbed23c 1228 radio.tx_buf[i] = tx_cnt;
dudmuck 1:1cd0afbed23c 1229 lora.start_tx(lora.RegPayloadLength);
dudmuck 2:c6b23a43a9d9 1230 } else { // FSK:
dudmuck 1:1cd0afbed23c 1231 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1232 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1233 fsk_tx_length = i;
dudmuck 1:1cd0afbed23c 1234 }
dudmuck 2:c6b23a43a9d9 1235 if (radio.RegOpMode.bits.Mode != RF_OPMODE_TRANSMITTER) { // if not already busy transmitting
dudmuck 2:c6b23a43a9d9 1236 tx_cnt++;
dudmuck 2:c6b23a43a9d9 1237 for (i = 0; i < fsk_tx_length; i++) {
dudmuck 2:c6b23a43a9d9 1238 radio.tx_buf[i] = tx_cnt;
dudmuck 2:c6b23a43a9d9 1239 }
dudmuck 2:c6b23a43a9d9 1240 fsk.start_tx(fsk_tx_length);
dudmuck 2:c6b23a43a9d9 1241 }
dudmuck 0:be215de91a68 1242 }
dudmuck 1:1cd0afbed23c 1243 } else if (pcbuf[0] == 'h' && pcbuf[1] == 'p' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1244 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1245 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1246 lora.RegHopPeriod = i;
dudmuck 1:1cd0afbed23c 1247 radio.write_reg(REG_LR_HOPPERIOD, lora.RegHopPeriod);
dudmuck 0:be215de91a68 1248 if (radio.RegDioMapping1.bits.Dio1Mapping != 1) {
dudmuck 0:be215de91a68 1249 radio.RegDioMapping1.bits.Dio1Mapping = 1;
dudmuck 0:be215de91a68 1250 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1251 }
dudmuck 0:be215de91a68 1252 }
dudmuck 1:1cd0afbed23c 1253 lora.RegHopPeriod = radio.read_reg(REG_LR_HOPPERIOD);
dudmuck 1:1cd0afbed23c 1254 printf("HopPeriod:0x%02x\r\n", lora.RegHopPeriod);
dudmuck 2:c6b23a43a9d9 1255 } else if (pcbuf[0] == 'r' && pcbuf[1] == 't' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1256 printf("RxTrigger:");
dudmuck 2:c6b23a43a9d9 1257 switch (fsk.RegRxConfig.bits.RxTrigger) {
dudmuck 2:c6b23a43a9d9 1258 case 0: fsk.RegRxConfig.bits.RxTrigger = 1;
dudmuck 2:c6b23a43a9d9 1259 printf("rssi\r\n");
dudmuck 2:c6b23a43a9d9 1260 break;
dudmuck 2:c6b23a43a9d9 1261 case 1: fsk.RegRxConfig.bits.RxTrigger = 6;
dudmuck 2:c6b23a43a9d9 1262 printf("preamble\r\n");
dudmuck 2:c6b23a43a9d9 1263 break;
dudmuck 2:c6b23a43a9d9 1264 case 6: fsk.RegRxConfig.bits.RxTrigger = 7;
dudmuck 2:c6b23a43a9d9 1265 printf("both\r\n");
dudmuck 2:c6b23a43a9d9 1266 break;
dudmuck 2:c6b23a43a9d9 1267 case 7: fsk.RegRxConfig.bits.RxTrigger = 0;
dudmuck 2:c6b23a43a9d9 1268 printf("none\r\n");
dudmuck 2:c6b23a43a9d9 1269 break;
dudmuck 2:c6b23a43a9d9 1270 default: fsk.RegRxConfig.bits.RxTrigger = 0;
dudmuck 2:c6b23a43a9d9 1271 printf("none\r\n");
dudmuck 2:c6b23a43a9d9 1272 break;
dudmuck 2:c6b23a43a9d9 1273 }
dudmuck 2:c6b23a43a9d9 1274 radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
dudmuck 0:be215de91a68 1275 } else if (pcbuf[0] == 'r' && pcbuf[1] == 'x') { // RX
dudmuck 2:c6b23a43a9d9 1276 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 2:c6b23a43a9d9 1277 lora.start_rx();
dudmuck 2:c6b23a43a9d9 1278 else
dudmuck 2:c6b23a43a9d9 1279 fsk.start_rx();
dudmuck 0:be215de91a68 1280 } else if (pcbuf[0] == 'r' && pcbuf[1] == ' ') { // read single register
dudmuck 0:be215de91a68 1281 sscanf(pcbuf+2, "%x", &i);
dudmuck 0:be215de91a68 1282 printf("%02x: %02x\r\n", i, radio.read_reg(i));
dudmuck 0:be215de91a68 1283 } else if (pcbuf[0] == 'w' && pcbuf[1] == ' ') { // write single register
dudmuck 0:be215de91a68 1284 sscanf(pcbuf+2, "%x %x", &i, &len);
dudmuck 0:be215de91a68 1285 radio.write_reg(i, len);
dudmuck 0:be215de91a68 1286 printf("%02x: %02x\r\n", i, radio.read_reg(i));
dudmuck 2:c6b23a43a9d9 1287 } else if (pcbuf[0] == 'm' && pcbuf[1] == 'p' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1288 radio.RegDioMapping2.bits.MapPreambleDetect ^= 1;
dudmuck 2:c6b23a43a9d9 1289 radio.write_reg(REG_DIOMAPPING2, radio.RegDioMapping2.octet);
dudmuck 2:c6b23a43a9d9 1290 printf("MapPreambleDetect:");
dudmuck 2:c6b23a43a9d9 1291 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 2:c6b23a43a9d9 1292 printf("preamble\r\n");
dudmuck 2:c6b23a43a9d9 1293 else
dudmuck 2:c6b23a43a9d9 1294 printf("rssi\r\n");
dudmuck 0:be215de91a68 1295 } else if (pcbuf[0] == 'o' && pcbuf[1] == 'p') {
dudmuck 0:be215de91a68 1296 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1297 sscanf(pcbuf+2, "%d", &i);
dudmuck 0:be215de91a68 1298 radio.RegPaConfig.bits.OutputPower = i;
dudmuck 0:be215de91a68 1299 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:be215de91a68 1300 }
dudmuck 0:be215de91a68 1301 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:be215de91a68 1302 printf("OutputPower:%d\r\n", radio.RegPaConfig.bits.OutputPower);
dudmuck 1:1cd0afbed23c 1303 } else if (pcbuf[0] == 'c' && pcbuf[1] == 'r' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1304 if (pcbuf[2] >= '0' && pcbuf[2] <= '9')
dudmuck 1:1cd0afbed23c 1305 lora.setCodingRate(pcbuf[2] - '0');
dudmuck 1:1cd0afbed23c 1306 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1307 lora_printCodingRate(false); // false: transmitted
dudmuck 0:be215de91a68 1308 printf("\r\n");
dudmuck 1:1cd0afbed23c 1309 } else if (pcbuf[0] == 'h' && pcbuf[1] == 'm' && radio.RegOpMode.bits.LongRangeMode) { // toggle implicit/explicit
dudmuck 1:1cd0afbed23c 1310 lora.setHeaderMode(!lora.getHeaderMode());
dudmuck 1:1cd0afbed23c 1311 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1312 lora_printHeaderMode();
dudmuck 0:be215de91a68 1313 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1314 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'l' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1315 fsk.RegAfcFei.bits.AfcAutoClearOn ^= 1;
dudmuck 2:c6b23a43a9d9 1316 printf("AfcAutoClearOn: ");
dudmuck 2:c6b23a43a9d9 1317 radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
dudmuck 2:c6b23a43a9d9 1318 if (fsk.RegAfcFei.bits.AfcAutoClearOn)
dudmuck 2:c6b23a43a9d9 1319 printf("ON\r\n");
dudmuck 2:c6b23a43a9d9 1320 else
dudmuck 2:c6b23a43a9d9 1321 printf("off\r\n");
dudmuck 2:c6b23a43a9d9 1322 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'r' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1323 fsk.RegSyncConfig.bits.AutoRestartRxMode++;
dudmuck 2:c6b23a43a9d9 1324 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1325 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1326 printf("AutoRestartRxMode:");
dudmuck 2:c6b23a43a9d9 1327 switch (fsk.RegSyncConfig.bits.AutoRestartRxMode) {
dudmuck 2:c6b23a43a9d9 1328 case 0: printf("off "); break;
dudmuck 2:c6b23a43a9d9 1329 case 1: printf("no-pll-wait "); break;
dudmuck 2:c6b23a43a9d9 1330 case 2: printf("pll-wait "); break;
dudmuck 2:c6b23a43a9d9 1331 case 3: printf("3 "); break;
dudmuck 2:c6b23a43a9d9 1332 }
dudmuck 2:c6b23a43a9d9 1333 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1334 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'c' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1335 printf("clear afc: ");
dudmuck 2:c6b23a43a9d9 1336 fsk.RegAfcFei.bits.AfcClear = 1;
dudmuck 2:c6b23a43a9d9 1337 radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
dudmuck 2:c6b23a43a9d9 1338 fsk.RegAfcFei.bits.AfcClear = 0;
dudmuck 2:c6b23a43a9d9 1339 printf("%dHz\r\n", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_AFCMSB)));
dudmuck 0:be215de91a68 1340 } else if (pcbuf[0] == 'b' && pcbuf[1] == 'w') {
dudmuck 1:1cd0afbed23c 1341 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1342 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 1:1cd0afbed23c 1343 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1344 sscanf(&pcbuf[2], "%d", &i);
dudmuck 1:1cd0afbed23c 1345 lora.setBw(i);
dudmuck 1:1cd0afbed23c 1346 } else
dudmuck 1:1cd0afbed23c 1347 lora_printAllBw();
dudmuck 1:1cd0afbed23c 1348 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1349 printf("current ");
dudmuck 1:1cd0afbed23c 1350 lora_printBw();
dudmuck 1:1cd0afbed23c 1351 printf("\r\n");
dudmuck 1:1cd0afbed23c 1352 } else { // FSK:
dudmuck 1:1cd0afbed23c 1353 if (pcbuf[2] == 'a') {
dudmuck 1:1cd0afbed23c 1354 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 1:1cd0afbed23c 1355 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1356 sscanf(&pcbuf[3], "%d", &i);
dudmuck 1:1cd0afbed23c 1357 fsk.set_rx_dcc_bw_hz(i, 1);
dudmuck 1:1cd0afbed23c 1358 }
dudmuck 1:1cd0afbed23c 1359 printf("afcbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_AFCBW));
dudmuck 1:1cd0afbed23c 1360 } else {
dudmuck 1:1cd0afbed23c 1361 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 1:1cd0afbed23c 1362 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1363 sscanf(&pcbuf[2], "%d", &i);
dudmuck 1:1cd0afbed23c 1364 fsk.set_rx_dcc_bw_hz(i, 0);
dudmuck 1:1cd0afbed23c 1365 }
dudmuck 1:1cd0afbed23c 1366 printf("rxbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_RXBW));
dudmuck 1:1cd0afbed23c 1367 }
dudmuck 1:1cd0afbed23c 1368 }
dudmuck 0:be215de91a68 1369 } else if (pcbuf[0] == 'v' && pcbuf[1] == 'h') {
dudmuck 1:1cd0afbed23c 1370 lora.poll_vh ^= 1;
dudmuck 1:1cd0afbed23c 1371 printf("poll_vh:%d\r\n", lora.poll_vh);
dudmuck 2:c6b23a43a9d9 1372 } else if (pcbuf[0] == 'S' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1373 if (pcbuf[1] == '0') {
dudmuck 2:c6b23a43a9d9 1374 sscanf(pcbuf+1, "%x", &ui);
dudmuck 2:c6b23a43a9d9 1375 if (ui < 0x100) {
dudmuck 2:c6b23a43a9d9 1376 fsk.RegSyncConfig.bits.SyncSize = 0;
dudmuck 2:c6b23a43a9d9 1377 radio.write_reg(REG_FSK_SYNCVALUE1, ui);
dudmuck 2:c6b23a43a9d9 1378 } else if (ui < 0x10000) {
dudmuck 2:c6b23a43a9d9 1379 fsk.RegSyncConfig.bits.SyncSize = 1;
dudmuck 2:c6b23a43a9d9 1380 radio.write_reg(REG_FSK_SYNCVALUE1, ui & 0xff);
dudmuck 2:c6b23a43a9d9 1381 radio.write_reg(REG_FSK_SYNCVALUE2, ui >> 8);
dudmuck 2:c6b23a43a9d9 1382 } else if (ui < 0x1000000) {
dudmuck 2:c6b23a43a9d9 1383 fsk.RegSyncConfig.bits.SyncSize = 2;
dudmuck 2:c6b23a43a9d9 1384 radio.write_reg(REG_FSK_SYNCVALUE1, ui & 0xff);
dudmuck 2:c6b23a43a9d9 1385 radio.write_reg(REG_FSK_SYNCVALUE2, (ui >> 8) & 0xff);
dudmuck 2:c6b23a43a9d9 1386 radio.write_reg(REG_FSK_SYNCVALUE3, ui >> 16);
dudmuck 2:c6b23a43a9d9 1387 } else {
dudmuck 2:c6b23a43a9d9 1388 fsk.RegSyncConfig.bits.SyncSize = 3;
dudmuck 2:c6b23a43a9d9 1389 radio.write_reg(REG_FSK_SYNCVALUE1, ui & 0xff);
dudmuck 2:c6b23a43a9d9 1390 radio.write_reg(REG_FSK_SYNCVALUE2, (ui >> 8) & 0xff);
dudmuck 2:c6b23a43a9d9 1391 radio.write_reg(REG_FSK_SYNCVALUE3, (ui >> 16) & 0xff);
dudmuck 2:c6b23a43a9d9 1392 radio.write_reg(REG_FSK_SYNCVALUE4, ui >> 24);
dudmuck 2:c6b23a43a9d9 1393 }
dudmuck 2:c6b23a43a9d9 1394 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1395 }
dudmuck 2:c6b23a43a9d9 1396 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1397 printf("%d: ", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 2:c6b23a43a9d9 1398 for (i = 0; i <= fsk.RegSyncConfig.bits.SyncSize; i++)
dudmuck 2:c6b23a43a9d9 1399 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE1+i));
dudmuck 2:c6b23a43a9d9 1400 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1401 } else if (pcbuf[0] == 's' && pcbuf[1] == 's' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1402 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1403 sscanf(pcbuf+2, "%d", &i);
dudmuck 2:c6b23a43a9d9 1404 fsk.RegSyncConfig.bits.SyncSize = i;
dudmuck 2:c6b23a43a9d9 1405 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1406 }
dudmuck 2:c6b23a43a9d9 1407 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1408 printf("SyncSize:%d\r\n", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 1:1cd0afbed23c 1409 } else if (pcbuf[0] == 's' && pcbuf[1] == 'f' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1410 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1411 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1412 lora.setSf(i);
dudmuck 1:1cd0afbed23c 1413 if (i == 6 && !lora.getHeaderMode()) {
dudmuck 0:be215de91a68 1414 printf("SF6: to implicit header mode\r\n");
dudmuck 1:1cd0afbed23c 1415 lora.setHeaderMode(true);
dudmuck 0:be215de91a68 1416 }
dudmuck 0:be215de91a68 1417 }
dudmuck 1:1cd0afbed23c 1418 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 1:1cd0afbed23c 1419 lora_printSf();
dudmuck 0:be215de91a68 1420 printf("\r\n");
dudmuck 0:be215de91a68 1421 } else if (pcbuf[0] == 'f' && pcbuf[1] == 'r' && pcbuf[2] == 'f') {
dudmuck 0:be215de91a68 1422 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 0:be215de91a68 1423 float MHz;
dudmuck 0:be215de91a68 1424 sscanf(pcbuf+3, "%f", &MHz);
dudmuck 0:be215de91a68 1425 //printf("MHz:%f\r\n", MHz);
dudmuck 0:be215de91a68 1426 radio.set_frf_MHz(MHz);
dudmuck 0:be215de91a68 1427 } else
dudmuck 0:be215de91a68 1428 printf("%fMHz\r\n", radio.get_frf_MHz());
dudmuck 2:c6b23a43a9d9 1429 } else if (pcbuf[0] == 'p' && pcbuf[1] == 't' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1430 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1431 sscanf(pcbuf+2, "%d", &i);
dudmuck 2:c6b23a43a9d9 1432 fsk.RegPreambleDetect.bits.PreambleDetectorTol = i;
dudmuck 2:c6b23a43a9d9 1433 radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
dudmuck 2:c6b23a43a9d9 1434 }
dudmuck 2:c6b23a43a9d9 1435 fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
dudmuck 2:c6b23a43a9d9 1436 printf("PreambleDetectorTol:%d\r\n", fsk.RegPreambleDetect.bits.PreambleDetectorTol);
dudmuck 2:c6b23a43a9d9 1437 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'd' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1438 fsk.RegPreambleDetect.bits.PreambleDetectorOn ^= 1;
dudmuck 2:c6b23a43a9d9 1439 radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
dudmuck 2:c6b23a43a9d9 1440 printf("PreambleDetector:");
dudmuck 2:c6b23a43a9d9 1441 if (fsk.RegPreambleDetect.bits.PreambleDetectorOn)
dudmuck 2:c6b23a43a9d9 1442 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1443 else
dudmuck 2:c6b23a43a9d9 1444 printf("OFF\r\n");
dudmuck 1:1cd0afbed23c 1445 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'l' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1446 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1447 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1448 lora.RegPayloadLength = i;
dudmuck 1:1cd0afbed23c 1449 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 0:be215de91a68 1450 }
dudmuck 1:1cd0afbed23c 1451 lora.RegPayloadLength = radio.read_reg(REG_LR_PAYLOADLENGTH);
dudmuck 1:1cd0afbed23c 1452 printf("PayloadLength:%d\r\n", lora.RegPayloadLength);
dudmuck 0:be215de91a68 1453 } else if (pcbuf[0] == 'd' && pcbuf[1] >= '0' && pcbuf[1] <= '5') {
dudmuck 0:be215de91a68 1454 switch (pcbuf[1]) {
dudmuck 0:be215de91a68 1455 case '0':
dudmuck 0:be215de91a68 1456 radio.RegDioMapping1.bits.Dio0Mapping++;
dudmuck 0:be215de91a68 1457 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1458 break;
dudmuck 0:be215de91a68 1459 case '1':
dudmuck 0:be215de91a68 1460 radio.RegDioMapping1.bits.Dio1Mapping++;
dudmuck 0:be215de91a68 1461 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1462 break;
dudmuck 0:be215de91a68 1463 case '2':
dudmuck 0:be215de91a68 1464 radio.RegDioMapping1.bits.Dio2Mapping++;
dudmuck 0:be215de91a68 1465 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1466 break;
dudmuck 0:be215de91a68 1467 case '3':
dudmuck 0:be215de91a68 1468 radio.RegDioMapping1.bits.Dio3Mapping++;
dudmuck 0:be215de91a68 1469 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1470 break;
dudmuck 0:be215de91a68 1471 case '4':
dudmuck 0:be215de91a68 1472 radio.RegDioMapping2.bits.Dio4Mapping++;
dudmuck 0:be215de91a68 1473 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping2.octet);
dudmuck 0:be215de91a68 1474 break;
dudmuck 0:be215de91a68 1475 case '5':
dudmuck 0:be215de91a68 1476 radio.RegDioMapping2.bits.Dio5Mapping++;
dudmuck 0:be215de91a68 1477 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping2.octet);
dudmuck 0:be215de91a68 1478 break;
dudmuck 0:be215de91a68 1479 } // ...switch (pcbuf[1])
dudmuck 1:1cd0afbed23c 1480 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1481 lora_print_dio();
dudmuck 1:1cd0afbed23c 1482 else
dudmuck 1:1cd0afbed23c 1483 fsk_print_dio();
dudmuck 0:be215de91a68 1484 } else if (pcbuf[0] == 's' && pcbuf[1] == 't' && pcbuf[2] == 'b') {
dudmuck 0:be215de91a68 1485 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 0:be215de91a68 1486 } else if (pcbuf[0] == 's' && pcbuf[1] == 'l' && pcbuf[2] == 'e') {
dudmuck 0:be215de91a68 1487 radio.set_opmode(RF_OPMODE_SLEEP);
dudmuck 0:be215de91a68 1488 } else if (pcbuf[0] == 'c' && pcbuf[1] == 'h' && pcbuf[2] == 'a') {
dudmuck 0:be215de91a68 1489 app = APP_CHAT;
dudmuck 1:1cd0afbed23c 1490 lora.start_rx();
dudmuck 0:be215de91a68 1491 printf("chat start\r\n");
dudmuck 0:be215de91a68 1492 }
dudmuck 0:be215de91a68 1493 }
dudmuck 0:be215de91a68 1494 printf("> ");
dudmuck 0:be215de91a68 1495 fflush(stdout);
dudmuck 0:be215de91a68 1496
dudmuck 0:be215de91a68 1497 }
dudmuck 0:be215de91a68 1498
dudmuck 0:be215de91a68 1499 int main()
dudmuck 0:be215de91a68 1500 {
dudmuck 0:be215de91a68 1501
dudmuck 0:be215de91a68 1502 pc.baud(57600);
dudmuck 0:be215de91a68 1503 user_init();
dudmuck 0:be215de91a68 1504
dudmuck 0:be215de91a68 1505 radio.frfs = frfs;
dudmuck 0:be215de91a68 1506
dudmuck 0:be215de91a68 1507 while(1) {
dudmuck 0:be215de91a68 1508 switch (app) {
dudmuck 0:be215de91a68 1509 case APP_NONE:
dudmuck 0:be215de91a68 1510 console();
dudmuck 0:be215de91a68 1511 break;
dudmuck 0:be215de91a68 1512 case APP_CHAT:
dudmuck 0:be215de91a68 1513 console_chat();
dudmuck 0:be215de91a68 1514 break;
dudmuck 0:be215de91a68 1515 } // ...switch (app)
dudmuck 0:be215de91a68 1516 } // ...while(1)
dudmuck 0:be215de91a68 1517 }
dudmuck 0:be215de91a68 1518