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

Committer:
dudmuck
Date:
Fri May 02 23:35:43 2014 +0000
Revision:
3:ab386fa756cc
Parent:
2:c6b23a43a9d9
Child:
4:7a9007dfc0e5
fixed FSK AFC

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