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 Oct 20 22:00:02 2015 +0000
Revision:
15:c69b942685ea
Parent:
14:c57ea544dc18
Child:
16:b9d36c60f2d3
added detection of sx1276 shield board type

Who changed what in which revision?

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