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:
Tue Jul 21 21:38:17 2015 +0000
Revision:
8:227605e4a760
Parent:
7:c3c54f222ced
Child:
9:2f13a9ef27b4
added Eiger PER support and support for +20dBm TX (OCP/BGR)

Who changed what in which revision?

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