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:
Mon Aug 10 23:13:56 2015 +0000
Revision:
9:2f13a9ef27b4
Parent:
8:227605e4a760
Child:
10:d9bb2ce57f05
added mDot_F411

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