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:
Fri Jun 19 21:19:24 2015 +0000
Revision:
7:c3c54f222ced
Parent:
6:fe16f96ee335
Child:
8:227605e4a760
add support for A4 pin on LPCXpresso11U68

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