UART console application for testing SX1272/SX1276

Dependencies:   SX127x

/media/uploads/dudmuck/lora.png

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

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

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

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

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

Using with SX1276MB1xAS Shield

This component plugs into any board with arduino uno headers.

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


Using with your own production board

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

Transmitter Test Guidelines

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

commands used for transmitter testing:

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

LoRa transmitter testing

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

Receiver Test Guidelines

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

commands used for receiver testing:

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

Full command list

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

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

command list: common commands (both LoRa and FSK)

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

command list: LoRa modem commands

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

command list: FSK modem commands

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

Who changed what in which revision?

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