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:
Fri May 02 23:35:43 2014 +0000
Revision:
3:ab386fa756cc
Parent:
2:c6b23a43a9d9
Child:
4:7a9007dfc0e5
fixed FSK AFC

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 0:be215de91a68 4 /*
dudmuck 0:be215de91a68 5 * http://mbed.org/handbook/mbed-FRDM-KL25Z
dudmuck 0:be215de91a68 6 */
dudmuck 0:be215de91a68 7
dudmuck 0:be215de91a68 8 DigitalOut green(LED_GREEN);
dudmuck 0:be215de91a68 9
dudmuck 0:be215de91a68 10 Serial pc(USBTX, USBRX);
dudmuck 0:be215de91a68 11
dudmuck 0:be215de91a68 12 uint8_t tx_cnt;
dudmuck 0:be215de91a68 13 char pcbuf[64];
dudmuck 0:be215de91a68 14
dudmuck 0:be215de91a68 15 typedef enum {
dudmuck 0:be215de91a68 16 APP_NONE = 0,
dudmuck 0:be215de91a68 17 APP_CHAT
dudmuck 0:be215de91a68 18 } app_e;
dudmuck 0:be215de91a68 19
dudmuck 0:be215de91a68 20 app_e app = APP_NONE;
dudmuck 0:be215de91a68 21
dudmuck 0:be215de91a68 22
dudmuck 3:ab386fa756cc 23 const uint32_t frfs[] = { /* frequency hopping table */
dudmuck 0:be215de91a68 24 MHZ_TO_FRF(903.0),
dudmuck 0:be215de91a68 25 MHZ_TO_FRF(904.0),
dudmuck 0:be215de91a68 26 MHZ_TO_FRF(905.0),
dudmuck 0:be215de91a68 27 MHZ_TO_FRF(906.0),
dudmuck 0:be215de91a68 28 MHZ_TO_FRF(907.0),
dudmuck 0:be215de91a68 29 MHZ_TO_FRF(908.0),
dudmuck 0:be215de91a68 30 MHZ_TO_FRF(909.0),
dudmuck 0:be215de91a68 31 MHZ_TO_FRF(910.0),
dudmuck 0:be215de91a68 32 MHZ_TO_FRF(911.0),
dudmuck 0:be215de91a68 33 MHZ_TO_FRF(912.0),
dudmuck 0:be215de91a68 34 MHZ_TO_FRF(913.0),
dudmuck 0:be215de91a68 35 MHZ_TO_FRF(914.0),
dudmuck 0:be215de91a68 36 MHZ_TO_FRF(915.0)
dudmuck 0:be215de91a68 37 };
dudmuck 0:be215de91a68 38
dudmuck 1:1cd0afbed23c 39 #define FSK_LARGE_PKT_THRESHOLD 0x3f
dudmuck 1:1cd0afbed23c 40
dudmuck 0:be215de91a68 41 /******************************************************************************/
dudmuck 0:be215de91a68 42
dudmuck 1:1cd0afbed23c 43 // pin: 3 8 1 7 10 12 5 20 18
dudmuck 0:be215de91a68 44 // mosi, miso, sclk, cs, rst, dio0, dio1, fctx, fcps
dudmuck 0:be215de91a68 45 SX127x radio(PTD2, PTD3, PTD1, PTD0, PTD5, PTA13, PTD4, PTC9, PTC8);
dudmuck 1:1cd0afbed23c 46 SX127x_fsk fsk(radio);
dudmuck 1:1cd0afbed23c 47 SX127x_lora lora(radio);
dudmuck 0:be215de91a68 48
dudmuck 0:be215de91a68 49 void printLoraIrqs_(bool clear)
dudmuck 0:be215de91a68 50 {
dudmuck 0:be215de91a68 51 //in radio class -- RegIrqFlags_t RegIrqFlags;
dudmuck 0:be215de91a68 52
dudmuck 0:be215de91a68 53 //already read RegIrqFlags.octet = radio.read_reg(REG_LR_IRQFLAGS);
dudmuck 0:be215de91a68 54 printf("\r\nIrqFlags:");
dudmuck 1:1cd0afbed23c 55 if (lora.RegIrqFlags.bits.CadDetected)
dudmuck 0:be215de91a68 56 printf("CadDetected ");
dudmuck 1:1cd0afbed23c 57 if (lora.RegIrqFlags.bits.FhssChangeChannel) {
dudmuck 0:be215de91a68 58 //radio.RegHopChannel.octet = radio.read_reg(REG_LR_HOPCHANNEL);
dudmuck 1:1cd0afbed23c 59 printf("FhssChangeChannel:%d ", lora.RegHopChannel.bits.FhssPresentChannel);
dudmuck 0:be215de91a68 60 }
dudmuck 1:1cd0afbed23c 61 if (lora.RegIrqFlags.bits.CadDone)
dudmuck 0:be215de91a68 62 printf("CadDone ");
dudmuck 1:1cd0afbed23c 63 if (lora.RegIrqFlags.bits.TxDone)
dudmuck 0:be215de91a68 64 printf("TxDone ");
dudmuck 1:1cd0afbed23c 65 if (lora.RegIrqFlags.bits.ValidHeader)
dudmuck 0:be215de91a68 66 printf("ValidHeader ");
dudmuck 1:1cd0afbed23c 67 if (lora.RegIrqFlags.bits.PayloadCrcError)
dudmuck 0:be215de91a68 68 printf("PayloadCrcError ");
dudmuck 1:1cd0afbed23c 69 if (lora.RegIrqFlags.bits.RxDone)
dudmuck 0:be215de91a68 70 printf("RxDone ");
dudmuck 1:1cd0afbed23c 71 if (lora.RegIrqFlags.bits.RxTimeout)
dudmuck 0:be215de91a68 72 printf("RxTimeout ");
dudmuck 0:be215de91a68 73
dudmuck 0:be215de91a68 74 printf("\r\n");
dudmuck 0:be215de91a68 75
dudmuck 0:be215de91a68 76 if (clear)
dudmuck 1:1cd0afbed23c 77 radio.write_reg(REG_LR_IRQFLAGS, lora.RegIrqFlags.octet);
dudmuck 0:be215de91a68 78
dudmuck 0:be215de91a68 79 }
dudmuck 0:be215de91a68 80
dudmuck 1:1cd0afbed23c 81 void lora_printCodingRate(bool from_rx)
dudmuck 0:be215de91a68 82 {
dudmuck 1:1cd0afbed23c 83 uint8_t d = lora.getCodingRate(from_rx);
dudmuck 0:be215de91a68 84 printf("CodingRate:");
dudmuck 0:be215de91a68 85 switch (d) {
dudmuck 0:be215de91a68 86 case 1: printf("4/5 "); break;
dudmuck 0:be215de91a68 87 case 2: printf("4/6 "); break;
dudmuck 0:be215de91a68 88 case 3: printf("4/7 "); break;
dudmuck 0:be215de91a68 89 case 4: printf("4/8 "); break;
dudmuck 0:be215de91a68 90 default:
dudmuck 0:be215de91a68 91 printf("%d ", d);
dudmuck 0:be215de91a68 92 break;
dudmuck 0:be215de91a68 93 }
dudmuck 0:be215de91a68 94 }
dudmuck 0:be215de91a68 95
dudmuck 1:1cd0afbed23c 96 void lora_printHeaderMode()
dudmuck 0:be215de91a68 97 {
dudmuck 1:1cd0afbed23c 98 if (lora.getHeaderMode())
dudmuck 0:be215de91a68 99 printf("implicit ");
dudmuck 0:be215de91a68 100 else
dudmuck 0:be215de91a68 101 printf("explicit ");
dudmuck 0:be215de91a68 102 }
dudmuck 0:be215de91a68 103
dudmuck 1:1cd0afbed23c 104 void lora_printBw()
dudmuck 0:be215de91a68 105 {
dudmuck 1:1cd0afbed23c 106 uint8_t bw = lora.getBw();
dudmuck 0:be215de91a68 107
dudmuck 0:be215de91a68 108 printf("Bw:");
dudmuck 0:be215de91a68 109 if (radio.type == SX1276) {
dudmuck 1:1cd0afbed23c 110 switch (lora.RegModemConfig.sx1276bits.Bw) {
dudmuck 0:be215de91a68 111 case 0: printf("7.8KHz "); break;
dudmuck 0:be215de91a68 112 case 1: printf("10.4KHz "); break;
dudmuck 0:be215de91a68 113 case 2: printf("15.6KHz "); break;
dudmuck 0:be215de91a68 114 case 3: printf("20.8KHz "); break;
dudmuck 0:be215de91a68 115 case 4: printf("31.25KHz "); break;
dudmuck 0:be215de91a68 116 case 5: printf("41.7KHz "); break;
dudmuck 0:be215de91a68 117 case 6: printf("62.5KHz "); break;
dudmuck 0:be215de91a68 118 case 7: printf("125KHz "); break;
dudmuck 0:be215de91a68 119 case 8: printf("250KHz "); break;
dudmuck 0:be215de91a68 120 case 9: printf("500KHz "); break;
dudmuck 1:1cd0afbed23c 121 default: printf("%x ", lora.RegModemConfig.sx1276bits.Bw); break;
dudmuck 0:be215de91a68 122 }
dudmuck 0:be215de91a68 123 } else if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 124 switch (lora.RegModemConfig.sx1272bits.Bw) {
dudmuck 0:be215de91a68 125 case 0: printf("125KHz "); break;
dudmuck 0:be215de91a68 126 case 1: printf("250KHz "); break;
dudmuck 0:be215de91a68 127 case 2: printf("500KHz "); break;
dudmuck 0:be215de91a68 128 case 3: printf("11b "); break;
dudmuck 0:be215de91a68 129 }
dudmuck 0:be215de91a68 130 }
dudmuck 0:be215de91a68 131 }
dudmuck 0:be215de91a68 132
dudmuck 1:1cd0afbed23c 133 void lora_printAllBw()
dudmuck 0:be215de91a68 134 {
dudmuck 0:be215de91a68 135 int i, s;
dudmuck 0:be215de91a68 136
dudmuck 0:be215de91a68 137 if (radio.type == SX1276) {
dudmuck 1:1cd0afbed23c 138 s = lora.RegModemConfig.sx1276bits.Bw;
dudmuck 0:be215de91a68 139 for (i = 0; i < 10; i++ ) {
dudmuck 1:1cd0afbed23c 140 lora.RegModemConfig.sx1276bits.Bw = i;
dudmuck 0:be215de91a68 141 printf("%d ", i);
dudmuck 1:1cd0afbed23c 142 lora_printBw();
dudmuck 0:be215de91a68 143 printf("\r\n");
dudmuck 0:be215de91a68 144 }
dudmuck 1:1cd0afbed23c 145 lora.RegModemConfig.sx1276bits.Bw = s;
dudmuck 0:be215de91a68 146 } else if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 147 s = lora.RegModemConfig.sx1272bits.Bw;
dudmuck 0:be215de91a68 148 for (i = 0; i < 3; i++ ) {
dudmuck 1:1cd0afbed23c 149 lora.RegModemConfig.sx1272bits.Bw = i;
dudmuck 0:be215de91a68 150 printf("%d ", i);
dudmuck 1:1cd0afbed23c 151 lora_printBw();
dudmuck 0:be215de91a68 152 printf("\r\n");
dudmuck 0:be215de91a68 153 }
dudmuck 1:1cd0afbed23c 154 lora.RegModemConfig.sx1272bits.Bw = s;
dudmuck 0:be215de91a68 155 }
dudmuck 0:be215de91a68 156 }
dudmuck 0:be215de91a68 157
dudmuck 1:1cd0afbed23c 158 void lora_printSf()
dudmuck 0:be215de91a68 159 {
dudmuck 0:be215de91a68 160 // spreading factor same between sx127[26]
dudmuck 1:1cd0afbed23c 161 printf("sf:%d ", lora.getSf());
dudmuck 0:be215de91a68 162 }
dudmuck 0:be215de91a68 163
dudmuck 1:1cd0afbed23c 164 void lora_printRxPayloadCrcOn()
dudmuck 0:be215de91a68 165 {
dudmuck 1:1cd0afbed23c 166 bool on = lora.getRxPayloadCrcOn();
dudmuck 0:be215de91a68 167 //printf("RxPayloadCrcOn:%s ", on ? "on" : "off");
dudmuck 0:be215de91a68 168 if (on)
dudmuck 0:be215de91a68 169 printf("RxPayloadCrcOn:1 = Tx CRC Enabled\r\n");
dudmuck 0:be215de91a68 170 else
dudmuck 0:be215de91a68 171 printf("RxPayloadCrcOn:1 = no Tx CRC\r\n");
dudmuck 0:be215de91a68 172 }
dudmuck 0:be215de91a68 173
dudmuck 1:1cd0afbed23c 174 void lora_printTxContinuousMode()
dudmuck 0:be215de91a68 175 {
dudmuck 1:1cd0afbed23c 176 printf("TxContinuousMode:%d ", lora.RegModemConfig2.sx1276bits.TxContinuousMode); // same for sx1272 and sx1276
dudmuck 0:be215de91a68 177 }
dudmuck 0:be215de91a68 178
dudmuck 1:1cd0afbed23c 179 void lora_printAgcAutoOn()
dudmuck 0:be215de91a68 180 {
dudmuck 1:1cd0afbed23c 181 printf("AgcAutoOn:%d", lora.getAgcAutoOn());
dudmuck 0:be215de91a68 182 }
dudmuck 0:be215de91a68 183
dudmuck 1:1cd0afbed23c 184 void lora_print_dio()
dudmuck 0:be215de91a68 185 {
dudmuck 1:1cd0afbed23c 186 radio.RegDioMapping2.octet = radio.read_reg(REG_DIOMAPPING2);
dudmuck 0:be215de91a68 187 printf("DIO5:");
dudmuck 0:be215de91a68 188 switch (radio.RegDioMapping2.bits.Dio5Mapping) {
dudmuck 0:be215de91a68 189 case 0: printf("ModeReady"); break;
dudmuck 0:be215de91a68 190 case 1: printf("ClkOut"); break;
dudmuck 0:be215de91a68 191 case 2: printf("ClkOut"); break;
dudmuck 0:be215de91a68 192 }
dudmuck 0:be215de91a68 193 printf(" DIO4:");
dudmuck 0:be215de91a68 194 switch (radio.RegDioMapping2.bits.Dio4Mapping) {
dudmuck 0:be215de91a68 195 case 0: printf("CadDetected"); break;
dudmuck 0:be215de91a68 196 case 1: printf("PllLock"); break;
dudmuck 0:be215de91a68 197 case 2: printf("PllLock"); break;
dudmuck 0:be215de91a68 198 }
dudmuck 0:be215de91a68 199 radio.RegDioMapping1.octet = radio.read_reg(REG_DIOMAPPING1);
dudmuck 0:be215de91a68 200 printf(" DIO3:");
dudmuck 0:be215de91a68 201 switch (radio.RegDioMapping1.bits.Dio3Mapping) {
dudmuck 0:be215de91a68 202 case 0: printf("CadDone"); break;
dudmuck 0:be215de91a68 203 case 1: printf("ValidHeader"); break;
dudmuck 0:be215de91a68 204 case 2: printf("PayloadCrcError"); break;
dudmuck 0:be215de91a68 205 }
dudmuck 0:be215de91a68 206 printf(" DIO2:");
dudmuck 0:be215de91a68 207 switch (radio.RegDioMapping1.bits.Dio2Mapping) {
dudmuck 0:be215de91a68 208 case 0:
dudmuck 0:be215de91a68 209 case 1:
dudmuck 0:be215de91a68 210 case 2:
dudmuck 0:be215de91a68 211 printf("FhssChangeChannel");
dudmuck 0:be215de91a68 212 break;
dudmuck 0:be215de91a68 213 }
dudmuck 0:be215de91a68 214 printf(" DIO1:");
dudmuck 0:be215de91a68 215 switch (radio.RegDioMapping1.bits.Dio1Mapping) {
dudmuck 0:be215de91a68 216 case 0: printf("RxTimeout"); break;
dudmuck 0:be215de91a68 217 case 1: printf("FhssChangeChannel"); break;
dudmuck 0:be215de91a68 218 case 2: printf("CadDetected"); break;
dudmuck 0:be215de91a68 219 }
dudmuck 0:be215de91a68 220 printf(" DIO0:");
dudmuck 0:be215de91a68 221 switch (radio.RegDioMapping1.bits.Dio0Mapping) {
dudmuck 0:be215de91a68 222 case 0: printf("RxDone"); break;
dudmuck 0:be215de91a68 223 case 1: printf("TxDone"); break;
dudmuck 0:be215de91a68 224 case 2: printf("CadDone"); break;
dudmuck 0:be215de91a68 225 }
dudmuck 0:be215de91a68 226
dudmuck 0:be215de91a68 227 printf("\r\n");
dudmuck 0:be215de91a68 228 }
dudmuck 0:be215de91a68 229
dudmuck 1:1cd0afbed23c 230 void fsk_print_dio()
dudmuck 1:1cd0afbed23c 231 {
dudmuck 1:1cd0afbed23c 232 radio.RegDioMapping2.octet = radio.read_reg(REG_DIOMAPPING2);
dudmuck 1:1cd0afbed23c 233
dudmuck 2:c6b23a43a9d9 234 printf("DIO5:");
dudmuck 1:1cd0afbed23c 235 switch (radio.RegDioMapping2.bits.Dio5Mapping) {
dudmuck 1:1cd0afbed23c 236 case 0: printf("ClkOut"); break;
dudmuck 1:1cd0afbed23c 237 case 1: printf("PllLock"); break;
dudmuck 1:1cd0afbed23c 238 case 2:
dudmuck 1:1cd0afbed23c 239 if (fsk.RegPktConfig2.bits.DataModePacket)
dudmuck 1:1cd0afbed23c 240 printf("data");
dudmuck 1:1cd0afbed23c 241 else {
dudmuck 1:1cd0afbed23c 242 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 243 printf("preamble");
dudmuck 1:1cd0afbed23c 244 else
dudmuck 1:1cd0afbed23c 245 printf("rssi");
dudmuck 1:1cd0afbed23c 246 }
dudmuck 1:1cd0afbed23c 247 break;
dudmuck 1:1cd0afbed23c 248 case 3: printf("ModeReady"); break;
dudmuck 1:1cd0afbed23c 249 }
dudmuck 1:1cd0afbed23c 250
dudmuck 2:c6b23a43a9d9 251 printf(" DIO4:");
dudmuck 1:1cd0afbed23c 252 switch (radio.RegDioMapping2.bits.Dio4Mapping) {
dudmuck 1:1cd0afbed23c 253 case 0: printf("temp/eol"); break;
dudmuck 1:1cd0afbed23c 254 case 1: printf("PllLock"); break;
dudmuck 1:1cd0afbed23c 255 case 2: printf("TimeOut"); break;
dudmuck 1:1cd0afbed23c 256 case 3:
dudmuck 1:1cd0afbed23c 257 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 258 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 259 printf("preamble");
dudmuck 1:1cd0afbed23c 260 else
dudmuck 1:1cd0afbed23c 261 printf("rssi");
dudmuck 1:1cd0afbed23c 262 } else
dudmuck 1:1cd0afbed23c 263 printf("ModeReady");
dudmuck 1:1cd0afbed23c 264 break;
dudmuck 1:1cd0afbed23c 265 }
dudmuck 1:1cd0afbed23c 266
dudmuck 1:1cd0afbed23c 267 radio.RegDioMapping1.octet = radio.read_reg(REG_DIOMAPPING1);
dudmuck 1:1cd0afbed23c 268
dudmuck 2:c6b23a43a9d9 269 printf(" DIO3:");
dudmuck 1:1cd0afbed23c 270 switch (radio.RegDioMapping1.bits.Dio3Mapping) {
dudmuck 1:1cd0afbed23c 271 case 0: printf("Timeout"); break;
dudmuck 1:1cd0afbed23c 272 case 1:
dudmuck 1:1cd0afbed23c 273 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 274 printf("preamble");
dudmuck 1:1cd0afbed23c 275 else
dudmuck 1:1cd0afbed23c 276 printf("rssi");
dudmuck 1:1cd0afbed23c 277 break;
dudmuck 1:1cd0afbed23c 278 case 2: printf("?automode_status?"); break;
dudmuck 1:1cd0afbed23c 279 case 3: printf("TempChange/LowBat"); break;
dudmuck 1:1cd0afbed23c 280 }
dudmuck 1:1cd0afbed23c 281
dudmuck 2:c6b23a43a9d9 282 printf(" DIO2:");
dudmuck 1:1cd0afbed23c 283 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 284 switch (radio.RegDioMapping1.bits.Dio2Mapping) {
dudmuck 1:1cd0afbed23c 285 case 0: printf("FifoFull"); break;
dudmuck 1:1cd0afbed23c 286 case 1: printf("RxReady"); break;
dudmuck 1:1cd0afbed23c 287 case 2: printf("FifoFull/rx-timeout"); break;
dudmuck 1:1cd0afbed23c 288 case 3: printf("FifoFull/rx-syncadrs"); break;
dudmuck 1:1cd0afbed23c 289 }
dudmuck 1:1cd0afbed23c 290 } else {
dudmuck 1:1cd0afbed23c 291 printf("Data");
dudmuck 1:1cd0afbed23c 292 }
dudmuck 1:1cd0afbed23c 293
dudmuck 2:c6b23a43a9d9 294 printf(" DIO1:");
dudmuck 1:1cd0afbed23c 295 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 296 switch (radio.RegDioMapping1.bits.Dio1Mapping) {
dudmuck 1:1cd0afbed23c 297 case 0: printf("FifoThresh"); break;
dudmuck 1:1cd0afbed23c 298 case 1: printf("FifoEmpty"); break;
dudmuck 1:1cd0afbed23c 299 case 2: printf("FifoFull"); break;
dudmuck 1:1cd0afbed23c 300 case 3: printf("-3-"); break;
dudmuck 1:1cd0afbed23c 301 }
dudmuck 1:1cd0afbed23c 302 } else {
dudmuck 1:1cd0afbed23c 303 switch (radio.RegDioMapping1.bits.Dio1Mapping) {
dudmuck 1:1cd0afbed23c 304 case 0: printf("Dclk"); break;
dudmuck 1:1cd0afbed23c 305 case 1:
dudmuck 1:1cd0afbed23c 306 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 307 printf("preamble");
dudmuck 1:1cd0afbed23c 308 else
dudmuck 1:1cd0afbed23c 309 printf("rssi");
dudmuck 1:1cd0afbed23c 310 break;
dudmuck 1:1cd0afbed23c 311 case 2: printf("-2-"); break;
dudmuck 1:1cd0afbed23c 312 case 3: printf("-3-"); break;
dudmuck 1:1cd0afbed23c 313 }
dudmuck 1:1cd0afbed23c 314 }
dudmuck 1:1cd0afbed23c 315
dudmuck 2:c6b23a43a9d9 316 printf(" DIO0:");
dudmuck 1:1cd0afbed23c 317 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 318 switch (radio.RegDioMapping1.bits.Dio0Mapping) {
dudmuck 1:1cd0afbed23c 319 case 0: printf("PayloadReady/PacketSent"); break;
dudmuck 1:1cd0afbed23c 320 case 1: printf("CrcOk"); break;
dudmuck 1:1cd0afbed23c 321 case 2: printf("-2-"); break;
dudmuck 1:1cd0afbed23c 322 case 3: printf("TempChange/LowBat"); break;
dudmuck 1:1cd0afbed23c 323 }
dudmuck 1:1cd0afbed23c 324 } else {
dudmuck 1:1cd0afbed23c 325 switch (radio.RegDioMapping1.bits.Dio0Mapping) {
dudmuck 1:1cd0afbed23c 326 case 0: printf("SyncAdrs/TxReady"); break;
dudmuck 1:1cd0afbed23c 327 case 1:
dudmuck 1:1cd0afbed23c 328 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 1:1cd0afbed23c 329 printf("preamble");
dudmuck 1:1cd0afbed23c 330 else
dudmuck 1:1cd0afbed23c 331 printf("rssi");
dudmuck 1:1cd0afbed23c 332 break;
dudmuck 1:1cd0afbed23c 333 case 2: printf("RxReady"); break;
dudmuck 1:1cd0afbed23c 334 case 3: printf("-3-"); break;
dudmuck 1:1cd0afbed23c 335 }
dudmuck 1:1cd0afbed23c 336 }
dudmuck 1:1cd0afbed23c 337 printf("\r\n");
dudmuck 1:1cd0afbed23c 338 }
dudmuck 1:1cd0afbed23c 339
dudmuck 0:be215de91a68 340 void lora_print_status()
dudmuck 0:be215de91a68 341 {
dudmuck 0:be215de91a68 342 uint8_t d;
dudmuck 0:be215de91a68 343
dudmuck 0:be215de91a68 344 if (radio.type == SX1276)
dudmuck 0:be215de91a68 345 printf("\r\nSX1276 ");
dudmuck 0:be215de91a68 346 else if (radio.type == SX1272)
dudmuck 0:be215de91a68 347 printf("\r\nSX1272 ");
dudmuck 0:be215de91a68 348
dudmuck 0:be215de91a68 349 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:be215de91a68 350 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 351 printf("FSK\r\n");
dudmuck 0:be215de91a68 352 return;
dudmuck 0:be215de91a68 353 }
dudmuck 0:be215de91a68 354
dudmuck 1:1cd0afbed23c 355 lora_print_dio();
dudmuck 0:be215de91a68 356 printf("LoRa ");
dudmuck 0:be215de91a68 357
dudmuck 0:be215de91a68 358 // printing LoRa registers at 0x0d -> 0x3f
dudmuck 0:be215de91a68 359
dudmuck 1:1cd0afbed23c 360 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 361 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 0:be215de91a68 362
dudmuck 1:1cd0afbed23c 363 lora_printCodingRate(false); // false: transmitted coding rate
dudmuck 1:1cd0afbed23c 364 lora_printHeaderMode();
dudmuck 1:1cd0afbed23c 365 lora_printBw();
dudmuck 1:1cd0afbed23c 366 lora_printSf();
dudmuck 1:1cd0afbed23c 367 lora_printRxPayloadCrcOn();
dudmuck 0:be215de91a68 368 // RegModemStat
dudmuck 0:be215de91a68 369 printf("ModemStat:0x%02x\r\n", radio.read_reg(REG_LR_MODEMSTAT));
dudmuck 0:be215de91a68 370
dudmuck 0:be215de91a68 371 // fifo ptrs:
dudmuck 1:1cd0afbed23c 372 lora.RegPayloadLength = radio.read_reg(REG_LR_PAYLOADLENGTH);
dudmuck 1:1cd0afbed23c 373 lora.RegRxMaxPayloadLength = radio.read_reg(REG_LR_RX_MAX_PAYLOADLENGTH);
dudmuck 0:be215de91a68 374 printf("fifoptr=0x%02x txbase=0x%02x rxbase=0x%02x payloadLength=0x%02x maxlen=0x%02x",
dudmuck 0:be215de91a68 375 radio.read_reg(REG_LR_FIFOADDRPTR),
dudmuck 0:be215de91a68 376 radio.read_reg(REG_LR_FIFOTXBASEADDR),
dudmuck 0:be215de91a68 377 radio.read_reg(REG_LR_FIFORXBASEADDR),
dudmuck 1:1cd0afbed23c 378 lora.RegPayloadLength,
dudmuck 1:1cd0afbed23c 379 lora.RegRxMaxPayloadLength
dudmuck 0:be215de91a68 380 );
dudmuck 0:be215de91a68 381
dudmuck 1:1cd0afbed23c 382 lora.RegIrqFlags.octet = radio.read_reg(REG_LR_IRQFLAGS);
dudmuck 0:be215de91a68 383 printLoraIrqs_(false);
dudmuck 0:be215de91a68 384
dudmuck 1:1cd0afbed23c 385 lora.RegHopPeriod = radio.read_reg(REG_LR_HOPPERIOD);
dudmuck 1:1cd0afbed23c 386 if (lora.RegHopPeriod != 0) {
dudmuck 1:1cd0afbed23c 387 printf("\r\nHopPeriod:0x%02x\r\n", lora.RegHopPeriod);
dudmuck 0:be215de91a68 388 }
dudmuck 0:be215de91a68 389
dudmuck 0:be215de91a68 390 printf("SymbTimeout:0x%03x ", radio.read_u16(REG_LR_MODEMCONFIG2) & 0x3ff);
dudmuck 0:be215de91a68 391
dudmuck 1:1cd0afbed23c 392 lora.RegPreamble = radio.read_u16(REG_LR_PREAMBLEMSB);
dudmuck 1:1cd0afbed23c 393 printf("PreambleLength:0x%03x ", lora.RegPreamble);
dudmuck 0:be215de91a68 394
dudmuck 0:be215de91a68 395
dudmuck 0:be215de91a68 396 if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER || radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER_SINGLE) {
dudmuck 0:be215de91a68 397 d = radio.read_reg(REG_LR_RSSIVALUE);
dudmuck 0:be215de91a68 398 printf("rssi:%ddBm ", d-120);
dudmuck 0:be215de91a68 399 }
dudmuck 0:be215de91a68 400
dudmuck 1:1cd0afbed23c 401 lora_printTxContinuousMode();
dudmuck 0:be215de91a68 402
dudmuck 0:be215de91a68 403 printf("\r\n");
dudmuck 1:1cd0afbed23c 404 lora_printAgcAutoOn();
dudmuck 0:be215de91a68 405 if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 406 printf(" LowDataRateOptimize:%d\r\n", lora.RegModemConfig.sx1272bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 407 }
dudmuck 0:be215de91a68 408
dudmuck 0:be215de91a68 409 printf("\r\nHeaderCount:%d PacketCount:%d, ",
dudmuck 0:be215de91a68 410 radio.read_u16(REG_LR_RXHEADERCNTVALUE_MSB), radio.read_u16(REG_LR_RXPACKETCNTVALUE_MSB));
dudmuck 0:be215de91a68 411
dudmuck 0:be215de91a68 412 printf("Lora detection threshold:%02x\r\n", radio.read_reg(REG_LR_DETECTION_THRESHOLD));
dudmuck 1:1cd0afbed23c 413 lora.RegTest31.octet = radio.read_reg(REG_LR_TEST31);
dudmuck 1:1cd0afbed23c 414 printf("detect_trig_same_peaks_nb:%d\r\n", lora.RegTest31.bits.detect_trig_same_peaks_nb);
dudmuck 0:be215de91a68 415
dudmuck 0:be215de91a68 416 if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 417 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 418 printf("LowDataRateOptimize:%d\r\n", lora.RegModemConfig.sx1272bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 419 } else if (radio.type == SX1276) {
dudmuck 1:1cd0afbed23c 420 lora.RegModemConfig3.octet = radio.read_reg(REG_LR_MODEMCONFIG3);
dudmuck 1:1cd0afbed23c 421 printf("LowDataRateOptimize:%d\r\n", lora.RegModemConfig3.sx1276bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 422 }
dudmuck 0:be215de91a68 423
dudmuck 0:be215de91a68 424 printf("\r\n");
dudmuck 0:be215de91a68 425 //printf("A %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 0:be215de91a68 426 }
dudmuck 0:be215de91a68 427
dudmuck 1:1cd0afbed23c 428 uint16_t
dudmuck 1:1cd0afbed23c 429 fsk_get_PayloadLength(void)
dudmuck 1:1cd0afbed23c 430 {
dudmuck 1:1cd0afbed23c 431 fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
dudmuck 1:1cd0afbed23c 432
dudmuck 1:1cd0afbed23c 433 return fsk.RegPktConfig2.bits.PayloadLength;
dudmuck 1:1cd0afbed23c 434 }
dudmuck 1:1cd0afbed23c 435
dudmuck 1:1cd0afbed23c 436 void fsk_printAddressFiltering()
dudmuck 1:1cd0afbed23c 437 {
dudmuck 1:1cd0afbed23c 438 uint8_t FSKRegNodeAdrs, FSKRegBroadcastAdrs;
dudmuck 1:1cd0afbed23c 439
dudmuck 1:1cd0afbed23c 440 printf(" AddressFiltering:");
dudmuck 1:1cd0afbed23c 441 switch (fsk.RegPktConfig1.bits.AddressFiltering) {
dudmuck 1:1cd0afbed23c 442 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 443 case 1: // NodeAddress
dudmuck 1:1cd0afbed23c 444 FSKRegNodeAdrs = radio.read_reg(REG_FSK_NODEADRS);
dudmuck 1:1cd0afbed23c 445 printf("NodeAdrs:%02x\n", FSKRegNodeAdrs);
dudmuck 1:1cd0afbed23c 446 break;
dudmuck 1:1cd0afbed23c 447 case 2: // NodeAddress & BroadcastAddress
dudmuck 1:1cd0afbed23c 448 FSKRegNodeAdrs = radio.read_reg(REG_FSK_NODEADRS);
dudmuck 1:1cd0afbed23c 449 printf("NodeAdrs:%02x ", FSKRegNodeAdrs);
dudmuck 1:1cd0afbed23c 450 FSKRegBroadcastAdrs = radio.read_reg(REG_FSK_BROADCASTADRS);
dudmuck 1:1cd0afbed23c 451 printf("BroadcastAdrs:%02x\n", FSKRegBroadcastAdrs );
dudmuck 1:1cd0afbed23c 452 break;
dudmuck 1:1cd0afbed23c 453 default:
dudmuck 1:1cd0afbed23c 454 printf("%d", fsk.RegPktConfig1.bits.AddressFiltering);
dudmuck 1:1cd0afbed23c 455 break;
dudmuck 1:1cd0afbed23c 456 }
dudmuck 1:1cd0afbed23c 457 }
dudmuck 1:1cd0afbed23c 458
dudmuck 1:1cd0afbed23c 459 void fsk_print_IrqFlags2()
dudmuck 1:1cd0afbed23c 460 {
dudmuck 2:c6b23a43a9d9 461 RegIrqFlags2_t RegIrqFlags2;
dudmuck 1:1cd0afbed23c 462
dudmuck 1:1cd0afbed23c 463 printf("IrqFlags2: ");
dudmuck 2:c6b23a43a9d9 464 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 465 if (RegIrqFlags2.bits.FifoFull)
dudmuck 1:1cd0afbed23c 466 printf("FifoFull ");
dudmuck 2:c6b23a43a9d9 467 if (RegIrqFlags2.bits.FifoEmpty)
dudmuck 1:1cd0afbed23c 468 printf("FifoEmpty ");
dudmuck 2:c6b23a43a9d9 469 if (RegIrqFlags2.bits.FifoLevel)
dudmuck 1:1cd0afbed23c 470 printf("FifoLevel ");
dudmuck 2:c6b23a43a9d9 471 if (RegIrqFlags2.bits.FifoOverrun)
dudmuck 1:1cd0afbed23c 472 printf("FifoOverrun ");
dudmuck 2:c6b23a43a9d9 473 if (RegIrqFlags2.bits.PacketSent)
dudmuck 1:1cd0afbed23c 474 printf("PacketSent ");
dudmuck 2:c6b23a43a9d9 475 if (RegIrqFlags2.bits.PayloadReady)
dudmuck 1:1cd0afbed23c 476 printf("PayloadReady ");
dudmuck 2:c6b23a43a9d9 477 if (RegIrqFlags2.bits.CrcOk)
dudmuck 1:1cd0afbed23c 478 printf("CrcOk ");
dudmuck 2:c6b23a43a9d9 479 if (RegIrqFlags2.bits.LowBat)
dudmuck 1:1cd0afbed23c 480 printf("LowBat ");
dudmuck 2:c6b23a43a9d9 481 printf("\r\n");
dudmuck 1:1cd0afbed23c 482 }
dudmuck 1:1cd0afbed23c 483
dudmuck 1:1cd0afbed23c 484 void
dudmuck 1:1cd0afbed23c 485 fsk_print_status()
dudmuck 1:1cd0afbed23c 486 {
dudmuck 1:1cd0afbed23c 487 //uint16_t s;
dudmuck 2:c6b23a43a9d9 488 RegIrqFlags1_t RegIrqFlags1;
dudmuck 1:1cd0afbed23c 489
dudmuck 1:1cd0afbed23c 490 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 491 printf("LoRa\r\n");
dudmuck 1:1cd0afbed23c 492 return;
dudmuck 1:1cd0afbed23c 493 }
dudmuck 1:1cd0afbed23c 494
dudmuck 1:1cd0afbed23c 495 if (radio.RegOpMode.bits.ModulationType == 0) {
dudmuck 1:1cd0afbed23c 496 printf("FSK ");
dudmuck 1:1cd0afbed23c 497 switch (radio.RegOpMode.bits.ModulationShaping) {
dudmuck 1:1cd0afbed23c 498 case 1: printf("BT1.0 "); break;
dudmuck 1:1cd0afbed23c 499 case 2: printf("BT0.5 "); break;
dudmuck 1:1cd0afbed23c 500 case 3: printf("BT0.3 "); break;
dudmuck 1:1cd0afbed23c 501 }
dudmuck 1:1cd0afbed23c 502 } else if (radio.RegOpMode.bits.ModulationType == 1) {
dudmuck 1:1cd0afbed23c 503 printf("OOK ");
dudmuck 1:1cd0afbed23c 504 }
dudmuck 1:1cd0afbed23c 505
dudmuck 3:ab386fa756cc 506 printf("%dbps fdev:%dHz\r\n", fsk.get_bitrate(), fsk.get_tx_fdev_hz());
dudmuck 1:1cd0afbed23c 507
dudmuck 1:1cd0afbed23c 508 fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
dudmuck 1:1cd0afbed23c 509
dudmuck 1:1cd0afbed23c 510 fsk_print_dio();
dudmuck 1:1cd0afbed23c 511
dudmuck 1:1cd0afbed23c 512 printf("rxbw:%dHz ", fsk.get_rx_bw_hz(REG_FSK_RXBW));
dudmuck 1:1cd0afbed23c 513 printf("afcbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_AFCBW));
dudmuck 1:1cd0afbed23c 514
dudmuck 1:1cd0afbed23c 515 fsk.RegRssiConfig.octet = radio.read_reg(REG_FSK_RSSICONFIG);
dudmuck 1:1cd0afbed23c 516 printf("RssiOffset:%ddB smoothing:%dsamples\r\n", fsk.RegRssiConfig.bits.RssiOffset, 1 << (fsk.RegRssiConfig.bits.RssiSmoothing+1));
dudmuck 1:1cd0afbed23c 517
dudmuck 1:1cd0afbed23c 518
dudmuck 1:1cd0afbed23c 519 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 1:1cd0afbed23c 520
dudmuck 1:1cd0afbed23c 521 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 522 uint16_t len;
dudmuck 1:1cd0afbed23c 523 /* packet mode */
dudmuck 1:1cd0afbed23c 524 len = fsk_get_PayloadLength();
dudmuck 1:1cd0afbed23c 525 printf("packet RegPayloadLength:0x%03x ", len);
dudmuck 1:1cd0afbed23c 526
dudmuck 1:1cd0afbed23c 527 if (fsk.RegPktConfig2.bits.BeaconOn)
dudmuck 1:1cd0afbed23c 528 printf("BeaconOn ");
dudmuck 1:1cd0afbed23c 529
dudmuck 1:1cd0afbed23c 530 fsk.RegFifoThreshold.octet = radio.read_reg(REG_FSK_FIFOTHRESH);
dudmuck 1:1cd0afbed23c 531 printf("FifoThreshold:%d TxStartCondition:", fsk.RegFifoThreshold.bits.FifoThreshold);
dudmuck 1:1cd0afbed23c 532 if (fsk.RegFifoThreshold.bits.TxStartCondition)
dudmuck 1:1cd0afbed23c 533 printf("!FifoEmpty");
dudmuck 1:1cd0afbed23c 534 else
dudmuck 1:1cd0afbed23c 535 printf("FifoLevel");
dudmuck 1:1cd0afbed23c 536
dudmuck 1:1cd0afbed23c 537 printf("\r\nAutoRestartRxMode:");
dudmuck 1:1cd0afbed23c 538 switch (fsk.RegSyncConfig.bits.AutoRestartRxMode) {
dudmuck 1:1cd0afbed23c 539 case 0: printf("off "); break;
dudmuck 1:1cd0afbed23c 540 case 1: printf("no-pll-wait "); break;
dudmuck 1:1cd0afbed23c 541 case 2: printf("pll-wait "); break;
dudmuck 1:1cd0afbed23c 542 case 3: printf("3 "); break;
dudmuck 1:1cd0afbed23c 543 }
dudmuck 1:1cd0afbed23c 544 //...todo
dudmuck 1:1cd0afbed23c 545
dudmuck 1:1cd0afbed23c 546 printf("PreambleSize:%d ", radio.read_u16(REG_FSK_PREAMBLEMSB));
dudmuck 1:1cd0afbed23c 547
dudmuck 1:1cd0afbed23c 548 fsk.RegOokPeak.octet = radio.read_reg(REG_FSK_OOKPEAK);
dudmuck 1:1cd0afbed23c 549 if (fsk.RegOokPeak.bits.barker_en)
dudmuck 1:1cd0afbed23c 550 printf("barker ");
dudmuck 1:1cd0afbed23c 551 if (!fsk.RegOokPeak.bits.BitSyncOn)
dudmuck 1:1cd0afbed23c 552 printf("BitSyncOff ");
dudmuck 1:1cd0afbed23c 553 //...todo
dudmuck 1:1cd0afbed23c 554
dudmuck 1:1cd0afbed23c 555 fsk.RegPktConfig1.octet = radio.read_reg(REG_FSK_PACKETCONFIG1);
dudmuck 1:1cd0afbed23c 556 if (fsk.RegPktConfig1.bits.PacketFormatVariable)
dudmuck 1:1cd0afbed23c 557 printf("variable");
dudmuck 1:1cd0afbed23c 558 else
dudmuck 1:1cd0afbed23c 559 printf("fixed");
dudmuck 1:1cd0afbed23c 560 printf("-length\r\ncrc");
dudmuck 1:1cd0afbed23c 561 if (fsk.RegPktConfig1.bits.CrcOn) {
dudmuck 1:1cd0afbed23c 562 printf("On");
dudmuck 1:1cd0afbed23c 563 } else
dudmuck 1:1cd0afbed23c 564 printf("Off");
dudmuck 1:1cd0afbed23c 565 printf(" crctype:");
dudmuck 1:1cd0afbed23c 566 if (fsk.RegPktConfig1.bits.CrCWhiteningType)
dudmuck 1:1cd0afbed23c 567 printf("IBM");
dudmuck 1:1cd0afbed23c 568 else
dudmuck 1:1cd0afbed23c 569 printf("CCITT");
dudmuck 1:1cd0afbed23c 570 printf(" dcFree:");
dudmuck 1:1cd0afbed23c 571 switch (fsk.RegPktConfig1.bits.DcFree) {
dudmuck 1:1cd0afbed23c 572 case 0: printf("none "); break;
dudmuck 1:1cd0afbed23c 573 case 1: printf("Manchester "); break;
dudmuck 1:1cd0afbed23c 574 case 2: printf("Whitening "); break;
dudmuck 1:1cd0afbed23c 575 case 3: printf("reserved "); break;
dudmuck 1:1cd0afbed23c 576 }
dudmuck 1:1cd0afbed23c 577 fsk_printAddressFiltering();
dudmuck 1:1cd0afbed23c 578
dudmuck 1:1cd0afbed23c 579 printf("\r\n");
dudmuck 1:1cd0afbed23c 580 fsk_print_IrqFlags2();
dudmuck 1:1cd0afbed23c 581 } else {
dudmuck 1:1cd0afbed23c 582 /* continuous mode */
dudmuck 1:1cd0afbed23c 583 printf("continuous ");
dudmuck 1:1cd0afbed23c 584 }
dudmuck 1:1cd0afbed23c 585
dudmuck 1:1cd0afbed23c 586 fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
dudmuck 1:1cd0afbed23c 587 printf("PreambleDetect:");
dudmuck 1:1cd0afbed23c 588 if (fsk.RegPreambleDetect.bits.PreambleDetectorOn) {
dudmuck 1:1cd0afbed23c 589 printf("size=%d,tol=%d ",
dudmuck 1:1cd0afbed23c 590 fsk.RegPreambleDetect.bits.PreambleDetectorSize,
dudmuck 1:1cd0afbed23c 591 fsk.RegPreambleDetect.bits.PreambleDetectorTol);
dudmuck 1:1cd0afbed23c 592 } else
dudmuck 1:1cd0afbed23c 593 printf("Off ");
dudmuck 1:1cd0afbed23c 594
dudmuck 1:1cd0afbed23c 595 printf(" syncsize:%d ", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 1:1cd0afbed23c 596 printf(" : %02x ", radio.read_reg(REG_FSK_SYNCVALUE1));
dudmuck 1:1cd0afbed23c 597 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE2));
dudmuck 1:1cd0afbed23c 598 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE3));
dudmuck 1:1cd0afbed23c 599 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE4));
dudmuck 1:1cd0afbed23c 600 printf("\r\n"); // end sync config
dudmuck 1:1cd0afbed23c 601
dudmuck 1:1cd0afbed23c 602 fsk.RegAfcFei.octet = radio.read_reg(REG_FSK_AFCFEI);
dudmuck 1:1cd0afbed23c 603 printf("afcAutoClear:");
dudmuck 1:1cd0afbed23c 604 if (fsk.RegAfcFei.bits.AfcAutoClearOn)
dudmuck 1:1cd0afbed23c 605 printf("On");
dudmuck 1:1cd0afbed23c 606 else
dudmuck 1:1cd0afbed23c 607 printf("OFF");
dudmuck 1:1cd0afbed23c 608 printf(" afc:%dHz ", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_AFCMSB)));
dudmuck 1:1cd0afbed23c 609
dudmuck 1:1cd0afbed23c 610 printf("fei:%dHz\r\n", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_FEIMSB)));
dudmuck 1:1cd0afbed23c 611
dudmuck 1:1cd0afbed23c 612 fsk.RegRxConfig.octet = radio.read_reg(REG_FSK_RXCONFIG);
dudmuck 1:1cd0afbed23c 613 printf("RxTrigger:");
dudmuck 1:1cd0afbed23c 614 switch (fsk.RegRxConfig.bits.RxTrigger) {
dudmuck 1:1cd0afbed23c 615 case 0: printf("none "); break;
dudmuck 1:1cd0afbed23c 616 case 1: printf("rssi "); break;
dudmuck 1:1cd0afbed23c 617 case 6: printf("preamble "); break;
dudmuck 1:1cd0afbed23c 618 case 7: printf("both "); break;
dudmuck 1:1cd0afbed23c 619 default: printf("-%d- ", fsk.RegRxConfig.bits.RxTrigger); break;
dudmuck 1:1cd0afbed23c 620 }
dudmuck 1:1cd0afbed23c 621 printf("AfcAuto:");
dudmuck 1:1cd0afbed23c 622 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 1:1cd0afbed23c 623 printf("On ");
dudmuck 1:1cd0afbed23c 624 else
dudmuck 1:1cd0afbed23c 625 printf("OFF ");
dudmuck 1:1cd0afbed23c 626 if (!fsk.RegRxConfig.bits.AgcAutoOn) {
dudmuck 1:1cd0afbed23c 627 radio.RegLna.octet = radio.read_reg(REG_LNA);
dudmuck 1:1cd0afbed23c 628 printf("AgcAutoOff:G%d ", radio.RegLna.bits.LnaGain);
dudmuck 1:1cd0afbed23c 629 }
dudmuck 1:1cd0afbed23c 630
dudmuck 1:1cd0afbed23c 631 fsk.RegTimerResol.octet = radio.read_reg(REG_FSK_TIMERRESOL);
dudmuck 1:1cd0afbed23c 632 if (fsk.RegTimerResol.bits.hlm_started)
dudmuck 1:1cd0afbed23c 633 printf("hlm_started ");
dudmuck 1:1cd0afbed23c 634 else
dudmuck 1:1cd0afbed23c 635 printf("hlm_stopped ");
dudmuck 1:1cd0afbed23c 636
dudmuck 1:1cd0afbed23c 637 fsk.RegRssiThresh = radio.read_reg(REG_FSK_RSSITHRESH);
dudmuck 1:1cd0afbed23c 638 printf("rssiThreshold:-%.1f@%02x ", fsk.RegRssiThresh / 2.0, REG_FSK_RSSITHRESH);
dudmuck 1:1cd0afbed23c 639
dudmuck 1:1cd0afbed23c 640 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 1:1cd0afbed23c 641 if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER ||
dudmuck 1:1cd0afbed23c 642 radio.RegOpMode.bits.Mode == RF_OPMODE_SYNTHESIZER_RX)
dudmuck 1:1cd0afbed23c 643 {
dudmuck 1:1cd0afbed23c 644 printf("rssi:-%.1f ", radio.read_reg(REG_FSK_RSSIVALUE) / 2.0);
dudmuck 1:1cd0afbed23c 645 }
dudmuck 1:1cd0afbed23c 646
dudmuck 1:1cd0afbed23c 647 fsk.RegSeqConfig1.octet = radio.read_reg(REG_FSK_SEQCONFIG1);
dudmuck 1:1cd0afbed23c 648 printf("\r\nsequencer: ");
dudmuck 1:1cd0afbed23c 649 printf("FromStart:");
dudmuck 1:1cd0afbed23c 650 switch (fsk.RegSeqConfig1.bits.FromStart) {
dudmuck 1:1cd0afbed23c 651 case 0:
dudmuck 1:1cd0afbed23c 652 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 653 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 654 printf("idle");
dudmuck 1:1cd0afbed23c 655 else
dudmuck 1:1cd0afbed23c 656 printf("sequencerOff");
dudmuck 1:1cd0afbed23c 657 break;
dudmuck 1:1cd0afbed23c 658 case 1: printf("rx"); break;
dudmuck 1:1cd0afbed23c 659 case 2: printf("tx"); break;
dudmuck 1:1cd0afbed23c 660 case 3: printf("tx on fifolevel"); break;
dudmuck 1:1cd0afbed23c 661 }
dudmuck 1:1cd0afbed23c 662 printf(" lowPowerSelection:");
dudmuck 1:1cd0afbed23c 663 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 664 printf("idle");
dudmuck 1:1cd0afbed23c 665 else
dudmuck 1:1cd0afbed23c 666 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 667 if (fsk.RegSeqConfig1.bits.FromStart != 0 &&
dudmuck 1:1cd0afbed23c 668 fsk.RegSeqConfig1.bits.LowPowerSelection != 0)
dudmuck 1:1cd0afbed23c 669 { // if sequencer enabled:
dudmuck 1:1cd0afbed23c 670 printf("\r\nsequencer: IdleMode:");
dudmuck 1:1cd0afbed23c 671 if (fsk.RegSeqConfig1.bits.IdleMode)
dudmuck 1:1cd0afbed23c 672 printf("Sleep");
dudmuck 1:1cd0afbed23c 673 else
dudmuck 1:1cd0afbed23c 674 printf("standby");
dudmuck 1:1cd0afbed23c 675 printf("\r\nsequencer: FromIdle to:");
dudmuck 1:1cd0afbed23c 676 if (fsk.RegSeqConfig1.bits.FromIdle)
dudmuck 1:1cd0afbed23c 677 printf("rx");
dudmuck 1:1cd0afbed23c 678 else
dudmuck 1:1cd0afbed23c 679 printf("tx");
dudmuck 1:1cd0afbed23c 680 printf("\r\nsequencer: FromTransmit to:");
dudmuck 1:1cd0afbed23c 681 if (fsk.RegSeqConfig1.bits.FromTransmit)
dudmuck 1:1cd0afbed23c 682 printf("rx-on-PacketSent");
dudmuck 1:1cd0afbed23c 683 else {
dudmuck 1:1cd0afbed23c 684 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 685 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 686 printf("idle");
dudmuck 1:1cd0afbed23c 687 else
dudmuck 1:1cd0afbed23c 688 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 689 printf("-on-PacketSent");
dudmuck 1:1cd0afbed23c 690 }
dudmuck 1:1cd0afbed23c 691 fsk.RegSeqConfig2.octet = radio.read_reg(REG_FSK_SEQCONFIG2);
dudmuck 1:1cd0afbed23c 692 printf("\r\nsequencer: FromReceive:");
dudmuck 1:1cd0afbed23c 693 switch (fsk.RegSeqConfig2.bits.FromReceive) {
dudmuck 1:1cd0afbed23c 694 case 1: printf("PacketRecevied on PayloadReady"); break;
dudmuck 1:1cd0afbed23c 695 case 2:
dudmuck 1:1cd0afbed23c 696 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 697 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 698 printf("idle");
dudmuck 1:1cd0afbed23c 699 else
dudmuck 1:1cd0afbed23c 700 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 701 printf("-on-payloadReady");
dudmuck 1:1cd0afbed23c 702 break;
dudmuck 1:1cd0afbed23c 703 case 3: printf("PacketRecevied-on-CrcOk"); break;
dudmuck 1:1cd0afbed23c 704 case 4: printf("SequencerOff-on-Rssi"); break;
dudmuck 1:1cd0afbed23c 705 case 5: printf("SequencerOff-on-SyncAddress"); break;
dudmuck 1:1cd0afbed23c 706 case 6: printf("SequencerOff-PreambleDetect"); break;
dudmuck 1:1cd0afbed23c 707 default: printf("-%d-", fsk.RegSeqConfig2.bits.FromReceive); break;
dudmuck 1:1cd0afbed23c 708 }
dudmuck 1:1cd0afbed23c 709 printf("\r\nsequencer: FromRxTimeout:");
dudmuck 1:1cd0afbed23c 710 switch (fsk.RegSeqConfig2.bits.FromRxTimeout) {
dudmuck 1:1cd0afbed23c 711 case 0: printf("rx"); break;
dudmuck 1:1cd0afbed23c 712 case 1: printf("tx"); break;
dudmuck 1:1cd0afbed23c 713 case 2:
dudmuck 1:1cd0afbed23c 714 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 715 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 716 printf("idle");
dudmuck 1:1cd0afbed23c 717 else
dudmuck 1:1cd0afbed23c 718 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 719 break;
dudmuck 1:1cd0afbed23c 720 case 3: printf("SequencerOff"); break;
dudmuck 1:1cd0afbed23c 721 }
dudmuck 1:1cd0afbed23c 722 printf("\r\nsequencer: FromPacketReceived to:");
dudmuck 1:1cd0afbed23c 723 switch (fsk.RegSeqConfig2.bits.FromPacketReceived) {
dudmuck 1:1cd0afbed23c 724 case 0: printf("SequencerOff"); break;
dudmuck 1:1cd0afbed23c 725 case 1: printf("tx on FifoEmpty"); break;
dudmuck 1:1cd0afbed23c 726 case 2:
dudmuck 1:1cd0afbed23c 727 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 728 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 729 printf("idle");
dudmuck 1:1cd0afbed23c 730 else
dudmuck 1:1cd0afbed23c 731 printf("sequencerOff");
dudmuck 1:1cd0afbed23c 732 break;
dudmuck 1:1cd0afbed23c 733 case 3: printf("rx via fs"); break;
dudmuck 1:1cd0afbed23c 734 case 4: printf("rx"); break;
dudmuck 1:1cd0afbed23c 735 }
dudmuck 1:1cd0afbed23c 736
dudmuck 1:1cd0afbed23c 737 fsk.RegTimerResol.octet = radio.read_reg(REG_FSK_TIMERRESOL);
dudmuck 1:1cd0afbed23c 738 printf("\r\nsequencer: timer1:");
dudmuck 1:1cd0afbed23c 739 switch (fsk.RegTimerResol.bits.timer1_resol) {
dudmuck 1:1cd0afbed23c 740 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 741 case 1: printf("%dus", radio.read_reg(REG_FSK_TIMER1COEF) * 64); break;
dudmuck 1:1cd0afbed23c 742 case 2: printf("%.1fms", radio.read_reg(REG_FSK_TIMER1COEF) * 4.1); break;
dudmuck 1:1cd0afbed23c 743 case 3: printf("%.1fs", radio.read_reg(REG_FSK_TIMER1COEF) * 0.262); break;
dudmuck 1:1cd0afbed23c 744 }
dudmuck 1:1cd0afbed23c 745
dudmuck 1:1cd0afbed23c 746 printf(" timer2:");
dudmuck 1:1cd0afbed23c 747 switch (fsk.RegTimerResol.bits.timer2_resol) {
dudmuck 1:1cd0afbed23c 748 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 749 case 1: printf("%dus", radio.read_reg(REG_FSK_TIMER2COEF) * 64); break;
dudmuck 1:1cd0afbed23c 750 case 2: printf("%.1fms", radio.read_reg(REG_FSK_TIMER2COEF) * 4.1); break;
dudmuck 1:1cd0afbed23c 751 case 3: printf("%.1fs", radio.read_reg(REG_FSK_TIMER2COEF) * 0.262); break;
dudmuck 1:1cd0afbed23c 752 }
dudmuck 1:1cd0afbed23c 753 } // ..if sequencer enabled
dudmuck 1:1cd0afbed23c 754
dudmuck 1:1cd0afbed23c 755 printf("\r\nIrqFlags1:");
dudmuck 2:c6b23a43a9d9 756 RegIrqFlags1.octet = radio.read_reg(REG_FSK_IRQFLAGS1);
dudmuck 2:c6b23a43a9d9 757 if (RegIrqFlags1.bits.ModeReady)
dudmuck 1:1cd0afbed23c 758 printf("ModeReady ");
dudmuck 2:c6b23a43a9d9 759 if (RegIrqFlags1.bits.RxReady)
dudmuck 1:1cd0afbed23c 760 printf("RxReady ");
dudmuck 2:c6b23a43a9d9 761 if (RegIrqFlags1.bits.TxReady)
dudmuck 1:1cd0afbed23c 762 printf("TxReady ");
dudmuck 2:c6b23a43a9d9 763 if (RegIrqFlags1.bits.PllLock)
dudmuck 1:1cd0afbed23c 764 printf("PllLock ");
dudmuck 2:c6b23a43a9d9 765 if (RegIrqFlags1.bits.Rssi)
dudmuck 1:1cd0afbed23c 766 printf("Rssi ");
dudmuck 2:c6b23a43a9d9 767 if (RegIrqFlags1.bits.Timeout)
dudmuck 1:1cd0afbed23c 768 printf("Timeout ");
dudmuck 2:c6b23a43a9d9 769 if (RegIrqFlags1.bits.PreambleDetect)
dudmuck 1:1cd0afbed23c 770 printf("PreambleDetect ");
dudmuck 2:c6b23a43a9d9 771 if (RegIrqFlags1.bits.SyncAddressMatch)
dudmuck 1:1cd0afbed23c 772 printf("SyncAddressMatch ");
dudmuck 1:1cd0afbed23c 773
dudmuck 1:1cd0afbed23c 774 printf("\r\n");
dudmuck 1:1cd0afbed23c 775
dudmuck 1:1cd0afbed23c 776 /* TODO if (!SX1272FSK->RegPktConfig1.bits.PacketFormatVariable) { // if fixed-length packet format:
dudmuck 1:1cd0afbed23c 777 s = fsk_get_PayloadLength();
dudmuck 1:1cd0afbed23c 778 if (s > FSK_LARGE_PKT_THRESHOLD)
dudmuck 1:1cd0afbed23c 779 flags.fifo_flow_ctl = 1;
dudmuck 1:1cd0afbed23c 780 else
dudmuck 1:1cd0afbed23c 781 flags.fifo_flow_ctl = 0;
dudmuck 1:1cd0afbed23c 782 }*/
dudmuck 1:1cd0afbed23c 783
dudmuck 1:1cd0afbed23c 784 fsk.RegImageCal.octet = radio.read_reg(REG_FSK_IMAGECAL);
dudmuck 1:1cd0afbed23c 785 if (fsk.RegImageCal.bits.TempMonitorOff) {
dudmuck 1:1cd0afbed23c 786 printf("TempMonitorOff[\r0m\n");
dudmuck 1:1cd0afbed23c 787 } else {
dudmuck 1:1cd0afbed23c 788 printf("TempThreshold:");
dudmuck 1:1cd0afbed23c 789 switch (fsk.RegImageCal.bits.TempThreshold) {
dudmuck 1:1cd0afbed23c 790 case 0: printf("5C"); break;
dudmuck 1:1cd0afbed23c 791 case 1: printf("10C"); break;
dudmuck 1:1cd0afbed23c 792 case 2: printf("15C"); break;
dudmuck 1:1cd0afbed23c 793 case 3: printf("20C"); break;
dudmuck 1:1cd0afbed23c 794 }
dudmuck 1:1cd0afbed23c 795 printf("\r\n");
dudmuck 1:1cd0afbed23c 796 }
dudmuck 1:1cd0afbed23c 797 if (fsk.RegImageCal.bits.ImageCalRunning)
dudmuck 1:1cd0afbed23c 798 printf("ImageCalRunning[\r0m\n");
dudmuck 1:1cd0afbed23c 799
dudmuck 1:1cd0afbed23c 800 /* printf("flags.fifo_flow_ctl:%d pktidx:%d rx_pktlen:%d", flags.fifo_flow_ctl, pktidx, rx_pktlen);
dudmuck 1:1cd0afbed23c 801 printf("\n");
dudmuck 1:1cd0afbed23c 802
dudmuck 1:1cd0afbed23c 803 //printf("DIO0_PIN:%d\n", digitalRead(DIO0_PIN));
dudmuck 1:1cd0afbed23c 804 printf("pkt_buf_len=%d remaining=%d\n", pk*/
dudmuck 1:1cd0afbed23c 805 }
dudmuck 1:1cd0afbed23c 806
dudmuck 0:be215de91a68 807 void printOpMode()
dudmuck 0:be215de91a68 808 {
dudmuck 0:be215de91a68 809 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:be215de91a68 810 switch (radio.RegOpMode.bits.Mode) {
dudmuck 0:be215de91a68 811 case RF_OPMODE_SLEEP: printf("sleep"); break;
dudmuck 0:be215de91a68 812 case RF_OPMODE_STANDBY: printf("stby"); break;
dudmuck 0:be215de91a68 813 case RF_OPMODE_SYNTHESIZER_TX: printf("fstx"); break;
dudmuck 0:be215de91a68 814 case RF_OPMODE_TRANSMITTER: printf("tx"); break;
dudmuck 0:be215de91a68 815 case RF_OPMODE_SYNTHESIZER_RX: printf("fsrx"); break;
dudmuck 0:be215de91a68 816 case RF_OPMODE_RECEIVER: printf("rx"); break;
dudmuck 0:be215de91a68 817 case 6:
dudmuck 0:be215de91a68 818 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:be215de91a68 819 printf("rxs");
dudmuck 0:be215de91a68 820 else
dudmuck 0:be215de91a68 821 printf("-6-");
dudmuck 0:be215de91a68 822 break; // todo: different lora/fsk
dudmuck 0:be215de91a68 823 case 7:
dudmuck 0:be215de91a68 824 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:be215de91a68 825 printf("cad");
dudmuck 0:be215de91a68 826 else
dudmuck 0:be215de91a68 827 printf("-7-");
dudmuck 0:be215de91a68 828 break; // todo: different lora/fsk
dudmuck 0:be215de91a68 829 }
dudmuck 0:be215de91a68 830 }
dudmuck 0:be215de91a68 831
dudmuck 0:be215de91a68 832 void
dudmuck 0:be215de91a68 833 printPa()
dudmuck 0:be215de91a68 834 {
dudmuck 0:be215de91a68 835 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:be215de91a68 836 if (radio.RegPaConfig.bits.PaSelect) {
dudmuck 0:be215de91a68 837 float output_dBm = 17 - (15-radio.RegPaConfig.bits.OutputPower);
dudmuck 0:be215de91a68 838 printf(" PABOOST OutputPower=%.1fdBm", output_dBm);
dudmuck 0:be215de91a68 839 } else {
dudmuck 0:be215de91a68 840 float pmax = (0.6*radio.RegPaConfig.bits.MaxPower) + 10.8;
dudmuck 0:be215de91a68 841 float output_dBm = pmax - (15-radio.RegPaConfig.bits.OutputPower);
dudmuck 0:be215de91a68 842 printf(" RFO pmax=%.1fdBm OutputPower=%.1fdBm", pmax, output_dBm);
dudmuck 0:be215de91a68 843 }
dudmuck 0:be215de91a68 844 }
dudmuck 0:be215de91a68 845
dudmuck 0:be215de91a68 846 void /* things always present, whether lora or fsk */
dudmuck 0:be215de91a68 847 common_print_status()
dudmuck 0:be215de91a68 848 {
dudmuck 0:be215de91a68 849 printf("version:0x%02x %.3fMHz ", radio.read_reg(REG_VERSION), radio.get_frf_MHz());
dudmuck 0:be215de91a68 850 printOpMode();
dudmuck 0:be215de91a68 851
dudmuck 0:be215de91a68 852 printPa();
dudmuck 0:be215de91a68 853
dudmuck 0:be215de91a68 854 radio.RegOcp.octet = radio.read_reg(REG_OCP);
dudmuck 0:be215de91a68 855 if (radio.RegOcp.bits.OcpOn) {
dudmuck 0:be215de91a68 856 int imax = 0;
dudmuck 0:be215de91a68 857 if (radio.RegOcp.bits.OcpTrim < 16)
dudmuck 0:be215de91a68 858 imax = 45 + (5 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:be215de91a68 859 else if (radio.RegOcp.bits.OcpTrim < 28)
dudmuck 0:be215de91a68 860 imax = -30 + (10 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:be215de91a68 861 else
dudmuck 0:be215de91a68 862 imax = 240;
dudmuck 0:be215de91a68 863 printf(" OcpOn %dmA ", imax);
dudmuck 0:be215de91a68 864 } else
dudmuck 0:be215de91a68 865 printf(" OcpOFF ");
dudmuck 0:be215de91a68 866
dudmuck 0:be215de91a68 867 printf("\r\n");
dudmuck 0:be215de91a68 868
dudmuck 0:be215de91a68 869 }
dudmuck 0:be215de91a68 870
dudmuck 0:be215de91a68 871 void print_rx_buf(int len)
dudmuck 0:be215de91a68 872 {
dudmuck 0:be215de91a68 873 int i;
dudmuck 0:be215de91a68 874
dudmuck 0:be215de91a68 875 printf("000:");
dudmuck 0:be215de91a68 876 for (i = 0; i < len; i++) {
dudmuck 0:be215de91a68 877 //printf("(%d)%02x ", i % 16, rx_buf[i]);
dudmuck 0:be215de91a68 878 printf("%02x ", radio.rx_buf[i]);
dudmuck 0:be215de91a68 879 if (i % 16 == 15 && i != len-1)
dudmuck 0:be215de91a68 880 printf("\r\n%03d:", i+1);
dudmuck 0:be215de91a68 881
dudmuck 0:be215de91a68 882 }
dudmuck 0:be215de91a68 883 printf("\r\n");
dudmuck 0:be215de91a68 884 }
dudmuck 0:be215de91a68 885
dudmuck 0:be215de91a68 886 void
dudmuck 0:be215de91a68 887 service_radio()
dudmuck 0:be215de91a68 888 {
dudmuck 1:1cd0afbed23c 889 service_action_e act;
dudmuck 1:1cd0afbed23c 890
dudmuck 1:1cd0afbed23c 891 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 892 act = lora.service();
dudmuck 0:be215de91a68 893
dudmuck 1:1cd0afbed23c 894 switch (act) {
dudmuck 1:1cd0afbed23c 895 case SERVICE_READ_FIFO:
dudmuck 1:1cd0afbed23c 896 float dbm;
dudmuck 1:1cd0afbed23c 897 if (app == APP_NONE) {
dudmuck 1:1cd0afbed23c 898 printLoraIrqs_(false);
dudmuck 1:1cd0afbed23c 899 if (lora.RegHopPeriod > 0) {
dudmuck 1:1cd0afbed23c 900 lora.RegHopChannel.octet = radio.read_reg(REG_LR_HOPCHANNEL);
dudmuck 1:1cd0afbed23c 901 printf("HopCH:%d ", lora.RegHopChannel.bits.FhssPresentChannel);
dudmuck 1:1cd0afbed23c 902 }
dudmuck 1:1cd0afbed23c 903 lora_printCodingRate(true); // true: of received packet
dudmuck 1:1cd0afbed23c 904 dbm = lora.get_pkt_rssi();
dudmuck 1:1cd0afbed23c 905 printf(" crc%s %.1fdB %.1fdBm\r\n",
dudmuck 1:1cd0afbed23c 906 lora.RegHopChannel.bits.RxPayloadCrcOn ? "On" : "OFF",
dudmuck 1:1cd0afbed23c 907 lora.RegPktSnrValue / 4.0,
dudmuck 1:1cd0afbed23c 908 dbm
dudmuck 1:1cd0afbed23c 909 );
dudmuck 1:1cd0afbed23c 910 print_rx_buf(lora.RegRxNbBytes);
dudmuck 1:1cd0afbed23c 911 } else if (app == APP_CHAT) {
dudmuck 1:1cd0afbed23c 912 if (lora.RegHopChannel.bits.RxPayloadCrcOn) {
dudmuck 1:1cd0afbed23c 913 if (lora.RegIrqFlags.bits.PayloadCrcError)
dudmuck 1:1cd0afbed23c 914 printf("crcError\r\n");
dudmuck 1:1cd0afbed23c 915 else {
dudmuck 1:1cd0afbed23c 916 int n = lora.RegRxNbBytes;
dudmuck 1:1cd0afbed23c 917 radio.rx_buf[n++] = '\r';
dudmuck 1:1cd0afbed23c 918 radio.rx_buf[n++] = '\n';
dudmuck 1:1cd0afbed23c 919 radio.rx_buf[n] = 0; // null terminate
dudmuck 1:1cd0afbed23c 920 printf((char *)radio.rx_buf);
dudmuck 1:1cd0afbed23c 921 }
dudmuck 1:1cd0afbed23c 922 } else
dudmuck 1:1cd0afbed23c 923 printf("crcOff\r\n");
dudmuck 1:1cd0afbed23c 924
dudmuck 1:1cd0afbed23c 925 // clear Irq flags
dudmuck 1:1cd0afbed23c 926 radio.write_reg(REG_LR_IRQFLAGS, lora.RegIrqFlags.octet);
dudmuck 1:1cd0afbed23c 927 // should still be in receive mode
dudmuck 0:be215de91a68 928 }
dudmuck 1:1cd0afbed23c 929 break;
dudmuck 1:1cd0afbed23c 930 case SERVICE_TX_DONE:
dudmuck 1:1cd0afbed23c 931 if (app == APP_CHAT) {
dudmuck 1:1cd0afbed23c 932 lora.start_rx();
dudmuck 1:1cd0afbed23c 933 }
dudmuck 1:1cd0afbed23c 934 break;
dudmuck 1:1cd0afbed23c 935 case SERVICE_ERROR:
dudmuck 1:1cd0afbed23c 936 printf("error\r\n");
dudmuck 1:1cd0afbed23c 937 break;
dudmuck 1:1cd0afbed23c 938 } // ...switch (act)
dudmuck 1:1cd0afbed23c 939 } else {
dudmuck 1:1cd0afbed23c 940 /* FSK: */
dudmuck 1:1cd0afbed23c 941 act = fsk.service();
dudmuck 1:1cd0afbed23c 942
dudmuck 1:1cd0afbed23c 943 switch (act) {
dudmuck 1:1cd0afbed23c 944 case SERVICE_READ_FIFO:
dudmuck 2:c6b23a43a9d9 945 if (app == APP_CHAT) {
dudmuck 2:c6b23a43a9d9 946 int n = fsk.rx_buf_length;
dudmuck 2:c6b23a43a9d9 947 radio.rx_buf[n++] = '\r';
dudmuck 2:c6b23a43a9d9 948 radio.rx_buf[n++] = '\n';
dudmuck 2:c6b23a43a9d9 949 radio.rx_buf[n] = 0; // null terminate
dudmuck 2:c6b23a43a9d9 950 printf((char *)radio.rx_buf);
dudmuck 2:c6b23a43a9d9 951 } else {
dudmuck 2:c6b23a43a9d9 952 int i;
dudmuck 2:c6b23a43a9d9 953 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 2:c6b23a43a9d9 954 printf("%dHz ", (int)(FREQ_STEP_HZ * fsk.RegAfcValue));
dudmuck 2:c6b23a43a9d9 955 printf("%d: ", fsk.rx_buf_length);
dudmuck 2:c6b23a43a9d9 956 for (i = 0; i < fsk.rx_buf_length; i++)
dudmuck 2:c6b23a43a9d9 957 printf("%02x ", radio.rx_buf[i]);
dudmuck 2:c6b23a43a9d9 958 printf("\r\n");
dudmuck 2:c6b23a43a9d9 959 }
dudmuck 1:1cd0afbed23c 960 break;
dudmuck 2:c6b23a43a9d9 961 case SERVICE_TX_DONE:
dudmuck 2:c6b23a43a9d9 962 if (app == APP_CHAT) {
dudmuck 2:c6b23a43a9d9 963 fsk.start_rx();
dudmuck 2:c6b23a43a9d9 964 }
dudmuck 2:c6b23a43a9d9 965 break;
dudmuck 1:1cd0afbed23c 966 } // ...switch (act)
dudmuck 1:1cd0afbed23c 967 }
dudmuck 0:be215de91a68 968 }
dudmuck 0:be215de91a68 969
dudmuck 0:be215de91a68 970 int get_kbd_str(char* buf, int size)
dudmuck 0:be215de91a68 971 {
dudmuck 0:be215de91a68 972 char c;
dudmuck 0:be215de91a68 973 int i;
dudmuck 0:be215de91a68 974 static int prev_len;
dudmuck 0:be215de91a68 975
dudmuck 0:be215de91a68 976 for (i = 0;;) {
dudmuck 0:be215de91a68 977 if (pc.readable()) {
dudmuck 0:be215de91a68 978 c = pc.getc();
dudmuck 0:be215de91a68 979 if (c == 8 && i > 0) {
dudmuck 0:be215de91a68 980 pc.putc(8);
dudmuck 0:be215de91a68 981 pc.putc(' ');
dudmuck 0:be215de91a68 982 pc.putc(8);
dudmuck 0:be215de91a68 983 i--;
dudmuck 0:be215de91a68 984 } else if (c == '\r') {
dudmuck 0:be215de91a68 985 if (i == 0) {
dudmuck 0:be215de91a68 986 return prev_len; // repeat previous
dudmuck 0:be215de91a68 987 } else {
dudmuck 0:be215de91a68 988 buf[i] = 0; // null terminate
dudmuck 0:be215de91a68 989 prev_len = i;
dudmuck 0:be215de91a68 990 return i;
dudmuck 0:be215de91a68 991 }
dudmuck 0:be215de91a68 992 } else if (c == 3) {
dudmuck 0:be215de91a68 993 // ctrl-C abort
dudmuck 0:be215de91a68 994 return -1;
dudmuck 0:be215de91a68 995 } else if (i < size) {
dudmuck 0:be215de91a68 996 buf[i++] = c;
dudmuck 0:be215de91a68 997 pc.putc(c);
dudmuck 0:be215de91a68 998 }
dudmuck 0:be215de91a68 999 } else
dudmuck 0:be215de91a68 1000 service_radio();
dudmuck 0:be215de91a68 1001 } // ...for()
dudmuck 0:be215de91a68 1002 }
dudmuck 0:be215de91a68 1003
dudmuck 0:be215de91a68 1004 void
dudmuck 0:be215de91a68 1005 console_chat()
dudmuck 0:be215de91a68 1006 {
dudmuck 0:be215de91a68 1007 int i, len = get_kbd_str(pcbuf, sizeof(pcbuf));
dudmuck 0:be215de91a68 1008 if (len < 0) {
dudmuck 0:be215de91a68 1009 printf("chat abort\r\n");
dudmuck 0:be215de91a68 1010 app = APP_NONE;
dudmuck 0:be215de91a68 1011 return;
dudmuck 0:be215de91a68 1012 } else {
dudmuck 0:be215de91a68 1013 for (i = 0; i < len; i++)
dudmuck 0:be215de91a68 1014 radio.tx_buf[i] = pcbuf[i];
dudmuck 1:1cd0afbed23c 1015 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1016 lora.RegPayloadLength = len;
dudmuck 1:1cd0afbed23c 1017 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 1:1cd0afbed23c 1018 lora.start_tx(len);
dudmuck 2:c6b23a43a9d9 1019 } else {
dudmuck 2:c6b23a43a9d9 1020 fsk.start_tx(len);
dudmuck 2:c6b23a43a9d9 1021 }
dudmuck 0:be215de91a68 1022 printf("\r\n");
dudmuck 0:be215de91a68 1023 }
dudmuck 0:be215de91a68 1024 }
dudmuck 0:be215de91a68 1025
dudmuck 0:be215de91a68 1026 void
dudmuck 0:be215de91a68 1027 console()
dudmuck 0:be215de91a68 1028 {
dudmuck 0:be215de91a68 1029 int len, i;
dudmuck 2:c6b23a43a9d9 1030 uint32_t ui;
dudmuck 0:be215de91a68 1031 uint8_t a, d;
dudmuck 1:1cd0afbed23c 1032 static uint16_t fsk_tx_length;
dudmuck 0:be215de91a68 1033
dudmuck 0:be215de91a68 1034 len = get_kbd_str(pcbuf, sizeof(pcbuf));
dudmuck 0:be215de91a68 1035 if (len < 0) {
dudmuck 0:be215de91a68 1036 printf("abort\r\n");
dudmuck 0:be215de91a68 1037 return;
dudmuck 0:be215de91a68 1038 }
dudmuck 0:be215de91a68 1039
dudmuck 0:be215de91a68 1040 printf("\r\n");
dudmuck 0:be215de91a68 1041 if (len == 1) {
dudmuck 0:be215de91a68 1042 switch (pcbuf[0]) {
dudmuck 0:be215de91a68 1043 case 'i':
dudmuck 3:ab386fa756cc 1044 printf("init\r\n");
dudmuck 0:be215de91a68 1045 radio.init();
dudmuck 3:ab386fa756cc 1046 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1047 fsk.init(); // put FSK modem to some functioning default
dudmuck 3:ab386fa756cc 1048 } else {
dudmuck 3:ab386fa756cc 1049 // lora configuration is more simple
dudmuck 3:ab386fa756cc 1050 }
dudmuck 0:be215de91a68 1051 break;
dudmuck 0:be215de91a68 1052 case 'h':
dudmuck 0:be215de91a68 1053 printf("hw_reset()\r\n");
dudmuck 0:be215de91a68 1054 radio.hw_reset();
dudmuck 0:be215de91a68 1055 break;
dudmuck 0:be215de91a68 1056 case 'R':
dudmuck 0:be215de91a68 1057 // read all registers
dudmuck 0:be215de91a68 1058 for (a = 1; a < 0x71; a++) {
dudmuck 0:be215de91a68 1059 d = radio.read_reg(a);
dudmuck 0:be215de91a68 1060 //update_shadow_regs(selected_radio, a, d);
dudmuck 0:be215de91a68 1061 printf("%02x: %02x\r\n", a, d);
dudmuck 0:be215de91a68 1062 }
dudmuck 0:be215de91a68 1063 break;
dudmuck 0:be215de91a68 1064 case 'T':
dudmuck 1:1cd0afbed23c 1065 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1066 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 1:1cd0afbed23c 1067 //printf("a %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1068 lora.RegModemConfig2.sx1276bits.TxContinuousMode ^= 1; // same for sx1272 and sx1276
dudmuck 1:1cd0afbed23c 1069 //printf("b %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1070 radio.write_reg(REG_LR_MODEMCONFIG2, lora.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1071 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1072 //printf("c %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1073 lora_printTxContinuousMode();
dudmuck 1:1cd0afbed23c 1074 printf("\r\n");
dudmuck 1:1cd0afbed23c 1075 }
dudmuck 0:be215de91a68 1076 break;
dudmuck 0:be215de91a68 1077 case 'C':
dudmuck 2:c6b23a43a9d9 1078 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1079 lora.setRxPayloadCrcOn(!lora.getRxPayloadCrcOn());
dudmuck 2:c6b23a43a9d9 1080 lora_printRxPayloadCrcOn();
dudmuck 2:c6b23a43a9d9 1081 } else {
dudmuck 2:c6b23a43a9d9 1082 printf("CrcOn:");
dudmuck 2:c6b23a43a9d9 1083 fsk.RegPktConfig1.bits.CrcOn ^= 1;
dudmuck 2:c6b23a43a9d9 1084 radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
dudmuck 2:c6b23a43a9d9 1085 if (fsk.RegPktConfig1.bits.CrcOn)
dudmuck 2:c6b23a43a9d9 1086 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1087 else
dudmuck 2:c6b23a43a9d9 1088 printf("Off\r\n");
dudmuck 2:c6b23a43a9d9 1089 if (fsk.RegPktConfig2.bits.DataModePacket && radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER) {
dudmuck 2:c6b23a43a9d9 1090 fsk.config_dio0_for_pktmode_rx();
dudmuck 2:c6b23a43a9d9 1091 }
dudmuck 2:c6b23a43a9d9 1092 }
dudmuck 0:be215de91a68 1093 printf("\r\n");
dudmuck 0:be215de91a68 1094 break;
dudmuck 0:be215de91a68 1095 case 'B':
dudmuck 0:be215de91a68 1096 radio.RegPaConfig.bits.PaSelect ^= 1;
dudmuck 0:be215de91a68 1097 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:be215de91a68 1098 printPa();
dudmuck 0:be215de91a68 1099 printf("\r\n");
dudmuck 1:1cd0afbed23c 1100 break;
dudmuck 1:1cd0afbed23c 1101 case 'L':
dudmuck 1:1cd0afbed23c 1102 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1103 fsk.enable();
dudmuck 1:1cd0afbed23c 1104 else
dudmuck 1:1cd0afbed23c 1105 lora.enable();
dudmuck 1:1cd0afbed23c 1106
dudmuck 1:1cd0afbed23c 1107 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 1:1cd0afbed23c 1108 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1109 printf("LoRa\r\n");
dudmuck 1:1cd0afbed23c 1110 else
dudmuck 1:1cd0afbed23c 1111 printf("FSK\r\n");
dudmuck 2:c6b23a43a9d9 1112 break;
dudmuck 2:c6b23a43a9d9 1113 case 's':
dudmuck 2:c6b23a43a9d9 1114 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1115 fsk.RegFifoThreshold.bits.TxStartCondition ^= 1;
dudmuck 2:c6b23a43a9d9 1116 radio.write_reg(REG_FSK_FIFOTHRESH, fsk.RegFifoThreshold.octet);
dudmuck 2:c6b23a43a9d9 1117 printf("TxStartCondition:");
dudmuck 2:c6b23a43a9d9 1118 if (fsk.RegFifoThreshold.bits.TxStartCondition)
dudmuck 2:c6b23a43a9d9 1119 printf("!FifoEmpty\r\n");
dudmuck 2:c6b23a43a9d9 1120 else
dudmuck 2:c6b23a43a9d9 1121 printf("FifoLevel\r\n");
dudmuck 2:c6b23a43a9d9 1122 }
dudmuck 2:c6b23a43a9d9 1123 break;
dudmuck 2:c6b23a43a9d9 1124 case 'f':
dudmuck 2:c6b23a43a9d9 1125 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1126 printf("PacketFormat:");
dudmuck 2:c6b23a43a9d9 1127 fsk.RegPktConfig1.bits.PacketFormatVariable ^= 1;
dudmuck 2:c6b23a43a9d9 1128 radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
dudmuck 2:c6b23a43a9d9 1129 if (fsk.RegPktConfig1.bits.PacketFormatVariable)
dudmuck 2:c6b23a43a9d9 1130 printf("variable\r\n");
dudmuck 2:c6b23a43a9d9 1131 else
dudmuck 2:c6b23a43a9d9 1132 printf("fixed\r\n");
dudmuck 2:c6b23a43a9d9 1133 /*if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER)
dudmuck 2:c6b23a43a9d9 1134 reset_flow();*/
dudmuck 2:c6b23a43a9d9 1135 }
dudmuck 2:c6b23a43a9d9 1136 break;
dudmuck 2:c6b23a43a9d9 1137 case 'E':
dudmuck 2:c6b23a43a9d9 1138 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1139 RegIrqFlags2_t RegIrqFlags2;
dudmuck 2:c6b23a43a9d9 1140 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 1141 while (!RegIrqFlags2.bits.FifoEmpty) {
dudmuck 2:c6b23a43a9d9 1142 if (pc.readable())
dudmuck 2:c6b23a43a9d9 1143 break;
dudmuck 2:c6b23a43a9d9 1144 printf("%02x\r\n", radio.read_reg(REG_FIFO));
dudmuck 2:c6b23a43a9d9 1145 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 1146 }
dudmuck 2:c6b23a43a9d9 1147 }
dudmuck 2:c6b23a43a9d9 1148 break;
dudmuck 2:c6b23a43a9d9 1149 case 'A':
dudmuck 2:c6b23a43a9d9 1150 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1151 fsk.RegRxConfig.bits.AfcAutoOn ^= 1;
dudmuck 2:c6b23a43a9d9 1152 radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
dudmuck 2:c6b23a43a9d9 1153 printf("AfcAuto:");
dudmuck 2:c6b23a43a9d9 1154 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 2:c6b23a43a9d9 1155 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1156 else
dudmuck 2:c6b23a43a9d9 1157 printf("OFF\r\n");
dudmuck 2:c6b23a43a9d9 1158 break;
dudmuck 2:c6b23a43a9d9 1159 }
dudmuck 2:c6b23a43a9d9 1160 break;
dudmuck 0:be215de91a68 1161 case '?':
dudmuck 1:1cd0afbed23c 1162 printf("L toggle LongRangeMode/FSK\r\n");
dudmuck 0:be215de91a68 1163 printf("i radio_init\r\n");
dudmuck 0:be215de91a68 1164 printf("h hw_reset\r\n");
dudmuck 2:c6b23a43a9d9 1165 printf("tx[%%d] transmit\r\n");
dudmuck 1:1cd0afbed23c 1166 printf("rx receive\r\n");
dudmuck 0:be215de91a68 1167 printf("C toggle crcOn\r\n");
dudmuck 2:c6b23a43a9d9 1168 printf("op[%%d] get/set output power\r\n");
dudmuck 1:1cd0afbed23c 1169 printf("d[0-5] change DIO pin assignment\r\n");
dudmuck 3:ab386fa756cc 1170 printf("frf[%%f} get/set operating frequency (MHz)\r\n");
dudmuck 1:1cd0afbed23c 1171 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1172 printf("pl[%%d] LORA get/set RegPayloadLength\r\n");
dudmuck 1:1cd0afbed23c 1173 printf("cr[1234] LORA set coding rate \r\n");
dudmuck 2:c6b23a43a9d9 1174 printf("bw[%%d] LORA get/set bandwidth\r\n");
dudmuck 2:c6b23a43a9d9 1175 printf("sf[%%d] LORA get/set spreading factor\r\n");
dudmuck 1:1cd0afbed23c 1176 printf("T LORA toggle TxContinuousMode\r\n");
dudmuck 2:c6b23a43a9d9 1177 printf("hp[%%d] LORA get/set hop period\r\n");
dudmuck 1:1cd0afbed23c 1178 printf("hm LORA toggle explicit/explicit header mode\r\n");
dudmuck 1:1cd0afbed23c 1179 } else {
dudmuck 2:c6b23a43a9d9 1180 printf("bw[a][%%d] FSK get-set rxbw (bwa=afcbw)\r\n");
dudmuck 3:ab386fa756cc 1181 printf("br[%%d] FSK get-set bitrate\r\n");
dudmuck 3:ab386fa756cc 1182 printf("fdev[%%d] FSK get-set TX frequency deviation (hz)\r\n");
dudmuck 2:c6b23a43a9d9 1183 printf("rt FSK change RxTrigger\r\n");
dudmuck 2:c6b23a43a9d9 1184 printf("pd FSK enable/disable preamble detector\r\n");
dudmuck 2:c6b23a43a9d9 1185 printf("pt FSK get-set PreambleDetectorTol\r\n");
dudmuck 2:c6b23a43a9d9 1186 printf("ss[%%d] FSK get-set SyncSize\r\n");
dudmuck 2:c6b23a43a9d9 1187 printf("S[%%x] FSK get-set sync word\r\n");
dudmuck 2:c6b23a43a9d9 1188 printf("s FSK toggle TxStartCondition\r\n");
dudmuck 2:c6b23a43a9d9 1189 printf("f FSK toggle PacketFormat fixed-variable\r\n");
dudmuck 2:c6b23a43a9d9 1190 printf("E FSK empty out the fifo\r\n");
dudmuck 2:c6b23a43a9d9 1191 printf("ac FSK AfcClear\r\n");
dudmuck 2:c6b23a43a9d9 1192 printf("A FSK toggle AfcAutoOn\r\n");
dudmuck 2:c6b23a43a9d9 1193 printf("mp FSK toggle MapPreambleDetect\r\n");
dudmuck 2:c6b23a43a9d9 1194 printf("ar FSK change AutoRestartRxMode\r\n");
dudmuck 2:c6b23a43a9d9 1195 printf("alc FSK toggle AfcAutoClearOn\r\n");
dudmuck 3:ab386fa756cc 1196 printf("pre[%%d} FSK get-set TX preamble length\r\n");
dudmuck 1:1cd0afbed23c 1197 }
dudmuck 0:be215de91a68 1198 break;
dudmuck 0:be215de91a68 1199 case '.':
dudmuck 1:1cd0afbed23c 1200 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1201 lora_print_status();
dudmuck 1:1cd0afbed23c 1202 else
dudmuck 1:1cd0afbed23c 1203 fsk_print_status();
dudmuck 0:be215de91a68 1204 common_print_status();
dudmuck 0:be215de91a68 1205 break;
dudmuck 0:be215de91a68 1206 } // ...switch (pcbuf[0])
dudmuck 0:be215de91a68 1207 } else {
dudmuck 0:be215de91a68 1208 if (pcbuf[0] == 't' && pcbuf[1] == 'x') { // TX
dudmuck 1:1cd0afbed23c 1209 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1210 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1211 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1212 lora.RegPayloadLength = i;
dudmuck 1:1cd0afbed23c 1213 }
dudmuck 1:1cd0afbed23c 1214 tx_cnt++;
dudmuck 1:1cd0afbed23c 1215 for (i = 0; i < lora.RegPayloadLength; i++)
dudmuck 1:1cd0afbed23c 1216 radio.tx_buf[i] = tx_cnt;
dudmuck 1:1cd0afbed23c 1217 lora.start_tx(lora.RegPayloadLength);
dudmuck 2:c6b23a43a9d9 1218 } else { // FSK:
dudmuck 1:1cd0afbed23c 1219 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1220 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1221 fsk_tx_length = i;
dudmuck 1:1cd0afbed23c 1222 }
dudmuck 2:c6b23a43a9d9 1223 if (radio.RegOpMode.bits.Mode != RF_OPMODE_TRANSMITTER) { // if not already busy transmitting
dudmuck 2:c6b23a43a9d9 1224 tx_cnt++;
dudmuck 2:c6b23a43a9d9 1225 for (i = 0; i < fsk_tx_length; i++) {
dudmuck 2:c6b23a43a9d9 1226 radio.tx_buf[i] = tx_cnt;
dudmuck 2:c6b23a43a9d9 1227 }
dudmuck 2:c6b23a43a9d9 1228 fsk.start_tx(fsk_tx_length);
dudmuck 2:c6b23a43a9d9 1229 }
dudmuck 0:be215de91a68 1230 }
dudmuck 1:1cd0afbed23c 1231 } else if (pcbuf[0] == 'h' && pcbuf[1] == 'p' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1232 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1233 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1234 lora.RegHopPeriod = i;
dudmuck 1:1cd0afbed23c 1235 radio.write_reg(REG_LR_HOPPERIOD, lora.RegHopPeriod);
dudmuck 0:be215de91a68 1236 if (radio.RegDioMapping1.bits.Dio1Mapping != 1) {
dudmuck 0:be215de91a68 1237 radio.RegDioMapping1.bits.Dio1Mapping = 1;
dudmuck 0:be215de91a68 1238 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1239 }
dudmuck 0:be215de91a68 1240 }
dudmuck 1:1cd0afbed23c 1241 lora.RegHopPeriod = radio.read_reg(REG_LR_HOPPERIOD);
dudmuck 1:1cd0afbed23c 1242 printf("HopPeriod:0x%02x\r\n", lora.RegHopPeriod);
dudmuck 2:c6b23a43a9d9 1243 } else if (pcbuf[0] == 'r' && pcbuf[1] == 't' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1244 printf("RxTrigger:");
dudmuck 2:c6b23a43a9d9 1245 switch (fsk.RegRxConfig.bits.RxTrigger) {
dudmuck 2:c6b23a43a9d9 1246 case 0: fsk.RegRxConfig.bits.RxTrigger = 1;
dudmuck 2:c6b23a43a9d9 1247 printf("rssi\r\n");
dudmuck 2:c6b23a43a9d9 1248 break;
dudmuck 2:c6b23a43a9d9 1249 case 1: fsk.RegRxConfig.bits.RxTrigger = 6;
dudmuck 2:c6b23a43a9d9 1250 printf("preamble\r\n");
dudmuck 2:c6b23a43a9d9 1251 break;
dudmuck 2:c6b23a43a9d9 1252 case 6: fsk.RegRxConfig.bits.RxTrigger = 7;
dudmuck 2:c6b23a43a9d9 1253 printf("both\r\n");
dudmuck 2:c6b23a43a9d9 1254 break;
dudmuck 2:c6b23a43a9d9 1255 case 7: fsk.RegRxConfig.bits.RxTrigger = 0;
dudmuck 2:c6b23a43a9d9 1256 printf("none\r\n");
dudmuck 2:c6b23a43a9d9 1257 break;
dudmuck 2:c6b23a43a9d9 1258 default: fsk.RegRxConfig.bits.RxTrigger = 0;
dudmuck 2:c6b23a43a9d9 1259 printf("none\r\n");
dudmuck 2:c6b23a43a9d9 1260 break;
dudmuck 2:c6b23a43a9d9 1261 }
dudmuck 2:c6b23a43a9d9 1262 radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
dudmuck 0:be215de91a68 1263 } else if (pcbuf[0] == 'r' && pcbuf[1] == 'x') { // RX
dudmuck 2:c6b23a43a9d9 1264 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 2:c6b23a43a9d9 1265 lora.start_rx();
dudmuck 2:c6b23a43a9d9 1266 else
dudmuck 2:c6b23a43a9d9 1267 fsk.start_rx();
dudmuck 0:be215de91a68 1268 } else if (pcbuf[0] == 'r' && pcbuf[1] == ' ') { // read single register
dudmuck 0:be215de91a68 1269 sscanf(pcbuf+2, "%x", &i);
dudmuck 0:be215de91a68 1270 printf("%02x: %02x\r\n", i, radio.read_reg(i));
dudmuck 0:be215de91a68 1271 } else if (pcbuf[0] == 'w' && pcbuf[1] == ' ') { // write single register
dudmuck 0:be215de91a68 1272 sscanf(pcbuf+2, "%x %x", &i, &len);
dudmuck 0:be215de91a68 1273 radio.write_reg(i, len);
dudmuck 0:be215de91a68 1274 printf("%02x: %02x\r\n", i, radio.read_reg(i));
dudmuck 2:c6b23a43a9d9 1275 } else if (pcbuf[0] == 'm' && pcbuf[1] == 'p' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1276 radio.RegDioMapping2.bits.MapPreambleDetect ^= 1;
dudmuck 2:c6b23a43a9d9 1277 radio.write_reg(REG_DIOMAPPING2, radio.RegDioMapping2.octet);
dudmuck 2:c6b23a43a9d9 1278 printf("MapPreambleDetect:");
dudmuck 2:c6b23a43a9d9 1279 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 2:c6b23a43a9d9 1280 printf("preamble\r\n");
dudmuck 2:c6b23a43a9d9 1281 else
dudmuck 2:c6b23a43a9d9 1282 printf("rssi\r\n");
dudmuck 0:be215de91a68 1283 } else if (pcbuf[0] == 'o' && pcbuf[1] == 'p') {
dudmuck 0:be215de91a68 1284 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1285 sscanf(pcbuf+2, "%d", &i);
dudmuck 0:be215de91a68 1286 radio.RegPaConfig.bits.OutputPower = i;
dudmuck 0:be215de91a68 1287 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:be215de91a68 1288 }
dudmuck 0:be215de91a68 1289 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:be215de91a68 1290 printf("OutputPower:%d\r\n", radio.RegPaConfig.bits.OutputPower);
dudmuck 1:1cd0afbed23c 1291 } else if (pcbuf[0] == 'c' && pcbuf[1] == 'r' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1292 if (pcbuf[2] >= '0' && pcbuf[2] <= '9')
dudmuck 1:1cd0afbed23c 1293 lora.setCodingRate(pcbuf[2] - '0');
dudmuck 1:1cd0afbed23c 1294 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1295 lora_printCodingRate(false); // false: transmitted
dudmuck 0:be215de91a68 1296 printf("\r\n");
dudmuck 1:1cd0afbed23c 1297 } else if (pcbuf[0] == 'h' && pcbuf[1] == 'm' && radio.RegOpMode.bits.LongRangeMode) { // toggle implicit/explicit
dudmuck 1:1cd0afbed23c 1298 lora.setHeaderMode(!lora.getHeaderMode());
dudmuck 1:1cd0afbed23c 1299 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1300 lora_printHeaderMode();
dudmuck 0:be215de91a68 1301 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1302 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'l' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1303 fsk.RegAfcFei.bits.AfcAutoClearOn ^= 1;
dudmuck 2:c6b23a43a9d9 1304 printf("AfcAutoClearOn: ");
dudmuck 2:c6b23a43a9d9 1305 radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
dudmuck 2:c6b23a43a9d9 1306 if (fsk.RegAfcFei.bits.AfcAutoClearOn)
dudmuck 2:c6b23a43a9d9 1307 printf("ON\r\n");
dudmuck 2:c6b23a43a9d9 1308 else
dudmuck 2:c6b23a43a9d9 1309 printf("off\r\n");
dudmuck 2:c6b23a43a9d9 1310 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'r' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1311 fsk.RegSyncConfig.bits.AutoRestartRxMode++;
dudmuck 2:c6b23a43a9d9 1312 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1313 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1314 printf("AutoRestartRxMode:");
dudmuck 2:c6b23a43a9d9 1315 switch (fsk.RegSyncConfig.bits.AutoRestartRxMode) {
dudmuck 2:c6b23a43a9d9 1316 case 0: printf("off "); break;
dudmuck 2:c6b23a43a9d9 1317 case 1: printf("no-pll-wait "); break;
dudmuck 2:c6b23a43a9d9 1318 case 2: printf("pll-wait "); break;
dudmuck 2:c6b23a43a9d9 1319 case 3: printf("3 "); break;
dudmuck 2:c6b23a43a9d9 1320 }
dudmuck 2:c6b23a43a9d9 1321 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1322 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'c' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1323 printf("clear afc: ");
dudmuck 2:c6b23a43a9d9 1324 fsk.RegAfcFei.bits.AfcClear = 1;
dudmuck 2:c6b23a43a9d9 1325 radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
dudmuck 2:c6b23a43a9d9 1326 fsk.RegAfcFei.bits.AfcClear = 0;
dudmuck 3:ab386fa756cc 1327 printf("%dHz\r\n", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_AFCMSB)));
dudmuck 3:ab386fa756cc 1328 } else if (pcbuf[0] == 'b' && pcbuf[1] == 'r' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1329 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 3:ab386fa756cc 1330 sscanf(&pcbuf[2], "%d", &i);
dudmuck 3:ab386fa756cc 1331 fsk.set_bitrate(i);
dudmuck 3:ab386fa756cc 1332 }
dudmuck 3:ab386fa756cc 1333 printf("%dbps\r\n", fsk.get_bitrate());
dudmuck 0:be215de91a68 1334 } else if (pcbuf[0] == 'b' && pcbuf[1] == 'w') {
dudmuck 1:1cd0afbed23c 1335 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1336 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 1:1cd0afbed23c 1337 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1338 sscanf(&pcbuf[2], "%d", &i);
dudmuck 1:1cd0afbed23c 1339 lora.setBw(i);
dudmuck 1:1cd0afbed23c 1340 } else
dudmuck 1:1cd0afbed23c 1341 lora_printAllBw();
dudmuck 1:1cd0afbed23c 1342 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1343 printf("current ");
dudmuck 1:1cd0afbed23c 1344 lora_printBw();
dudmuck 1:1cd0afbed23c 1345 printf("\r\n");
dudmuck 1:1cd0afbed23c 1346 } else { // FSK:
dudmuck 1:1cd0afbed23c 1347 if (pcbuf[2] == 'a') {
dudmuck 1:1cd0afbed23c 1348 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 1:1cd0afbed23c 1349 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1350 sscanf(&pcbuf[3], "%d", &i);
dudmuck 1:1cd0afbed23c 1351 fsk.set_rx_dcc_bw_hz(i, 1);
dudmuck 1:1cd0afbed23c 1352 }
dudmuck 1:1cd0afbed23c 1353 printf("afcbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_AFCBW));
dudmuck 1:1cd0afbed23c 1354 } else {
dudmuck 1:1cd0afbed23c 1355 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 1:1cd0afbed23c 1356 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1357 sscanf(&pcbuf[2], "%d", &i);
dudmuck 1:1cd0afbed23c 1358 fsk.set_rx_dcc_bw_hz(i, 0);
dudmuck 1:1cd0afbed23c 1359 }
dudmuck 1:1cd0afbed23c 1360 printf("rxbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_RXBW));
dudmuck 1:1cd0afbed23c 1361 }
dudmuck 1:1cd0afbed23c 1362 }
dudmuck 0:be215de91a68 1363 } else if (pcbuf[0] == 'v' && pcbuf[1] == 'h') {
dudmuck 1:1cd0afbed23c 1364 lora.poll_vh ^= 1;
dudmuck 1:1cd0afbed23c 1365 printf("poll_vh:%d\r\n", lora.poll_vh);
dudmuck 2:c6b23a43a9d9 1366 } else if (pcbuf[0] == 'S' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1367 if (pcbuf[1] == '0') {
dudmuck 2:c6b23a43a9d9 1368 sscanf(pcbuf+1, "%x", &ui);
dudmuck 2:c6b23a43a9d9 1369 if (ui < 0x100) {
dudmuck 2:c6b23a43a9d9 1370 fsk.RegSyncConfig.bits.SyncSize = 0;
dudmuck 2:c6b23a43a9d9 1371 radio.write_reg(REG_FSK_SYNCVALUE1, ui);
dudmuck 2:c6b23a43a9d9 1372 } else if (ui < 0x10000) {
dudmuck 2:c6b23a43a9d9 1373 fsk.RegSyncConfig.bits.SyncSize = 1;
dudmuck 3:ab386fa756cc 1374 radio.write_reg(REG_FSK_SYNCVALUE2, ui & 0xff);
dudmuck 3:ab386fa756cc 1375 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 8);
dudmuck 2:c6b23a43a9d9 1376 } else if (ui < 0x1000000) {
dudmuck 2:c6b23a43a9d9 1377 fsk.RegSyncConfig.bits.SyncSize = 2;
dudmuck 3:ab386fa756cc 1378 radio.write_reg(REG_FSK_SYNCVALUE3, ui & 0xff);
dudmuck 2:c6b23a43a9d9 1379 radio.write_reg(REG_FSK_SYNCVALUE2, (ui >> 8) & 0xff);
dudmuck 3:ab386fa756cc 1380 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 16);
dudmuck 2:c6b23a43a9d9 1381 } else {
dudmuck 2:c6b23a43a9d9 1382 fsk.RegSyncConfig.bits.SyncSize = 3;
dudmuck 3:ab386fa756cc 1383 radio.write_reg(REG_FSK_SYNCVALUE4, ui & 0xff);
dudmuck 3:ab386fa756cc 1384 radio.write_reg(REG_FSK_SYNCVALUE3, (ui >> 8) & 0xff);
dudmuck 3:ab386fa756cc 1385 radio.write_reg(REG_FSK_SYNCVALUE2, (ui >> 16) & 0xff);
dudmuck 3:ab386fa756cc 1386 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 24);
dudmuck 2:c6b23a43a9d9 1387 }
dudmuck 2:c6b23a43a9d9 1388 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1389 }
dudmuck 2:c6b23a43a9d9 1390 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1391 printf("%d: ", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 2:c6b23a43a9d9 1392 for (i = 0; i <= fsk.RegSyncConfig.bits.SyncSize; i++)
dudmuck 2:c6b23a43a9d9 1393 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE1+i));
dudmuck 2:c6b23a43a9d9 1394 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1395 } else if (pcbuf[0] == 's' && pcbuf[1] == 's' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1396 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1397 sscanf(pcbuf+2, "%d", &i);
dudmuck 2:c6b23a43a9d9 1398 fsk.RegSyncConfig.bits.SyncSize = i;
dudmuck 2:c6b23a43a9d9 1399 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1400 }
dudmuck 2:c6b23a43a9d9 1401 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1402 printf("SyncSize:%d\r\n", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 1:1cd0afbed23c 1403 } else if (pcbuf[0] == 's' && pcbuf[1] == 'f' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1404 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1405 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1406 lora.setSf(i);
dudmuck 1:1cd0afbed23c 1407 if (i == 6 && !lora.getHeaderMode()) {
dudmuck 0:be215de91a68 1408 printf("SF6: to implicit header mode\r\n");
dudmuck 1:1cd0afbed23c 1409 lora.setHeaderMode(true);
dudmuck 0:be215de91a68 1410 }
dudmuck 0:be215de91a68 1411 }
dudmuck 1:1cd0afbed23c 1412 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 1:1cd0afbed23c 1413 lora_printSf();
dudmuck 0:be215de91a68 1414 printf("\r\n");
dudmuck 3:ab386fa756cc 1415 } else if (pcbuf[0] == 'f' && pcbuf[1] == 'd' && pcbuf[2] == 'e' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1416 if (pcbuf[4] >= '0' && pcbuf[4] <= '9') {
dudmuck 3:ab386fa756cc 1417 sscanf(pcbuf+4, "%d", &i);
dudmuck 3:ab386fa756cc 1418 fsk.set_tx_fdev_hz(i);
dudmuck 3:ab386fa756cc 1419 }
dudmuck 3:ab386fa756cc 1420 printf("fdev:%dHz\r\n", fsk.get_tx_fdev_hz());
dudmuck 0:be215de91a68 1421 } else if (pcbuf[0] == 'f' && pcbuf[1] == 'r' && pcbuf[2] == 'f') {
dudmuck 0:be215de91a68 1422 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 0:be215de91a68 1423 float MHz;
dudmuck 0:be215de91a68 1424 sscanf(pcbuf+3, "%f", &MHz);
dudmuck 0:be215de91a68 1425 //printf("MHz:%f\r\n", MHz);
dudmuck 0:be215de91a68 1426 radio.set_frf_MHz(MHz);
dudmuck 3:ab386fa756cc 1427 }
dudmuck 3:ab386fa756cc 1428 printf("%fMHz\r\n", radio.get_frf_MHz());
dudmuck 3:ab386fa756cc 1429 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'r' && pcbuf[2] == 'e' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1430 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 3:ab386fa756cc 1431 sscanf(pcbuf+3, "%d", &i);
dudmuck 3:ab386fa756cc 1432 radio.write_u16(REG_FSK_PREAMBLEMSB, i);
dudmuck 3:ab386fa756cc 1433 }
dudmuck 3:ab386fa756cc 1434 printf("FSK TX PreambleSize:%d ", radio.read_u16(REG_FSK_PREAMBLEMSB));
dudmuck 2:c6b23a43a9d9 1435 } else if (pcbuf[0] == 'p' && pcbuf[1] == 't' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1436 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1437 sscanf(pcbuf+2, "%d", &i);
dudmuck 2:c6b23a43a9d9 1438 fsk.RegPreambleDetect.bits.PreambleDetectorTol = i;
dudmuck 2:c6b23a43a9d9 1439 radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
dudmuck 2:c6b23a43a9d9 1440 }
dudmuck 2:c6b23a43a9d9 1441 fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
dudmuck 2:c6b23a43a9d9 1442 printf("PreambleDetectorTol:%d\r\n", fsk.RegPreambleDetect.bits.PreambleDetectorTol);
dudmuck 2:c6b23a43a9d9 1443 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'd' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1444 fsk.RegPreambleDetect.bits.PreambleDetectorOn ^= 1;
dudmuck 2:c6b23a43a9d9 1445 radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
dudmuck 2:c6b23a43a9d9 1446 printf("PreambleDetector:");
dudmuck 2:c6b23a43a9d9 1447 if (fsk.RegPreambleDetect.bits.PreambleDetectorOn)
dudmuck 2:c6b23a43a9d9 1448 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1449 else
dudmuck 2:c6b23a43a9d9 1450 printf("OFF\r\n");
dudmuck 1:1cd0afbed23c 1451 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'l' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1452 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1453 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1454 lora.RegPayloadLength = i;
dudmuck 1:1cd0afbed23c 1455 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 0:be215de91a68 1456 }
dudmuck 1:1cd0afbed23c 1457 lora.RegPayloadLength = radio.read_reg(REG_LR_PAYLOADLENGTH);
dudmuck 1:1cd0afbed23c 1458 printf("PayloadLength:%d\r\n", lora.RegPayloadLength);
dudmuck 0:be215de91a68 1459 } else if (pcbuf[0] == 'd' && pcbuf[1] >= '0' && pcbuf[1] <= '5') {
dudmuck 0:be215de91a68 1460 switch (pcbuf[1]) {
dudmuck 0:be215de91a68 1461 case '0':
dudmuck 0:be215de91a68 1462 radio.RegDioMapping1.bits.Dio0Mapping++;
dudmuck 0:be215de91a68 1463 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1464 break;
dudmuck 0:be215de91a68 1465 case '1':
dudmuck 0:be215de91a68 1466 radio.RegDioMapping1.bits.Dio1Mapping++;
dudmuck 0:be215de91a68 1467 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1468 break;
dudmuck 0:be215de91a68 1469 case '2':
dudmuck 0:be215de91a68 1470 radio.RegDioMapping1.bits.Dio2Mapping++;
dudmuck 0:be215de91a68 1471 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1472 break;
dudmuck 0:be215de91a68 1473 case '3':
dudmuck 0:be215de91a68 1474 radio.RegDioMapping1.bits.Dio3Mapping++;
dudmuck 0:be215de91a68 1475 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1476 break;
dudmuck 0:be215de91a68 1477 case '4':
dudmuck 0:be215de91a68 1478 radio.RegDioMapping2.bits.Dio4Mapping++;
dudmuck 0:be215de91a68 1479 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping2.octet);
dudmuck 0:be215de91a68 1480 break;
dudmuck 0:be215de91a68 1481 case '5':
dudmuck 0:be215de91a68 1482 radio.RegDioMapping2.bits.Dio5Mapping++;
dudmuck 0:be215de91a68 1483 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping2.octet);
dudmuck 0:be215de91a68 1484 break;
dudmuck 0:be215de91a68 1485 } // ...switch (pcbuf[1])
dudmuck 1:1cd0afbed23c 1486 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1487 lora_print_dio();
dudmuck 1:1cd0afbed23c 1488 else
dudmuck 1:1cd0afbed23c 1489 fsk_print_dio();
dudmuck 0:be215de91a68 1490 } else if (pcbuf[0] == 's' && pcbuf[1] == 't' && pcbuf[2] == 'b') {
dudmuck 0:be215de91a68 1491 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 0:be215de91a68 1492 } else if (pcbuf[0] == 's' && pcbuf[1] == 'l' && pcbuf[2] == 'e') {
dudmuck 0:be215de91a68 1493 radio.set_opmode(RF_OPMODE_SLEEP);
dudmuck 0:be215de91a68 1494 } else if (pcbuf[0] == 'c' && pcbuf[1] == 'h' && pcbuf[2] == 'a') {
dudmuck 0:be215de91a68 1495 app = APP_CHAT;
dudmuck 1:1cd0afbed23c 1496 lora.start_rx();
dudmuck 0:be215de91a68 1497 printf("chat start\r\n");
dudmuck 0:be215de91a68 1498 }
dudmuck 0:be215de91a68 1499 }
dudmuck 0:be215de91a68 1500 printf("> ");
dudmuck 0:be215de91a68 1501 fflush(stdout);
dudmuck 0:be215de91a68 1502
dudmuck 0:be215de91a68 1503 }
dudmuck 0:be215de91a68 1504
dudmuck 0:be215de91a68 1505 int main()
dudmuck 0:be215de91a68 1506 {
dudmuck 0:be215de91a68 1507
dudmuck 0:be215de91a68 1508 pc.baud(57600);
dudmuck 0:be215de91a68 1509
dudmuck 0:be215de91a68 1510 radio.frfs = frfs;
dudmuck 0:be215de91a68 1511
dudmuck 0:be215de91a68 1512 while(1) {
dudmuck 0:be215de91a68 1513 switch (app) {
dudmuck 0:be215de91a68 1514 case APP_NONE:
dudmuck 0:be215de91a68 1515 console();
dudmuck 0:be215de91a68 1516 break;
dudmuck 0:be215de91a68 1517 case APP_CHAT:
dudmuck 0:be215de91a68 1518 console_chat();
dudmuck 0:be215de91a68 1519 break;
dudmuck 0:be215de91a68 1520 } // ...switch (app)
dudmuck 0:be215de91a68 1521 } // ...while(1)
dudmuck 0:be215de91a68 1522 }
dudmuck 0:be215de91a68 1523