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:
Wed Sep 16 18:23:01 2015 +0000
Revision:
12:beb0387c1b4c
Parent:
11:81ff5bcafd97
Child:
13:c73caaee93a5
changed default eiger spreading factor to 10

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