UART console application for testing SX1272/SX1276

Dependencies:   SX127x

/media/uploads/dudmuck/lora.png

This is a UART console test application for using SX127x library driver for SX1272/SX1276 radio transceivers. Serial console is provided at 57600bps. Refer to Serial Communication with a PC for information about using the serial port with your PC.

Using this command interface, you can exercise the functionality of radio chip without needing specialized software application for your PC.

Commands which can be used include ? to list available commands, or . to query status from radio chip, for example. The serial console allows you to configure the radio chip, such as setting spreading factor, bandwidth, operating frequency, etc.

A simple chat application is provided to try communications between two boards. The SX127x library object is instantiated with pin assignments generic arduino headers, but can be easily reassigned for any mbed board.

The same driver library can operate for both SX1272 and SX1276. Upon starting, the driver auto-detects whether SX1272 or SX1276 transceiver chip is connected by attempting to change the LowFrequencyModeOn bit in RegOpMode register. If this bit can be changed, then the radio device is SX1276. This bit is not implemented in SX1272. A few of the radio driver functions select behavior based on this detection. The differences between these two devices is small, from a software perspective.

Using with SX1276MB1xAS Shield

This component plugs into any board with arduino uno headers.

There are two different version of this shield. European version (MAS), and North American (LAS). The LAS shield uses PA_BOOST transmit pin to permit +20dBm power. The MAS version uses RFO transmit pin in Europe. This software reads RF switch pin (A4 pin) pulling resistor to determine which type of shield is installed.


Using with your own production board

This software is useful for validating RF performance your own LoRa board design, because only two external pins needs to be provided to PC (UART TX/RX). You can select an mbed platform which matches the CPU on your own board. If the memory size doesnt match exactly, you can export the program to an offline toolchain and edit the target type or linker file there.

Transmitter Test Guidelines

FSK mode is used for transmitter testing, because an unmodulated carrier can be sent, permitting easy measurement of TX power and frequency error.

commands used for transmitter testing:

  • frf915.0 change to your desired RF center frequency (in this case 915MHz)
  • L to toggle the radio chip into FSK mode.
  • fdev0 to configure TX frequency deviation to zero, to put the transmitted carrier on the center frequency.
  • pas to select which TX pin is connected to antenna matching (RFO vs PA_BOOST).
  • op<dBm> to configure TX power.
  • If you desire to test higher power PA_BOOST, use ocp<mA>
  • w 01 03 put radio chip into transmit mode (skips writing to FIFO). This will cause radio to transmit preamble, because the FIFO is empty in TX mode. Since Fdev is zero, an unmodulated carrier is sent.
  • Spectrum analyzer can now be used to to observe TX power, harmonics, power consumption, or frequency error.
  • stby to end transmission, or use h to reset radio chip to default condition.
  • Use period . command at any time to review current radio configuration.

LoRa transmitter testing

  • use L command to toggle radio into LoRa, if necessary.
  • Normally the tx command is used to manually send single packets.
  • txc will toggle TxContinuousMode in LoRa modem to send continuous modulated transmission.
  • Useful for checking adjacent channel power.
  • enter txc again to end transmission.

Receiver Test Guidelines

FSK mode is used for receiver sensitivity testing, allowing the use of a BERT signal generator (such as R/S SMIQ03B). Using this method provides real-time indication of receiver sensitivity, useful for tuning and impedance matching. The radio chip outputs DCLK and DATA digital signals which are connected back to BERT signal generator.

commands used for receiver testing:

  • L to toggle the radio chip into FSK mode.
  • datam to toggle FSK modem into continuous mode. This disables packet engine and gives direct access to demodulator.
  • configure DIO1 pin to DCLK function, and DIO2 pin to DATA function:
    • dio command to list current DIO pin asignments
    • d1 to cycle DIO1 function until Dclk is selected
    • d2 for DIO2, only Data function is available in FSK continuous mode
  • frf915.0 change to your desired RF center frequency (in this case 915MHz)
  • rx to start receiver
  • stby to disable receiver

Full command list

Arguments shown in square brackets [] indicate required. <> are optional, where leaving off the argument usually causes a read of the item, and providing the value causes a write operation. You should always have the radio chip datasheet on-hand when using these commands.

Hitting <enter> key by itself will repeat last command.
<Ctrl-C> will cancel an operation in progress.

command list: common commands (both LoRa and FSK)

commanddescription
. (period)print current radio status
?list available commands
Ltoggle active radio modem (LoRa vs FSK)
hhardware reset, put radio into default power-on condition
frf<MHz>get/set RF operating frequency
rxstart radio receiver (any received packets are printed onto your serial terminal)
rssiread instantaneous RSSI (level read at the time command is issued)
tx<%d>transmit test packet. Packet length value can be provided as argument, or uses last value if not provided
payl<%d>get/set payload length
bw<KHz>get/set bandwidth. In LoRa mode, both receive and transmit bandwidth are changed. For FSK, only receive bandwidth is affected. bwa accesses AFC bandwidth in FSK
pastoggle RFO / PA_BOOST transmit pin output selection
op<dBm>get/set TX output power. Value is provided in dBm. Special case is value of 20dBm (on PA_BOOST), which causes increase in TX DAC voltage
ocp<mA>get/set TX current limit, in milliamps. Necessary adjustment when +20dBm is used
dioshow DIO pin assignments
d<0-5>change DIO pin assignment, the pin number is given as arguement. Each pin has up to 4 possible functions
pres<%d>set preamble length. LoRa: number of symbols. FSK: number of bytes
crcontoggle crcOn
lnabcycle LNA-boost setting (receiver performance adjustment)
Rread all radio registers (use only while reading chip datasheet)
r[%x]read single radio register (use only while reading chip datasheet)
w[%x %x]write single radio register (use only while reading chip datasheet)
pllbwchange PLL bandwidth
stbyset chip mode to standby
sleepset chip mode to sleep
fstxset chip mode to fstx
fsrxset chip mode to fsrx
Eiger range test commandsdescription
pid<%d>get set ID number in range test payload
pertx<%d>start Eiger PER transmit. The count of packets to send is provided as arguement
perrxstart Eiger PER receive
txpd<%d>get/set tx delay between PER packets transmitted

command list: LoRa modem commands

LoRa commandLoRa description
iqinvtoggle RX IQ invert
cintoggle TX IQ invert
lhp<%d>(RX) get/set hop period
sync<%x>get/set sync (post-preamble gap, single byte)
cr<1-4>get/set codingRate
lhmtoggle explicit/implicit (explicit mode sends payload length with each packet)
sf<%d>get/set spreadingFactor (SF7 to SF12)
ldrtoggle LowDataRateOptimize (changes payload encoding, for long packets)
txctoggle TxContinuousMode
rxt<%d>get/set SymbTimeout
rxsstart RX_SINGLE (receives only for SymbTimeout symbols)
cad<%d num tries>run channel activity detection

command list: FSK modem commands

FSK commandFSK description
c<%d>get/set test cases. Several FSK bitrates/bandwidths pre-configured to give optimal performance.
fdev<kHz>(TX) get/set frequency deviation
mods(TX) increment modulation shaping
par(TX) increment paRamp
datamtoggle DataMode (packet/continuous)
fifottoggle TxStartCondition (FifoThreshold level vs FifoNotEmpty)
br<%f kbps>get/set bitrate
dcfincrement DcFree (manchester / whitening)
pktftoggle PacketFormat fixed/variable length
syncontoggle SyncOn (frame sync, SFD enable)
bitsynctoggle BitSyncOn (continuous mode only)
syncw<hex bytes>get/set syncword. Sync bytes are provided by hex octects separated by spaces.
fei(RX) read FEI
rxt(RX) increment RxTrigger (RX start on rssi vs. preamble detect)
rssit<-dBm>(RX) get/set rssi threshold (trigger level for RSSI interrupt)
rssis<%d>(RX) get/set rssi smoothing
rssio<%d>(RX) get/set rssi offset
agcauto(RX) toggle AgcAutoOn (true = LNA gain set automatically)
afcauto(RX) toggle AfcAutoOn
ac(RX) AfcClear
ar(RX) increment AutoRestartRxMode
alc(RX) toggle AfcAutoClearOn (only if AfcAutoOn is set)
prep(RX) toggle PreamblePolarity (0xAA vs 0x55)
pde(RX) toggle PreambleDetectorOn
pds<%d>(RX) get/set PreambleDetectorSize
pdt<%d>(RX) get/set PreambleDetectorTol
mp(RX) toggle MapPreambleDetect (DIO function RSSI vs PreambleDetect)
thr<%d>get/set FifoThreshold (triggers FifoLevel interrupt)
polltoggle poll_irq_en. Radio events read from DIO pins vs polling of IrqFlags register
Eempty out FIFO
clkoutincrement ClkOut divider
ookenter OOK mode
ooktincrement OokThreshType
ooksincrement OokPeakTheshStep
sqlch<%d>get/set OokFixedThresh
Committer:
dudmuck
Date:
Thu May 28 01:24:05 2015 +0000
Revision:
6:fe16f96ee335
Parent:
5:360069ec9953
Child:
7:c3c54f222ced
added lora spectral inversion commands

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