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 Sep 28 22:32:58 2015 +0000
Revision:
13:c73caaee93a5
Parent:
12:beb0387c1b4c
Child:
14:c57ea544dc18
added PER test for FSK

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