UART console application for testing SX1272/SX1276

Dependencies:   SX127x

/media/uploads/dudmuck/lora.png

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

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

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

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

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

Using with SX1276MB1xAS Shield

This component plugs into any board with arduino uno headers.

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


Using with your own production board

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

Transmitter Test Guidelines

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

commands used for transmitter testing:

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

LoRa transmitter testing

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

Receiver Test Guidelines

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

commands used for receiver testing:

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

Full command list

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

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

command list: common commands (both LoRa and FSK)

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

command list: LoRa modem commands

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

command list: FSK modem commands

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

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 4:7a9007dfc0e5 393 printf("PreambleLength:%d ", lora.RegPreamble);
dudmuck 0:be215de91a68 394
dudmuck 0:be215de91a68 395 if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER || radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER_SINGLE) {
dudmuck 0:be215de91a68 396 d = radio.read_reg(REG_LR_RSSIVALUE);
dudmuck 0:be215de91a68 397 printf("rssi:%ddBm ", d-120);
dudmuck 0:be215de91a68 398 }
dudmuck 0:be215de91a68 399
dudmuck 1:1cd0afbed23c 400 lora_printTxContinuousMode();
dudmuck 0:be215de91a68 401
dudmuck 0:be215de91a68 402 printf("\r\n");
dudmuck 1:1cd0afbed23c 403 lora_printAgcAutoOn();
dudmuck 0:be215de91a68 404 if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 405 printf(" LowDataRateOptimize:%d\r\n", lora.RegModemConfig.sx1272bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 406 }
dudmuck 0:be215de91a68 407
dudmuck 0:be215de91a68 408 printf("\r\nHeaderCount:%d PacketCount:%d, ",
dudmuck 0:be215de91a68 409 radio.read_u16(REG_LR_RXHEADERCNTVALUE_MSB), radio.read_u16(REG_LR_RXPACKETCNTVALUE_MSB));
dudmuck 0:be215de91a68 410
dudmuck 0:be215de91a68 411 printf("Lora detection threshold:%02x\r\n", radio.read_reg(REG_LR_DETECTION_THRESHOLD));
dudmuck 1:1cd0afbed23c 412 lora.RegTest31.octet = radio.read_reg(REG_LR_TEST31);
dudmuck 1:1cd0afbed23c 413 printf("detect_trig_same_peaks_nb:%d\r\n", lora.RegTest31.bits.detect_trig_same_peaks_nb);
dudmuck 0:be215de91a68 414
dudmuck 0:be215de91a68 415 if (radio.type == SX1272) {
dudmuck 1:1cd0afbed23c 416 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 417 printf("LowDataRateOptimize:%d\r\n", lora.RegModemConfig.sx1272bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 418 } else if (radio.type == SX1276) {
dudmuck 1:1cd0afbed23c 419 lora.RegModemConfig3.octet = radio.read_reg(REG_LR_MODEMCONFIG3);
dudmuck 1:1cd0afbed23c 420 printf("LowDataRateOptimize:%d\r\n", lora.RegModemConfig3.sx1276bits.LowDataRateOptimize);
dudmuck 0:be215de91a68 421 }
dudmuck 0:be215de91a68 422
dudmuck 0:be215de91a68 423 printf("\r\n");
dudmuck 0:be215de91a68 424 //printf("A %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 0:be215de91a68 425 }
dudmuck 0:be215de91a68 426
dudmuck 1:1cd0afbed23c 427 uint16_t
dudmuck 1:1cd0afbed23c 428 fsk_get_PayloadLength(void)
dudmuck 1:1cd0afbed23c 429 {
dudmuck 1:1cd0afbed23c 430 fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
dudmuck 1:1cd0afbed23c 431
dudmuck 1:1cd0afbed23c 432 return fsk.RegPktConfig2.bits.PayloadLength;
dudmuck 1:1cd0afbed23c 433 }
dudmuck 1:1cd0afbed23c 434
dudmuck 1:1cd0afbed23c 435 void fsk_printAddressFiltering()
dudmuck 1:1cd0afbed23c 436 {
dudmuck 1:1cd0afbed23c 437 uint8_t FSKRegNodeAdrs, FSKRegBroadcastAdrs;
dudmuck 1:1cd0afbed23c 438
dudmuck 1:1cd0afbed23c 439 printf(" AddressFiltering:");
dudmuck 1:1cd0afbed23c 440 switch (fsk.RegPktConfig1.bits.AddressFiltering) {
dudmuck 1:1cd0afbed23c 441 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 442 case 1: // NodeAddress
dudmuck 1:1cd0afbed23c 443 FSKRegNodeAdrs = radio.read_reg(REG_FSK_NODEADRS);
dudmuck 1:1cd0afbed23c 444 printf("NodeAdrs:%02x\n", FSKRegNodeAdrs);
dudmuck 1:1cd0afbed23c 445 break;
dudmuck 1:1cd0afbed23c 446 case 2: // NodeAddress & BroadcastAddress
dudmuck 1:1cd0afbed23c 447 FSKRegNodeAdrs = radio.read_reg(REG_FSK_NODEADRS);
dudmuck 1:1cd0afbed23c 448 printf("NodeAdrs:%02x ", FSKRegNodeAdrs);
dudmuck 1:1cd0afbed23c 449 FSKRegBroadcastAdrs = radio.read_reg(REG_FSK_BROADCASTADRS);
dudmuck 1:1cd0afbed23c 450 printf("BroadcastAdrs:%02x\n", FSKRegBroadcastAdrs );
dudmuck 1:1cd0afbed23c 451 break;
dudmuck 1:1cd0afbed23c 452 default:
dudmuck 1:1cd0afbed23c 453 printf("%d", fsk.RegPktConfig1.bits.AddressFiltering);
dudmuck 1:1cd0afbed23c 454 break;
dudmuck 1:1cd0afbed23c 455 }
dudmuck 1:1cd0afbed23c 456 }
dudmuck 1:1cd0afbed23c 457
dudmuck 1:1cd0afbed23c 458 void fsk_print_IrqFlags2()
dudmuck 1:1cd0afbed23c 459 {
dudmuck 2:c6b23a43a9d9 460 RegIrqFlags2_t RegIrqFlags2;
dudmuck 1:1cd0afbed23c 461
dudmuck 1:1cd0afbed23c 462 printf("IrqFlags2: ");
dudmuck 2:c6b23a43a9d9 463 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 464 if (RegIrqFlags2.bits.FifoFull)
dudmuck 1:1cd0afbed23c 465 printf("FifoFull ");
dudmuck 2:c6b23a43a9d9 466 if (RegIrqFlags2.bits.FifoEmpty)
dudmuck 1:1cd0afbed23c 467 printf("FifoEmpty ");
dudmuck 2:c6b23a43a9d9 468 if (RegIrqFlags2.bits.FifoLevel)
dudmuck 1:1cd0afbed23c 469 printf("FifoLevel ");
dudmuck 2:c6b23a43a9d9 470 if (RegIrqFlags2.bits.FifoOverrun)
dudmuck 1:1cd0afbed23c 471 printf("FifoOverrun ");
dudmuck 2:c6b23a43a9d9 472 if (RegIrqFlags2.bits.PacketSent)
dudmuck 1:1cd0afbed23c 473 printf("PacketSent ");
dudmuck 2:c6b23a43a9d9 474 if (RegIrqFlags2.bits.PayloadReady)
dudmuck 1:1cd0afbed23c 475 printf("PayloadReady ");
dudmuck 2:c6b23a43a9d9 476 if (RegIrqFlags2.bits.CrcOk)
dudmuck 1:1cd0afbed23c 477 printf("CrcOk ");
dudmuck 2:c6b23a43a9d9 478 if (RegIrqFlags2.bits.LowBat)
dudmuck 1:1cd0afbed23c 479 printf("LowBat ");
dudmuck 2:c6b23a43a9d9 480 printf("\r\n");
dudmuck 1:1cd0afbed23c 481 }
dudmuck 1:1cd0afbed23c 482
dudmuck 1:1cd0afbed23c 483 void
dudmuck 1:1cd0afbed23c 484 fsk_print_status()
dudmuck 1:1cd0afbed23c 485 {
dudmuck 1:1cd0afbed23c 486 //uint16_t s;
dudmuck 2:c6b23a43a9d9 487 RegIrqFlags1_t RegIrqFlags1;
dudmuck 1:1cd0afbed23c 488
dudmuck 1:1cd0afbed23c 489 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 490 printf("LoRa\r\n");
dudmuck 1:1cd0afbed23c 491 return;
dudmuck 1:1cd0afbed23c 492 }
dudmuck 1:1cd0afbed23c 493
dudmuck 1:1cd0afbed23c 494 if (radio.RegOpMode.bits.ModulationType == 0) {
dudmuck 1:1cd0afbed23c 495 printf("FSK ");
dudmuck 1:1cd0afbed23c 496 switch (radio.RegOpMode.bits.ModulationShaping) {
dudmuck 1:1cd0afbed23c 497 case 1: printf("BT1.0 "); break;
dudmuck 1:1cd0afbed23c 498 case 2: printf("BT0.5 "); break;
dudmuck 1:1cd0afbed23c 499 case 3: printf("BT0.3 "); break;
dudmuck 1:1cd0afbed23c 500 }
dudmuck 1:1cd0afbed23c 501 } else if (radio.RegOpMode.bits.ModulationType == 1) {
dudmuck 1:1cd0afbed23c 502 printf("OOK ");
dudmuck 1:1cd0afbed23c 503 }
dudmuck 1:1cd0afbed23c 504
dudmuck 3:ab386fa756cc 505 printf("%dbps fdev:%dHz\r\n", fsk.get_bitrate(), fsk.get_tx_fdev_hz());
dudmuck 1:1cd0afbed23c 506
dudmuck 1:1cd0afbed23c 507 fsk.RegPktConfig2.word = radio.read_u16(REG_FSK_PACKETCONFIG2);
dudmuck 1:1cd0afbed23c 508
dudmuck 1:1cd0afbed23c 509 fsk_print_dio();
dudmuck 1:1cd0afbed23c 510
dudmuck 1:1cd0afbed23c 511 printf("rxbw:%dHz ", fsk.get_rx_bw_hz(REG_FSK_RXBW));
dudmuck 1:1cd0afbed23c 512 printf("afcbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_AFCBW));
dudmuck 1:1cd0afbed23c 513
dudmuck 1:1cd0afbed23c 514 fsk.RegRssiConfig.octet = radio.read_reg(REG_FSK_RSSICONFIG);
dudmuck 1:1cd0afbed23c 515 printf("RssiOffset:%ddB smoothing:%dsamples\r\n", fsk.RegRssiConfig.bits.RssiOffset, 1 << (fsk.RegRssiConfig.bits.RssiSmoothing+1));
dudmuck 1:1cd0afbed23c 516
dudmuck 1:1cd0afbed23c 517
dudmuck 1:1cd0afbed23c 518 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 1:1cd0afbed23c 519
dudmuck 1:1cd0afbed23c 520 if (fsk.RegPktConfig2.bits.DataModePacket) {
dudmuck 1:1cd0afbed23c 521 uint16_t len;
dudmuck 1:1cd0afbed23c 522 /* packet mode */
dudmuck 1:1cd0afbed23c 523 len = fsk_get_PayloadLength();
dudmuck 1:1cd0afbed23c 524 printf("packet RegPayloadLength:0x%03x ", len);
dudmuck 1:1cd0afbed23c 525
dudmuck 1:1cd0afbed23c 526 if (fsk.RegPktConfig2.bits.BeaconOn)
dudmuck 1:1cd0afbed23c 527 printf("BeaconOn ");
dudmuck 1:1cd0afbed23c 528
dudmuck 1:1cd0afbed23c 529 fsk.RegFifoThreshold.octet = radio.read_reg(REG_FSK_FIFOTHRESH);
dudmuck 1:1cd0afbed23c 530 printf("FifoThreshold:%d TxStartCondition:", fsk.RegFifoThreshold.bits.FifoThreshold);
dudmuck 1:1cd0afbed23c 531 if (fsk.RegFifoThreshold.bits.TxStartCondition)
dudmuck 1:1cd0afbed23c 532 printf("!FifoEmpty");
dudmuck 1:1cd0afbed23c 533 else
dudmuck 1:1cd0afbed23c 534 printf("FifoLevel");
dudmuck 1:1cd0afbed23c 535
dudmuck 1:1cd0afbed23c 536 printf("\r\nAutoRestartRxMode:");
dudmuck 1:1cd0afbed23c 537 switch (fsk.RegSyncConfig.bits.AutoRestartRxMode) {
dudmuck 1:1cd0afbed23c 538 case 0: printf("off "); break;
dudmuck 1:1cd0afbed23c 539 case 1: printf("no-pll-wait "); break;
dudmuck 1:1cd0afbed23c 540 case 2: printf("pll-wait "); break;
dudmuck 1:1cd0afbed23c 541 case 3: printf("3 "); break;
dudmuck 1:1cd0afbed23c 542 }
dudmuck 1:1cd0afbed23c 543 //...todo
dudmuck 1:1cd0afbed23c 544
dudmuck 1:1cd0afbed23c 545 printf("PreambleSize:%d ", radio.read_u16(REG_FSK_PREAMBLEMSB));
dudmuck 1:1cd0afbed23c 546
dudmuck 1:1cd0afbed23c 547 fsk.RegOokPeak.octet = radio.read_reg(REG_FSK_OOKPEAK);
dudmuck 1:1cd0afbed23c 548 if (fsk.RegOokPeak.bits.barker_en)
dudmuck 1:1cd0afbed23c 549 printf("barker ");
dudmuck 1:1cd0afbed23c 550 if (!fsk.RegOokPeak.bits.BitSyncOn)
dudmuck 1:1cd0afbed23c 551 printf("BitSyncOff ");
dudmuck 1:1cd0afbed23c 552 //...todo
dudmuck 1:1cd0afbed23c 553
dudmuck 1:1cd0afbed23c 554 fsk.RegPktConfig1.octet = radio.read_reg(REG_FSK_PACKETCONFIG1);
dudmuck 1:1cd0afbed23c 555 if (fsk.RegPktConfig1.bits.PacketFormatVariable)
dudmuck 1:1cd0afbed23c 556 printf("variable");
dudmuck 1:1cd0afbed23c 557 else
dudmuck 1:1cd0afbed23c 558 printf("fixed");
dudmuck 1:1cd0afbed23c 559 printf("-length\r\ncrc");
dudmuck 1:1cd0afbed23c 560 if (fsk.RegPktConfig1.bits.CrcOn) {
dudmuck 1:1cd0afbed23c 561 printf("On");
dudmuck 1:1cd0afbed23c 562 } else
dudmuck 1:1cd0afbed23c 563 printf("Off");
dudmuck 1:1cd0afbed23c 564 printf(" crctype:");
dudmuck 1:1cd0afbed23c 565 if (fsk.RegPktConfig1.bits.CrCWhiteningType)
dudmuck 1:1cd0afbed23c 566 printf("IBM");
dudmuck 1:1cd0afbed23c 567 else
dudmuck 1:1cd0afbed23c 568 printf("CCITT");
dudmuck 1:1cd0afbed23c 569 printf(" dcFree:");
dudmuck 1:1cd0afbed23c 570 switch (fsk.RegPktConfig1.bits.DcFree) {
dudmuck 1:1cd0afbed23c 571 case 0: printf("none "); break;
dudmuck 1:1cd0afbed23c 572 case 1: printf("Manchester "); break;
dudmuck 1:1cd0afbed23c 573 case 2: printf("Whitening "); break;
dudmuck 1:1cd0afbed23c 574 case 3: printf("reserved "); break;
dudmuck 1:1cd0afbed23c 575 }
dudmuck 1:1cd0afbed23c 576 fsk_printAddressFiltering();
dudmuck 1:1cd0afbed23c 577
dudmuck 1:1cd0afbed23c 578 printf("\r\n");
dudmuck 1:1cd0afbed23c 579 fsk_print_IrqFlags2();
dudmuck 1:1cd0afbed23c 580 } else {
dudmuck 1:1cd0afbed23c 581 /* continuous mode */
dudmuck 1:1cd0afbed23c 582 printf("continuous ");
dudmuck 1:1cd0afbed23c 583 }
dudmuck 1:1cd0afbed23c 584
dudmuck 1:1cd0afbed23c 585 fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
dudmuck 1:1cd0afbed23c 586 printf("PreambleDetect:");
dudmuck 1:1cd0afbed23c 587 if (fsk.RegPreambleDetect.bits.PreambleDetectorOn) {
dudmuck 1:1cd0afbed23c 588 printf("size=%d,tol=%d ",
dudmuck 1:1cd0afbed23c 589 fsk.RegPreambleDetect.bits.PreambleDetectorSize,
dudmuck 1:1cd0afbed23c 590 fsk.RegPreambleDetect.bits.PreambleDetectorTol);
dudmuck 1:1cd0afbed23c 591 } else
dudmuck 1:1cd0afbed23c 592 printf("Off ");
dudmuck 1:1cd0afbed23c 593
dudmuck 1:1cd0afbed23c 594 printf(" syncsize:%d ", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 1:1cd0afbed23c 595 printf(" : %02x ", radio.read_reg(REG_FSK_SYNCVALUE1));
dudmuck 1:1cd0afbed23c 596 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE2));
dudmuck 1:1cd0afbed23c 597 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE3));
dudmuck 1:1cd0afbed23c 598 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE4));
dudmuck 1:1cd0afbed23c 599 printf("\r\n"); // end sync config
dudmuck 1:1cd0afbed23c 600
dudmuck 1:1cd0afbed23c 601 fsk.RegAfcFei.octet = radio.read_reg(REG_FSK_AFCFEI);
dudmuck 1:1cd0afbed23c 602 printf("afcAutoClear:");
dudmuck 1:1cd0afbed23c 603 if (fsk.RegAfcFei.bits.AfcAutoClearOn)
dudmuck 1:1cd0afbed23c 604 printf("On");
dudmuck 1:1cd0afbed23c 605 else
dudmuck 1:1cd0afbed23c 606 printf("OFF");
dudmuck 1:1cd0afbed23c 607 printf(" afc:%dHz ", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_AFCMSB)));
dudmuck 1:1cd0afbed23c 608
dudmuck 1:1cd0afbed23c 609 printf("fei:%dHz\r\n", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_FEIMSB)));
dudmuck 1:1cd0afbed23c 610
dudmuck 1:1cd0afbed23c 611 fsk.RegRxConfig.octet = radio.read_reg(REG_FSK_RXCONFIG);
dudmuck 1:1cd0afbed23c 612 printf("RxTrigger:");
dudmuck 1:1cd0afbed23c 613 switch (fsk.RegRxConfig.bits.RxTrigger) {
dudmuck 1:1cd0afbed23c 614 case 0: printf("none "); break;
dudmuck 1:1cd0afbed23c 615 case 1: printf("rssi "); break;
dudmuck 1:1cd0afbed23c 616 case 6: printf("preamble "); break;
dudmuck 1:1cd0afbed23c 617 case 7: printf("both "); break;
dudmuck 1:1cd0afbed23c 618 default: printf("-%d- ", fsk.RegRxConfig.bits.RxTrigger); break;
dudmuck 1:1cd0afbed23c 619 }
dudmuck 1:1cd0afbed23c 620 printf("AfcAuto:");
dudmuck 1:1cd0afbed23c 621 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 1:1cd0afbed23c 622 printf("On ");
dudmuck 1:1cd0afbed23c 623 else
dudmuck 1:1cd0afbed23c 624 printf("OFF ");
dudmuck 1:1cd0afbed23c 625 if (!fsk.RegRxConfig.bits.AgcAutoOn) {
dudmuck 1:1cd0afbed23c 626 radio.RegLna.octet = radio.read_reg(REG_LNA);
dudmuck 1:1cd0afbed23c 627 printf("AgcAutoOff:G%d ", radio.RegLna.bits.LnaGain);
dudmuck 1:1cd0afbed23c 628 }
dudmuck 1:1cd0afbed23c 629
dudmuck 1:1cd0afbed23c 630 fsk.RegTimerResol.octet = radio.read_reg(REG_FSK_TIMERRESOL);
dudmuck 1:1cd0afbed23c 631 if (fsk.RegTimerResol.bits.hlm_started)
dudmuck 1:1cd0afbed23c 632 printf("hlm_started ");
dudmuck 1:1cd0afbed23c 633 else
dudmuck 1:1cd0afbed23c 634 printf("hlm_stopped ");
dudmuck 1:1cd0afbed23c 635
dudmuck 1:1cd0afbed23c 636 fsk.RegRssiThresh = radio.read_reg(REG_FSK_RSSITHRESH);
dudmuck 1:1cd0afbed23c 637 printf("rssiThreshold:-%.1f@%02x ", fsk.RegRssiThresh / 2.0, REG_FSK_RSSITHRESH);
dudmuck 1:1cd0afbed23c 638
dudmuck 1:1cd0afbed23c 639 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 1:1cd0afbed23c 640 if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER ||
dudmuck 1:1cd0afbed23c 641 radio.RegOpMode.bits.Mode == RF_OPMODE_SYNTHESIZER_RX)
dudmuck 1:1cd0afbed23c 642 {
dudmuck 1:1cd0afbed23c 643 printf("rssi:-%.1f ", radio.read_reg(REG_FSK_RSSIVALUE) / 2.0);
dudmuck 1:1cd0afbed23c 644 }
dudmuck 1:1cd0afbed23c 645
dudmuck 1:1cd0afbed23c 646 fsk.RegSeqConfig1.octet = radio.read_reg(REG_FSK_SEQCONFIG1);
dudmuck 1:1cd0afbed23c 647 printf("\r\nsequencer: ");
dudmuck 1:1cd0afbed23c 648 printf("FromStart:");
dudmuck 1:1cd0afbed23c 649 switch (fsk.RegSeqConfig1.bits.FromStart) {
dudmuck 1:1cd0afbed23c 650 case 0:
dudmuck 1:1cd0afbed23c 651 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 652 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 653 printf("idle");
dudmuck 1:1cd0afbed23c 654 else
dudmuck 1:1cd0afbed23c 655 printf("sequencerOff");
dudmuck 1:1cd0afbed23c 656 break;
dudmuck 1:1cd0afbed23c 657 case 1: printf("rx"); break;
dudmuck 1:1cd0afbed23c 658 case 2: printf("tx"); break;
dudmuck 1:1cd0afbed23c 659 case 3: printf("tx on fifolevel"); break;
dudmuck 1:1cd0afbed23c 660 }
dudmuck 1:1cd0afbed23c 661 printf(" lowPowerSelection:");
dudmuck 1:1cd0afbed23c 662 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 663 printf("idle");
dudmuck 1:1cd0afbed23c 664 else
dudmuck 1:1cd0afbed23c 665 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 666 if (fsk.RegSeqConfig1.bits.FromStart != 0 &&
dudmuck 1:1cd0afbed23c 667 fsk.RegSeqConfig1.bits.LowPowerSelection != 0)
dudmuck 1:1cd0afbed23c 668 { // if sequencer enabled:
dudmuck 1:1cd0afbed23c 669 printf("\r\nsequencer: IdleMode:");
dudmuck 1:1cd0afbed23c 670 if (fsk.RegSeqConfig1.bits.IdleMode)
dudmuck 1:1cd0afbed23c 671 printf("Sleep");
dudmuck 1:1cd0afbed23c 672 else
dudmuck 1:1cd0afbed23c 673 printf("standby");
dudmuck 1:1cd0afbed23c 674 printf("\r\nsequencer: FromIdle to:");
dudmuck 1:1cd0afbed23c 675 if (fsk.RegSeqConfig1.bits.FromIdle)
dudmuck 1:1cd0afbed23c 676 printf("rx");
dudmuck 1:1cd0afbed23c 677 else
dudmuck 1:1cd0afbed23c 678 printf("tx");
dudmuck 1:1cd0afbed23c 679 printf("\r\nsequencer: FromTransmit to:");
dudmuck 1:1cd0afbed23c 680 if (fsk.RegSeqConfig1.bits.FromTransmit)
dudmuck 1:1cd0afbed23c 681 printf("rx-on-PacketSent");
dudmuck 1:1cd0afbed23c 682 else {
dudmuck 1:1cd0afbed23c 683 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 684 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 685 printf("idle");
dudmuck 1:1cd0afbed23c 686 else
dudmuck 1:1cd0afbed23c 687 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 688 printf("-on-PacketSent");
dudmuck 1:1cd0afbed23c 689 }
dudmuck 1:1cd0afbed23c 690 fsk.RegSeqConfig2.octet = radio.read_reg(REG_FSK_SEQCONFIG2);
dudmuck 1:1cd0afbed23c 691 printf("\r\nsequencer: FromReceive:");
dudmuck 1:1cd0afbed23c 692 switch (fsk.RegSeqConfig2.bits.FromReceive) {
dudmuck 1:1cd0afbed23c 693 case 1: printf("PacketRecevied on PayloadReady"); break;
dudmuck 1:1cd0afbed23c 694 case 2:
dudmuck 1:1cd0afbed23c 695 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 696 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 697 printf("idle");
dudmuck 1:1cd0afbed23c 698 else
dudmuck 1:1cd0afbed23c 699 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 700 printf("-on-payloadReady");
dudmuck 1:1cd0afbed23c 701 break;
dudmuck 1:1cd0afbed23c 702 case 3: printf("PacketRecevied-on-CrcOk"); break;
dudmuck 1:1cd0afbed23c 703 case 4: printf("SequencerOff-on-Rssi"); break;
dudmuck 1:1cd0afbed23c 704 case 5: printf("SequencerOff-on-SyncAddress"); break;
dudmuck 1:1cd0afbed23c 705 case 6: printf("SequencerOff-PreambleDetect"); break;
dudmuck 1:1cd0afbed23c 706 default: printf("-%d-", fsk.RegSeqConfig2.bits.FromReceive); break;
dudmuck 1:1cd0afbed23c 707 }
dudmuck 1:1cd0afbed23c 708 printf("\r\nsequencer: FromRxTimeout:");
dudmuck 1:1cd0afbed23c 709 switch (fsk.RegSeqConfig2.bits.FromRxTimeout) {
dudmuck 1:1cd0afbed23c 710 case 0: printf("rx"); break;
dudmuck 1:1cd0afbed23c 711 case 1: printf("tx"); break;
dudmuck 1:1cd0afbed23c 712 case 2:
dudmuck 1:1cd0afbed23c 713 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 714 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 715 printf("idle");
dudmuck 1:1cd0afbed23c 716 else
dudmuck 1:1cd0afbed23c 717 printf("SequencerOff");
dudmuck 1:1cd0afbed23c 718 break;
dudmuck 1:1cd0afbed23c 719 case 3: printf("SequencerOff"); break;
dudmuck 1:1cd0afbed23c 720 }
dudmuck 1:1cd0afbed23c 721 printf("\r\nsequencer: FromPacketReceived to:");
dudmuck 1:1cd0afbed23c 722 switch (fsk.RegSeqConfig2.bits.FromPacketReceived) {
dudmuck 1:1cd0afbed23c 723 case 0: printf("SequencerOff"); break;
dudmuck 1:1cd0afbed23c 724 case 1: printf("tx on FifoEmpty"); break;
dudmuck 1:1cd0afbed23c 725 case 2:
dudmuck 1:1cd0afbed23c 726 printf("lowPowerSelection-");
dudmuck 1:1cd0afbed23c 727 if (fsk.RegSeqConfig1.bits.LowPowerSelection)
dudmuck 1:1cd0afbed23c 728 printf("idle");
dudmuck 1:1cd0afbed23c 729 else
dudmuck 1:1cd0afbed23c 730 printf("sequencerOff");
dudmuck 1:1cd0afbed23c 731 break;
dudmuck 1:1cd0afbed23c 732 case 3: printf("rx via fs"); break;
dudmuck 1:1cd0afbed23c 733 case 4: printf("rx"); break;
dudmuck 1:1cd0afbed23c 734 }
dudmuck 1:1cd0afbed23c 735
dudmuck 1:1cd0afbed23c 736 fsk.RegTimerResol.octet = radio.read_reg(REG_FSK_TIMERRESOL);
dudmuck 1:1cd0afbed23c 737 printf("\r\nsequencer: timer1:");
dudmuck 1:1cd0afbed23c 738 switch (fsk.RegTimerResol.bits.timer1_resol) {
dudmuck 1:1cd0afbed23c 739 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 740 case 1: printf("%dus", radio.read_reg(REG_FSK_TIMER1COEF) * 64); break;
dudmuck 1:1cd0afbed23c 741 case 2: printf("%.1fms", radio.read_reg(REG_FSK_TIMER1COEF) * 4.1); break;
dudmuck 1:1cd0afbed23c 742 case 3: printf("%.1fs", radio.read_reg(REG_FSK_TIMER1COEF) * 0.262); break;
dudmuck 1:1cd0afbed23c 743 }
dudmuck 1:1cd0afbed23c 744
dudmuck 1:1cd0afbed23c 745 printf(" timer2:");
dudmuck 1:1cd0afbed23c 746 switch (fsk.RegTimerResol.bits.timer2_resol) {
dudmuck 1:1cd0afbed23c 747 case 0: printf("off"); break;
dudmuck 1:1cd0afbed23c 748 case 1: printf("%dus", radio.read_reg(REG_FSK_TIMER2COEF) * 64); break;
dudmuck 1:1cd0afbed23c 749 case 2: printf("%.1fms", radio.read_reg(REG_FSK_TIMER2COEF) * 4.1); break;
dudmuck 1:1cd0afbed23c 750 case 3: printf("%.1fs", radio.read_reg(REG_FSK_TIMER2COEF) * 0.262); break;
dudmuck 1:1cd0afbed23c 751 }
dudmuck 1:1cd0afbed23c 752 } // ..if sequencer enabled
dudmuck 1:1cd0afbed23c 753
dudmuck 1:1cd0afbed23c 754 printf("\r\nIrqFlags1:");
dudmuck 2:c6b23a43a9d9 755 RegIrqFlags1.octet = radio.read_reg(REG_FSK_IRQFLAGS1);
dudmuck 2:c6b23a43a9d9 756 if (RegIrqFlags1.bits.ModeReady)
dudmuck 1:1cd0afbed23c 757 printf("ModeReady ");
dudmuck 2:c6b23a43a9d9 758 if (RegIrqFlags1.bits.RxReady)
dudmuck 1:1cd0afbed23c 759 printf("RxReady ");
dudmuck 2:c6b23a43a9d9 760 if (RegIrqFlags1.bits.TxReady)
dudmuck 1:1cd0afbed23c 761 printf("TxReady ");
dudmuck 2:c6b23a43a9d9 762 if (RegIrqFlags1.bits.PllLock)
dudmuck 1:1cd0afbed23c 763 printf("PllLock ");
dudmuck 2:c6b23a43a9d9 764 if (RegIrqFlags1.bits.Rssi)
dudmuck 1:1cd0afbed23c 765 printf("Rssi ");
dudmuck 2:c6b23a43a9d9 766 if (RegIrqFlags1.bits.Timeout)
dudmuck 1:1cd0afbed23c 767 printf("Timeout ");
dudmuck 2:c6b23a43a9d9 768 if (RegIrqFlags1.bits.PreambleDetect)
dudmuck 1:1cd0afbed23c 769 printf("PreambleDetect ");
dudmuck 2:c6b23a43a9d9 770 if (RegIrqFlags1.bits.SyncAddressMatch)
dudmuck 1:1cd0afbed23c 771 printf("SyncAddressMatch ");
dudmuck 1:1cd0afbed23c 772
dudmuck 1:1cd0afbed23c 773 printf("\r\n");
dudmuck 1:1cd0afbed23c 774
dudmuck 1:1cd0afbed23c 775 /* TODO if (!SX1272FSK->RegPktConfig1.bits.PacketFormatVariable) { // if fixed-length packet format:
dudmuck 1:1cd0afbed23c 776 s = fsk_get_PayloadLength();
dudmuck 1:1cd0afbed23c 777 if (s > FSK_LARGE_PKT_THRESHOLD)
dudmuck 1:1cd0afbed23c 778 flags.fifo_flow_ctl = 1;
dudmuck 1:1cd0afbed23c 779 else
dudmuck 1:1cd0afbed23c 780 flags.fifo_flow_ctl = 0;
dudmuck 1:1cd0afbed23c 781 }*/
dudmuck 1:1cd0afbed23c 782
dudmuck 1:1cd0afbed23c 783 fsk.RegImageCal.octet = radio.read_reg(REG_FSK_IMAGECAL);
dudmuck 1:1cd0afbed23c 784 if (fsk.RegImageCal.bits.TempMonitorOff) {
dudmuck 1:1cd0afbed23c 785 printf("TempMonitorOff[\r0m\n");
dudmuck 1:1cd0afbed23c 786 } else {
dudmuck 1:1cd0afbed23c 787 printf("TempThreshold:");
dudmuck 1:1cd0afbed23c 788 switch (fsk.RegImageCal.bits.TempThreshold) {
dudmuck 1:1cd0afbed23c 789 case 0: printf("5C"); break;
dudmuck 1:1cd0afbed23c 790 case 1: printf("10C"); break;
dudmuck 1:1cd0afbed23c 791 case 2: printf("15C"); break;
dudmuck 1:1cd0afbed23c 792 case 3: printf("20C"); break;
dudmuck 1:1cd0afbed23c 793 }
dudmuck 1:1cd0afbed23c 794 printf("\r\n");
dudmuck 1:1cd0afbed23c 795 }
dudmuck 1:1cd0afbed23c 796 if (fsk.RegImageCal.bits.ImageCalRunning)
dudmuck 1:1cd0afbed23c 797 printf("ImageCalRunning[\r0m\n");
dudmuck 1:1cd0afbed23c 798
dudmuck 1:1cd0afbed23c 799 /* printf("flags.fifo_flow_ctl:%d pktidx:%d rx_pktlen:%d", flags.fifo_flow_ctl, pktidx, rx_pktlen);
dudmuck 1:1cd0afbed23c 800 printf("\n");
dudmuck 1:1cd0afbed23c 801
dudmuck 1:1cd0afbed23c 802 //printf("DIO0_PIN:%d\n", digitalRead(DIO0_PIN));
dudmuck 1:1cd0afbed23c 803 printf("pkt_buf_len=%d remaining=%d\n", pk*/
dudmuck 1:1cd0afbed23c 804 }
dudmuck 1:1cd0afbed23c 805
dudmuck 0:be215de91a68 806 void printOpMode()
dudmuck 0:be215de91a68 807 {
dudmuck 0:be215de91a68 808 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:be215de91a68 809 switch (radio.RegOpMode.bits.Mode) {
dudmuck 0:be215de91a68 810 case RF_OPMODE_SLEEP: printf("sleep"); break;
dudmuck 0:be215de91a68 811 case RF_OPMODE_STANDBY: printf("stby"); break;
dudmuck 0:be215de91a68 812 case RF_OPMODE_SYNTHESIZER_TX: printf("fstx"); break;
dudmuck 0:be215de91a68 813 case RF_OPMODE_TRANSMITTER: printf("tx"); break;
dudmuck 0:be215de91a68 814 case RF_OPMODE_SYNTHESIZER_RX: printf("fsrx"); break;
dudmuck 0:be215de91a68 815 case RF_OPMODE_RECEIVER: printf("rx"); break;
dudmuck 0:be215de91a68 816 case 6:
dudmuck 0:be215de91a68 817 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:be215de91a68 818 printf("rxs");
dudmuck 0:be215de91a68 819 else
dudmuck 0:be215de91a68 820 printf("-6-");
dudmuck 0:be215de91a68 821 break; // todo: different lora/fsk
dudmuck 0:be215de91a68 822 case 7:
dudmuck 0:be215de91a68 823 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:be215de91a68 824 printf("cad");
dudmuck 0:be215de91a68 825 else
dudmuck 0:be215de91a68 826 printf("-7-");
dudmuck 0:be215de91a68 827 break; // todo: different lora/fsk
dudmuck 0:be215de91a68 828 }
dudmuck 0:be215de91a68 829 }
dudmuck 0:be215de91a68 830
dudmuck 0:be215de91a68 831 void
dudmuck 0:be215de91a68 832 printPa()
dudmuck 0:be215de91a68 833 {
dudmuck 0:be215de91a68 834 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:be215de91a68 835 if (radio.RegPaConfig.bits.PaSelect) {
dudmuck 0:be215de91a68 836 float output_dBm = 17 - (15-radio.RegPaConfig.bits.OutputPower);
dudmuck 0:be215de91a68 837 printf(" PABOOST OutputPower=%.1fdBm", output_dBm);
dudmuck 0:be215de91a68 838 } else {
dudmuck 0:be215de91a68 839 float pmax = (0.6*radio.RegPaConfig.bits.MaxPower) + 10.8;
dudmuck 0:be215de91a68 840 float output_dBm = pmax - (15-radio.RegPaConfig.bits.OutputPower);
dudmuck 0:be215de91a68 841 printf(" RFO pmax=%.1fdBm OutputPower=%.1fdBm", pmax, output_dBm);
dudmuck 0:be215de91a68 842 }
dudmuck 0:be215de91a68 843 }
dudmuck 0:be215de91a68 844
dudmuck 0:be215de91a68 845 void /* things always present, whether lora or fsk */
dudmuck 0:be215de91a68 846 common_print_status()
dudmuck 0:be215de91a68 847 {
dudmuck 0:be215de91a68 848 printf("version:0x%02x %.3fMHz ", radio.read_reg(REG_VERSION), radio.get_frf_MHz());
dudmuck 0:be215de91a68 849 printOpMode();
dudmuck 0:be215de91a68 850
dudmuck 0:be215de91a68 851 printPa();
dudmuck 0:be215de91a68 852
dudmuck 0:be215de91a68 853 radio.RegOcp.octet = radio.read_reg(REG_OCP);
dudmuck 0:be215de91a68 854 if (radio.RegOcp.bits.OcpOn) {
dudmuck 0:be215de91a68 855 int imax = 0;
dudmuck 0:be215de91a68 856 if (radio.RegOcp.bits.OcpTrim < 16)
dudmuck 0:be215de91a68 857 imax = 45 + (5 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:be215de91a68 858 else if (radio.RegOcp.bits.OcpTrim < 28)
dudmuck 0:be215de91a68 859 imax = -30 + (10 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:be215de91a68 860 else
dudmuck 0:be215de91a68 861 imax = 240;
dudmuck 0:be215de91a68 862 printf(" OcpOn %dmA ", imax);
dudmuck 0:be215de91a68 863 } else
dudmuck 0:be215de91a68 864 printf(" OcpOFF ");
dudmuck 0:be215de91a68 865
dudmuck 0:be215de91a68 866 printf("\r\n");
dudmuck 0:be215de91a68 867
dudmuck 0:be215de91a68 868 }
dudmuck 0:be215de91a68 869
dudmuck 0:be215de91a68 870 void print_rx_buf(int len)
dudmuck 0:be215de91a68 871 {
dudmuck 0:be215de91a68 872 int i;
dudmuck 0:be215de91a68 873
dudmuck 0:be215de91a68 874 printf("000:");
dudmuck 0:be215de91a68 875 for (i = 0; i < len; i++) {
dudmuck 0:be215de91a68 876 //printf("(%d)%02x ", i % 16, rx_buf[i]);
dudmuck 0:be215de91a68 877 printf("%02x ", radio.rx_buf[i]);
dudmuck 0:be215de91a68 878 if (i % 16 == 15 && i != len-1)
dudmuck 0:be215de91a68 879 printf("\r\n%03d:", i+1);
dudmuck 0:be215de91a68 880
dudmuck 0:be215de91a68 881 }
dudmuck 0:be215de91a68 882 printf("\r\n");
dudmuck 0:be215de91a68 883 }
dudmuck 0:be215de91a68 884
dudmuck 0:be215de91a68 885 void
dudmuck 0:be215de91a68 886 service_radio()
dudmuck 0:be215de91a68 887 {
dudmuck 1:1cd0afbed23c 888 service_action_e act;
dudmuck 1:1cd0afbed23c 889
dudmuck 1:1cd0afbed23c 890 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 4:7a9007dfc0e5 891
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 4:7a9007dfc0e5 999 } else {
dudmuck 0:be215de91a68 1000 service_radio();
dudmuck 4:7a9007dfc0e5 1001 }
dudmuck 0:be215de91a68 1002 } // ...for()
dudmuck 0:be215de91a68 1003 }
dudmuck 0:be215de91a68 1004
dudmuck 0:be215de91a68 1005 void
dudmuck 0:be215de91a68 1006 console_chat()
dudmuck 0:be215de91a68 1007 {
dudmuck 0:be215de91a68 1008 int i, len = get_kbd_str(pcbuf, sizeof(pcbuf));
dudmuck 0:be215de91a68 1009 if (len < 0) {
dudmuck 0:be215de91a68 1010 printf("chat abort\r\n");
dudmuck 0:be215de91a68 1011 app = APP_NONE;
dudmuck 0:be215de91a68 1012 return;
dudmuck 0:be215de91a68 1013 } else {
dudmuck 0:be215de91a68 1014 for (i = 0; i < len; i++)
dudmuck 0:be215de91a68 1015 radio.tx_buf[i] = pcbuf[i];
dudmuck 1:1cd0afbed23c 1016 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1017 lora.RegPayloadLength = len;
dudmuck 1:1cd0afbed23c 1018 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 1:1cd0afbed23c 1019 lora.start_tx(len);
dudmuck 2:c6b23a43a9d9 1020 } else {
dudmuck 2:c6b23a43a9d9 1021 fsk.start_tx(len);
dudmuck 2:c6b23a43a9d9 1022 }
dudmuck 0:be215de91a68 1023 printf("\r\n");
dudmuck 0:be215de91a68 1024 }
dudmuck 0:be215de91a68 1025 }
dudmuck 0:be215de91a68 1026
dudmuck 0:be215de91a68 1027 void
dudmuck 0:be215de91a68 1028 console()
dudmuck 0:be215de91a68 1029 {
dudmuck 0:be215de91a68 1030 int len, i;
dudmuck 2:c6b23a43a9d9 1031 uint32_t ui;
dudmuck 0:be215de91a68 1032 uint8_t a, d;
dudmuck 1:1cd0afbed23c 1033 static uint16_t fsk_tx_length;
dudmuck 0:be215de91a68 1034
dudmuck 0:be215de91a68 1035 len = get_kbd_str(pcbuf, sizeof(pcbuf));
dudmuck 0:be215de91a68 1036 if (len < 0) {
dudmuck 0:be215de91a68 1037 printf("abort\r\n");
dudmuck 0:be215de91a68 1038 return;
dudmuck 0:be215de91a68 1039 }
dudmuck 0:be215de91a68 1040
dudmuck 0:be215de91a68 1041 printf("\r\n");
dudmuck 0:be215de91a68 1042 if (len == 1) {
dudmuck 0:be215de91a68 1043 switch (pcbuf[0]) {
dudmuck 0:be215de91a68 1044 case 'i':
dudmuck 3:ab386fa756cc 1045 printf("init\r\n");
dudmuck 0:be215de91a68 1046 radio.init();
dudmuck 3:ab386fa756cc 1047 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1048 fsk.init(); // put FSK modem to some functioning default
dudmuck 3:ab386fa756cc 1049 } else {
dudmuck 3:ab386fa756cc 1050 // lora configuration is more simple
dudmuck 3:ab386fa756cc 1051 }
dudmuck 0:be215de91a68 1052 break;
dudmuck 0:be215de91a68 1053 case 'h':
dudmuck 0:be215de91a68 1054 printf("hw_reset()\r\n");
dudmuck 0:be215de91a68 1055 radio.hw_reset();
dudmuck 0:be215de91a68 1056 break;
dudmuck 0:be215de91a68 1057 case 'R':
dudmuck 0:be215de91a68 1058 // read all registers
dudmuck 0:be215de91a68 1059 for (a = 1; a < 0x71; a++) {
dudmuck 0:be215de91a68 1060 d = radio.read_reg(a);
dudmuck 0:be215de91a68 1061 //update_shadow_regs(selected_radio, a, d);
dudmuck 0:be215de91a68 1062 printf("%02x: %02x\r\n", a, d);
dudmuck 0:be215de91a68 1063 }
dudmuck 0:be215de91a68 1064 break;
dudmuck 0:be215de91a68 1065 case 'T':
dudmuck 1:1cd0afbed23c 1066 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1067 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 1:1cd0afbed23c 1068 //printf("a %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1069 lora.RegModemConfig2.sx1276bits.TxContinuousMode ^= 1; // same for sx1272 and sx1276
dudmuck 1:1cd0afbed23c 1070 //printf("b %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1071 radio.write_reg(REG_LR_MODEMCONFIG2, lora.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1072 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1073 //printf("c %02x\r\n", radio.RegModemConfig2.octet);
dudmuck 1:1cd0afbed23c 1074 lora_printTxContinuousMode();
dudmuck 1:1cd0afbed23c 1075 printf("\r\n");
dudmuck 1:1cd0afbed23c 1076 }
dudmuck 0:be215de91a68 1077 break;
dudmuck 0:be215de91a68 1078 case 'C':
dudmuck 2:c6b23a43a9d9 1079 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1080 lora.setRxPayloadCrcOn(!lora.getRxPayloadCrcOn());
dudmuck 2:c6b23a43a9d9 1081 lora_printRxPayloadCrcOn();
dudmuck 2:c6b23a43a9d9 1082 } else {
dudmuck 2:c6b23a43a9d9 1083 printf("CrcOn:");
dudmuck 2:c6b23a43a9d9 1084 fsk.RegPktConfig1.bits.CrcOn ^= 1;
dudmuck 2:c6b23a43a9d9 1085 radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
dudmuck 2:c6b23a43a9d9 1086 if (fsk.RegPktConfig1.bits.CrcOn)
dudmuck 2:c6b23a43a9d9 1087 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1088 else
dudmuck 2:c6b23a43a9d9 1089 printf("Off\r\n");
dudmuck 2:c6b23a43a9d9 1090 if (fsk.RegPktConfig2.bits.DataModePacket && radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER) {
dudmuck 2:c6b23a43a9d9 1091 fsk.config_dio0_for_pktmode_rx();
dudmuck 2:c6b23a43a9d9 1092 }
dudmuck 2:c6b23a43a9d9 1093 }
dudmuck 0:be215de91a68 1094 printf("\r\n");
dudmuck 0:be215de91a68 1095 break;
dudmuck 0:be215de91a68 1096 case 'B':
dudmuck 0:be215de91a68 1097 radio.RegPaConfig.bits.PaSelect ^= 1;
dudmuck 0:be215de91a68 1098 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:be215de91a68 1099 printPa();
dudmuck 0:be215de91a68 1100 printf("\r\n");
dudmuck 1:1cd0afbed23c 1101 break;
dudmuck 1:1cd0afbed23c 1102 case 'L':
dudmuck 1:1cd0afbed23c 1103 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1104 fsk.enable();
dudmuck 1:1cd0afbed23c 1105 else
dudmuck 1:1cd0afbed23c 1106 lora.enable();
dudmuck 1:1cd0afbed23c 1107
dudmuck 1:1cd0afbed23c 1108 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 1:1cd0afbed23c 1109 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1110 printf("LoRa\r\n");
dudmuck 1:1cd0afbed23c 1111 else
dudmuck 1:1cd0afbed23c 1112 printf("FSK\r\n");
dudmuck 2:c6b23a43a9d9 1113 break;
dudmuck 2:c6b23a43a9d9 1114 case 's':
dudmuck 2:c6b23a43a9d9 1115 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1116 fsk.RegFifoThreshold.bits.TxStartCondition ^= 1;
dudmuck 2:c6b23a43a9d9 1117 radio.write_reg(REG_FSK_FIFOTHRESH, fsk.RegFifoThreshold.octet);
dudmuck 2:c6b23a43a9d9 1118 printf("TxStartCondition:");
dudmuck 2:c6b23a43a9d9 1119 if (fsk.RegFifoThreshold.bits.TxStartCondition)
dudmuck 2:c6b23a43a9d9 1120 printf("!FifoEmpty\r\n");
dudmuck 2:c6b23a43a9d9 1121 else
dudmuck 2:c6b23a43a9d9 1122 printf("FifoLevel\r\n");
dudmuck 2:c6b23a43a9d9 1123 }
dudmuck 2:c6b23a43a9d9 1124 break;
dudmuck 2:c6b23a43a9d9 1125 case 'f':
dudmuck 2:c6b23a43a9d9 1126 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1127 printf("PacketFormat:");
dudmuck 2:c6b23a43a9d9 1128 fsk.RegPktConfig1.bits.PacketFormatVariable ^= 1;
dudmuck 2:c6b23a43a9d9 1129 radio.write_reg(REG_FSK_PACKETCONFIG1, fsk.RegPktConfig1.octet);
dudmuck 2:c6b23a43a9d9 1130 if (fsk.RegPktConfig1.bits.PacketFormatVariable)
dudmuck 2:c6b23a43a9d9 1131 printf("variable\r\n");
dudmuck 2:c6b23a43a9d9 1132 else
dudmuck 2:c6b23a43a9d9 1133 printf("fixed\r\n");
dudmuck 2:c6b23a43a9d9 1134 /*if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER)
dudmuck 2:c6b23a43a9d9 1135 reset_flow();*/
dudmuck 2:c6b23a43a9d9 1136 }
dudmuck 2:c6b23a43a9d9 1137 break;
dudmuck 2:c6b23a43a9d9 1138 case 'E':
dudmuck 2:c6b23a43a9d9 1139 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1140 RegIrqFlags2_t RegIrqFlags2;
dudmuck 2:c6b23a43a9d9 1141 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 1142 while (!RegIrqFlags2.bits.FifoEmpty) {
dudmuck 2:c6b23a43a9d9 1143 if (pc.readable())
dudmuck 2:c6b23a43a9d9 1144 break;
dudmuck 2:c6b23a43a9d9 1145 printf("%02x\r\n", radio.read_reg(REG_FIFO));
dudmuck 2:c6b23a43a9d9 1146 RegIrqFlags2.octet = radio.read_reg(REG_FSK_IRQFLAGS2);
dudmuck 2:c6b23a43a9d9 1147 }
dudmuck 2:c6b23a43a9d9 1148 }
dudmuck 2:c6b23a43a9d9 1149 break;
dudmuck 2:c6b23a43a9d9 1150 case 'A':
dudmuck 2:c6b23a43a9d9 1151 if (!radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1152 fsk.RegRxConfig.bits.AfcAutoOn ^= 1;
dudmuck 2:c6b23a43a9d9 1153 radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
dudmuck 2:c6b23a43a9d9 1154 printf("AfcAuto:");
dudmuck 2:c6b23a43a9d9 1155 if (fsk.RegRxConfig.bits.AfcAutoOn)
dudmuck 2:c6b23a43a9d9 1156 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1157 else
dudmuck 2:c6b23a43a9d9 1158 printf("OFF\r\n");
dudmuck 2:c6b23a43a9d9 1159 break;
dudmuck 2:c6b23a43a9d9 1160 }
dudmuck 2:c6b23a43a9d9 1161 break;
dudmuck 0:be215de91a68 1162 case '?':
dudmuck 1:1cd0afbed23c 1163 printf("L toggle LongRangeMode/FSK\r\n");
dudmuck 0:be215de91a68 1164 printf("i radio_init\r\n");
dudmuck 0:be215de91a68 1165 printf("h hw_reset\r\n");
dudmuck 2:c6b23a43a9d9 1166 printf("tx[%%d] transmit\r\n");
dudmuck 1:1cd0afbed23c 1167 printf("rx receive\r\n");
dudmuck 0:be215de91a68 1168 printf("C toggle crcOn\r\n");
dudmuck 2:c6b23a43a9d9 1169 printf("op[%%d] get/set output power\r\n");
dudmuck 1:1cd0afbed23c 1170 printf("d[0-5] change DIO pin assignment\r\n");
dudmuck 3:ab386fa756cc 1171 printf("frf[%%f} get/set operating frequency (MHz)\r\n");
dudmuck 1:1cd0afbed23c 1172 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1173 printf("pl[%%d] LORA get/set RegPayloadLength\r\n");
dudmuck 1:1cd0afbed23c 1174 printf("cr[1234] LORA set coding rate \r\n");
dudmuck 2:c6b23a43a9d9 1175 printf("bw[%%d] LORA get/set bandwidth\r\n");
dudmuck 2:c6b23a43a9d9 1176 printf("sf[%%d] LORA get/set spreading factor\r\n");
dudmuck 1:1cd0afbed23c 1177 printf("T LORA toggle TxContinuousMode\r\n");
dudmuck 2:c6b23a43a9d9 1178 printf("hp[%%d] LORA get/set hop period\r\n");
dudmuck 1:1cd0afbed23c 1179 printf("hm LORA toggle explicit/explicit header mode\r\n");
dudmuck 1:1cd0afbed23c 1180 } else {
dudmuck 2:c6b23a43a9d9 1181 printf("bw[a][%%d] FSK get-set rxbw (bwa=afcbw)\r\n");
dudmuck 3:ab386fa756cc 1182 printf("br[%%d] FSK get-set bitrate\r\n");
dudmuck 3:ab386fa756cc 1183 printf("fdev[%%d] FSK get-set TX frequency deviation (hz)\r\n");
dudmuck 2:c6b23a43a9d9 1184 printf("rt FSK change RxTrigger\r\n");
dudmuck 2:c6b23a43a9d9 1185 printf("pd FSK enable/disable preamble detector\r\n");
dudmuck 2:c6b23a43a9d9 1186 printf("pt FSK get-set PreambleDetectorTol\r\n");
dudmuck 2:c6b23a43a9d9 1187 printf("ss[%%d] FSK get-set SyncSize\r\n");
dudmuck 2:c6b23a43a9d9 1188 printf("S[%%x] FSK get-set sync word\r\n");
dudmuck 2:c6b23a43a9d9 1189 printf("s FSK toggle TxStartCondition\r\n");
dudmuck 2:c6b23a43a9d9 1190 printf("f FSK toggle PacketFormat fixed-variable\r\n");
dudmuck 2:c6b23a43a9d9 1191 printf("E FSK empty out the fifo\r\n");
dudmuck 2:c6b23a43a9d9 1192 printf("ac FSK AfcClear\r\n");
dudmuck 2:c6b23a43a9d9 1193 printf("A FSK toggle AfcAutoOn\r\n");
dudmuck 2:c6b23a43a9d9 1194 printf("mp FSK toggle MapPreambleDetect\r\n");
dudmuck 2:c6b23a43a9d9 1195 printf("ar FSK change AutoRestartRxMode\r\n");
dudmuck 2:c6b23a43a9d9 1196 printf("alc FSK toggle AfcAutoClearOn\r\n");
dudmuck 3:ab386fa756cc 1197 printf("pre[%%d} FSK get-set TX preamble length\r\n");
dudmuck 1:1cd0afbed23c 1198 }
dudmuck 0:be215de91a68 1199 break;
dudmuck 0:be215de91a68 1200 case '.':
dudmuck 1:1cd0afbed23c 1201 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1202 lora_print_status();
dudmuck 1:1cd0afbed23c 1203 else
dudmuck 1:1cd0afbed23c 1204 fsk_print_status();
dudmuck 0:be215de91a68 1205 common_print_status();
dudmuck 0:be215de91a68 1206 break;
dudmuck 0:be215de91a68 1207 } // ...switch (pcbuf[0])
dudmuck 0:be215de91a68 1208 } else {
dudmuck 0:be215de91a68 1209 if (pcbuf[0] == 't' && pcbuf[1] == 'x') { // TX
dudmuck 1:1cd0afbed23c 1210 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1211 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1212 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1213 lora.RegPayloadLength = i;
dudmuck 1:1cd0afbed23c 1214 }
dudmuck 1:1cd0afbed23c 1215 tx_cnt++;
dudmuck 1:1cd0afbed23c 1216 for (i = 0; i < lora.RegPayloadLength; i++)
dudmuck 1:1cd0afbed23c 1217 radio.tx_buf[i] = tx_cnt;
dudmuck 1:1cd0afbed23c 1218 lora.start_tx(lora.RegPayloadLength);
dudmuck 2:c6b23a43a9d9 1219 } else { // FSK:
dudmuck 1:1cd0afbed23c 1220 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1221 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1222 fsk_tx_length = i;
dudmuck 1:1cd0afbed23c 1223 }
dudmuck 2:c6b23a43a9d9 1224 if (radio.RegOpMode.bits.Mode != RF_OPMODE_TRANSMITTER) { // if not already busy transmitting
dudmuck 2:c6b23a43a9d9 1225 tx_cnt++;
dudmuck 2:c6b23a43a9d9 1226 for (i = 0; i < fsk_tx_length; i++) {
dudmuck 2:c6b23a43a9d9 1227 radio.tx_buf[i] = tx_cnt;
dudmuck 2:c6b23a43a9d9 1228 }
dudmuck 2:c6b23a43a9d9 1229 fsk.start_tx(fsk_tx_length);
dudmuck 2:c6b23a43a9d9 1230 }
dudmuck 0:be215de91a68 1231 }
dudmuck 1:1cd0afbed23c 1232 } else if (pcbuf[0] == 'h' && pcbuf[1] == 'p' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1233 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1234 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1235 lora.RegHopPeriod = i;
dudmuck 1:1cd0afbed23c 1236 radio.write_reg(REG_LR_HOPPERIOD, lora.RegHopPeriod);
dudmuck 0:be215de91a68 1237 if (radio.RegDioMapping1.bits.Dio1Mapping != 1) {
dudmuck 0:be215de91a68 1238 radio.RegDioMapping1.bits.Dio1Mapping = 1;
dudmuck 0:be215de91a68 1239 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1240 }
dudmuck 0:be215de91a68 1241 }
dudmuck 1:1cd0afbed23c 1242 lora.RegHopPeriod = radio.read_reg(REG_LR_HOPPERIOD);
dudmuck 1:1cd0afbed23c 1243 printf("HopPeriod:0x%02x\r\n", lora.RegHopPeriod);
dudmuck 2:c6b23a43a9d9 1244 } else if (pcbuf[0] == 'r' && pcbuf[1] == 't' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1245 printf("RxTrigger:");
dudmuck 2:c6b23a43a9d9 1246 switch (fsk.RegRxConfig.bits.RxTrigger) {
dudmuck 2:c6b23a43a9d9 1247 case 0: fsk.RegRxConfig.bits.RxTrigger = 1;
dudmuck 2:c6b23a43a9d9 1248 printf("rssi\r\n");
dudmuck 2:c6b23a43a9d9 1249 break;
dudmuck 2:c6b23a43a9d9 1250 case 1: fsk.RegRxConfig.bits.RxTrigger = 6;
dudmuck 2:c6b23a43a9d9 1251 printf("preamble\r\n");
dudmuck 2:c6b23a43a9d9 1252 break;
dudmuck 2:c6b23a43a9d9 1253 case 6: fsk.RegRxConfig.bits.RxTrigger = 7;
dudmuck 2:c6b23a43a9d9 1254 printf("both\r\n");
dudmuck 2:c6b23a43a9d9 1255 break;
dudmuck 2:c6b23a43a9d9 1256 case 7: fsk.RegRxConfig.bits.RxTrigger = 0;
dudmuck 2:c6b23a43a9d9 1257 printf("none\r\n");
dudmuck 2:c6b23a43a9d9 1258 break;
dudmuck 2:c6b23a43a9d9 1259 default: fsk.RegRxConfig.bits.RxTrigger = 0;
dudmuck 2:c6b23a43a9d9 1260 printf("none\r\n");
dudmuck 2:c6b23a43a9d9 1261 break;
dudmuck 2:c6b23a43a9d9 1262 }
dudmuck 2:c6b23a43a9d9 1263 radio.write_reg(REG_FSK_RXCONFIG, fsk.RegRxConfig.octet);
dudmuck 0:be215de91a68 1264 } else if (pcbuf[0] == 'r' && pcbuf[1] == 'x') { // RX
dudmuck 2:c6b23a43a9d9 1265 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 2:c6b23a43a9d9 1266 lora.start_rx();
dudmuck 2:c6b23a43a9d9 1267 else
dudmuck 2:c6b23a43a9d9 1268 fsk.start_rx();
dudmuck 0:be215de91a68 1269 } else if (pcbuf[0] == 'r' && pcbuf[1] == ' ') { // read single register
dudmuck 0:be215de91a68 1270 sscanf(pcbuf+2, "%x", &i);
dudmuck 0:be215de91a68 1271 printf("%02x: %02x\r\n", i, radio.read_reg(i));
dudmuck 0:be215de91a68 1272 } else if (pcbuf[0] == 'w' && pcbuf[1] == ' ') { // write single register
dudmuck 0:be215de91a68 1273 sscanf(pcbuf+2, "%x %x", &i, &len);
dudmuck 0:be215de91a68 1274 radio.write_reg(i, len);
dudmuck 0:be215de91a68 1275 printf("%02x: %02x\r\n", i, radio.read_reg(i));
dudmuck 2:c6b23a43a9d9 1276 } else if (pcbuf[0] == 'm' && pcbuf[1] == 'p' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1277 radio.RegDioMapping2.bits.MapPreambleDetect ^= 1;
dudmuck 2:c6b23a43a9d9 1278 radio.write_reg(REG_DIOMAPPING2, radio.RegDioMapping2.octet);
dudmuck 2:c6b23a43a9d9 1279 printf("MapPreambleDetect:");
dudmuck 2:c6b23a43a9d9 1280 if (radio.RegDioMapping2.bits.MapPreambleDetect)
dudmuck 2:c6b23a43a9d9 1281 printf("preamble\r\n");
dudmuck 2:c6b23a43a9d9 1282 else
dudmuck 2:c6b23a43a9d9 1283 printf("rssi\r\n");
dudmuck 0:be215de91a68 1284 } else if (pcbuf[0] == 'o' && pcbuf[1] == 'p') {
dudmuck 0:be215de91a68 1285 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1286 sscanf(pcbuf+2, "%d", &i);
dudmuck 0:be215de91a68 1287 radio.RegPaConfig.bits.OutputPower = i;
dudmuck 0:be215de91a68 1288 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:be215de91a68 1289 }
dudmuck 0:be215de91a68 1290 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:be215de91a68 1291 printf("OutputPower:%d\r\n", radio.RegPaConfig.bits.OutputPower);
dudmuck 1:1cd0afbed23c 1292 } else if (pcbuf[0] == 'c' && pcbuf[1] == 'r' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1293 if (pcbuf[2] >= '0' && pcbuf[2] <= '9')
dudmuck 1:1cd0afbed23c 1294 lora.setCodingRate(pcbuf[2] - '0');
dudmuck 1:1cd0afbed23c 1295 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1296 lora_printCodingRate(false); // false: transmitted
dudmuck 0:be215de91a68 1297 printf("\r\n");
dudmuck 1:1cd0afbed23c 1298 } else if (pcbuf[0] == 'h' && pcbuf[1] == 'm' && radio.RegOpMode.bits.LongRangeMode) { // toggle implicit/explicit
dudmuck 1:1cd0afbed23c 1299 lora.setHeaderMode(!lora.getHeaderMode());
dudmuck 1:1cd0afbed23c 1300 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1301 lora_printHeaderMode();
dudmuck 0:be215de91a68 1302 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1303 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'l' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1304 fsk.RegAfcFei.bits.AfcAutoClearOn ^= 1;
dudmuck 2:c6b23a43a9d9 1305 printf("AfcAutoClearOn: ");
dudmuck 2:c6b23a43a9d9 1306 radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
dudmuck 2:c6b23a43a9d9 1307 if (fsk.RegAfcFei.bits.AfcAutoClearOn)
dudmuck 2:c6b23a43a9d9 1308 printf("ON\r\n");
dudmuck 2:c6b23a43a9d9 1309 else
dudmuck 2:c6b23a43a9d9 1310 printf("off\r\n");
dudmuck 2:c6b23a43a9d9 1311 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'r' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1312 fsk.RegSyncConfig.bits.AutoRestartRxMode++;
dudmuck 2:c6b23a43a9d9 1313 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1314 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1315 printf("AutoRestartRxMode:");
dudmuck 2:c6b23a43a9d9 1316 switch (fsk.RegSyncConfig.bits.AutoRestartRxMode) {
dudmuck 2:c6b23a43a9d9 1317 case 0: printf("off "); break;
dudmuck 2:c6b23a43a9d9 1318 case 1: printf("no-pll-wait "); break;
dudmuck 2:c6b23a43a9d9 1319 case 2: printf("pll-wait "); break;
dudmuck 2:c6b23a43a9d9 1320 case 3: printf("3 "); break;
dudmuck 2:c6b23a43a9d9 1321 }
dudmuck 2:c6b23a43a9d9 1322 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1323 } else if (pcbuf[0] == 'a' && pcbuf[1] == 'c' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1324 printf("clear afc: ");
dudmuck 2:c6b23a43a9d9 1325 fsk.RegAfcFei.bits.AfcClear = 1;
dudmuck 2:c6b23a43a9d9 1326 radio.write_reg(REG_FSK_AFCFEI, fsk.RegAfcFei.octet);
dudmuck 2:c6b23a43a9d9 1327 fsk.RegAfcFei.bits.AfcClear = 0;
dudmuck 3:ab386fa756cc 1328 printf("%dHz\r\n", (int)(FREQ_STEP_HZ * radio.read_s16(REG_FSK_AFCMSB)));
dudmuck 3:ab386fa756cc 1329 } else if (pcbuf[0] == 'b' && pcbuf[1] == 'r' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1330 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 3:ab386fa756cc 1331 sscanf(&pcbuf[2], "%d", &i);
dudmuck 3:ab386fa756cc 1332 fsk.set_bitrate(i);
dudmuck 3:ab386fa756cc 1333 }
dudmuck 3:ab386fa756cc 1334 printf("%dbps\r\n", fsk.get_bitrate());
dudmuck 0:be215de91a68 1335 } else if (pcbuf[0] == 'b' && pcbuf[1] == 'w') {
dudmuck 1:1cd0afbed23c 1336 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 1:1cd0afbed23c 1337 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 1:1cd0afbed23c 1338 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1339 sscanf(&pcbuf[2], "%d", &i);
dudmuck 1:1cd0afbed23c 1340 lora.setBw(i);
dudmuck 1:1cd0afbed23c 1341 } else
dudmuck 1:1cd0afbed23c 1342 lora_printAllBw();
dudmuck 1:1cd0afbed23c 1343 lora.RegModemConfig.octet = radio.read_reg(REG_LR_MODEMCONFIG);
dudmuck 1:1cd0afbed23c 1344 printf("current ");
dudmuck 1:1cd0afbed23c 1345 lora_printBw();
dudmuck 1:1cd0afbed23c 1346 printf("\r\n");
dudmuck 1:1cd0afbed23c 1347 } else { // FSK:
dudmuck 1:1cd0afbed23c 1348 if (pcbuf[2] == 'a') {
dudmuck 1:1cd0afbed23c 1349 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 1:1cd0afbed23c 1350 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1351 sscanf(&pcbuf[3], "%d", &i);
dudmuck 1:1cd0afbed23c 1352 fsk.set_rx_dcc_bw_hz(i, 1);
dudmuck 1:1cd0afbed23c 1353 }
dudmuck 1:1cd0afbed23c 1354 printf("afcbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_AFCBW));
dudmuck 1:1cd0afbed23c 1355 } else {
dudmuck 1:1cd0afbed23c 1356 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 1:1cd0afbed23c 1357 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 1:1cd0afbed23c 1358 sscanf(&pcbuf[2], "%d", &i);
dudmuck 1:1cd0afbed23c 1359 fsk.set_rx_dcc_bw_hz(i, 0);
dudmuck 1:1cd0afbed23c 1360 }
dudmuck 1:1cd0afbed23c 1361 printf("rxbw:%dHz\r\n", fsk.get_rx_bw_hz(REG_FSK_RXBW));
dudmuck 1:1cd0afbed23c 1362 }
dudmuck 1:1cd0afbed23c 1363 }
dudmuck 0:be215de91a68 1364 } else if (pcbuf[0] == 'v' && pcbuf[1] == 'h') {
dudmuck 1:1cd0afbed23c 1365 lora.poll_vh ^= 1;
dudmuck 1:1cd0afbed23c 1366 printf("poll_vh:%d\r\n", lora.poll_vh);
dudmuck 2:c6b23a43a9d9 1367 } else if (pcbuf[0] == 'S' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1368 if (pcbuf[1] == '0') {
dudmuck 2:c6b23a43a9d9 1369 sscanf(pcbuf+1, "%x", &ui);
dudmuck 2:c6b23a43a9d9 1370 if (ui < 0x100) {
dudmuck 2:c6b23a43a9d9 1371 fsk.RegSyncConfig.bits.SyncSize = 0;
dudmuck 2:c6b23a43a9d9 1372 radio.write_reg(REG_FSK_SYNCVALUE1, ui);
dudmuck 2:c6b23a43a9d9 1373 } else if (ui < 0x10000) {
dudmuck 2:c6b23a43a9d9 1374 fsk.RegSyncConfig.bits.SyncSize = 1;
dudmuck 3:ab386fa756cc 1375 radio.write_reg(REG_FSK_SYNCVALUE2, ui & 0xff);
dudmuck 3:ab386fa756cc 1376 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 8);
dudmuck 2:c6b23a43a9d9 1377 } else if (ui < 0x1000000) {
dudmuck 2:c6b23a43a9d9 1378 fsk.RegSyncConfig.bits.SyncSize = 2;
dudmuck 3:ab386fa756cc 1379 radio.write_reg(REG_FSK_SYNCVALUE3, ui & 0xff);
dudmuck 2:c6b23a43a9d9 1380 radio.write_reg(REG_FSK_SYNCVALUE2, (ui >> 8) & 0xff);
dudmuck 3:ab386fa756cc 1381 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 16);
dudmuck 2:c6b23a43a9d9 1382 } else {
dudmuck 2:c6b23a43a9d9 1383 fsk.RegSyncConfig.bits.SyncSize = 3;
dudmuck 3:ab386fa756cc 1384 radio.write_reg(REG_FSK_SYNCVALUE4, ui & 0xff);
dudmuck 3:ab386fa756cc 1385 radio.write_reg(REG_FSK_SYNCVALUE3, (ui >> 8) & 0xff);
dudmuck 3:ab386fa756cc 1386 radio.write_reg(REG_FSK_SYNCVALUE2, (ui >> 16) & 0xff);
dudmuck 3:ab386fa756cc 1387 radio.write_reg(REG_FSK_SYNCVALUE1, ui >> 24);
dudmuck 2:c6b23a43a9d9 1388 }
dudmuck 2:c6b23a43a9d9 1389 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1390 }
dudmuck 2:c6b23a43a9d9 1391 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1392 printf("%d: ", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 2:c6b23a43a9d9 1393 for (i = 0; i <= fsk.RegSyncConfig.bits.SyncSize; i++)
dudmuck 2:c6b23a43a9d9 1394 printf("%02x ", radio.read_reg(REG_FSK_SYNCVALUE1+i));
dudmuck 2:c6b23a43a9d9 1395 printf("\r\n");
dudmuck 2:c6b23a43a9d9 1396 } else if (pcbuf[0] == 's' && pcbuf[1] == 's' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1397 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1398 sscanf(pcbuf+2, "%d", &i);
dudmuck 2:c6b23a43a9d9 1399 fsk.RegSyncConfig.bits.SyncSize = i;
dudmuck 2:c6b23a43a9d9 1400 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 2:c6b23a43a9d9 1401 }
dudmuck 2:c6b23a43a9d9 1402 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 2:c6b23a43a9d9 1403 printf("SyncSize:%d\r\n", fsk.RegSyncConfig.bits.SyncSize);
dudmuck 1:1cd0afbed23c 1404 } else if (pcbuf[0] == 's' && pcbuf[1] == 'f' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1405 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1406 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1407 lora.setSf(i);
dudmuck 1:1cd0afbed23c 1408 if (i == 6 && !lora.getHeaderMode()) {
dudmuck 0:be215de91a68 1409 printf("SF6: to implicit header mode\r\n");
dudmuck 1:1cd0afbed23c 1410 lora.setHeaderMode(true);
dudmuck 0:be215de91a68 1411 }
dudmuck 0:be215de91a68 1412 }
dudmuck 1:1cd0afbed23c 1413 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 1:1cd0afbed23c 1414 lora_printSf();
dudmuck 0:be215de91a68 1415 printf("\r\n");
dudmuck 3:ab386fa756cc 1416 } else if (pcbuf[0] == 'f' && pcbuf[1] == 'd' && pcbuf[2] == 'e' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 3:ab386fa756cc 1417 if (pcbuf[4] >= '0' && pcbuf[4] <= '9') {
dudmuck 3:ab386fa756cc 1418 sscanf(pcbuf+4, "%d", &i);
dudmuck 3:ab386fa756cc 1419 fsk.set_tx_fdev_hz(i);
dudmuck 3:ab386fa756cc 1420 }
dudmuck 3:ab386fa756cc 1421 printf("fdev:%dHz\r\n", fsk.get_tx_fdev_hz());
dudmuck 0:be215de91a68 1422 } else if (pcbuf[0] == 'f' && pcbuf[1] == 'r' && pcbuf[2] == 'f') {
dudmuck 0:be215de91a68 1423 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 0:be215de91a68 1424 float MHz;
dudmuck 0:be215de91a68 1425 sscanf(pcbuf+3, "%f", &MHz);
dudmuck 0:be215de91a68 1426 //printf("MHz:%f\r\n", MHz);
dudmuck 0:be215de91a68 1427 radio.set_frf_MHz(MHz);
dudmuck 3:ab386fa756cc 1428 }
dudmuck 3:ab386fa756cc 1429 printf("%fMHz\r\n", radio.get_frf_MHz());
dudmuck 4:7a9007dfc0e5 1430 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'r' && pcbuf[2] == 'e') {
dudmuck 4:7a9007dfc0e5 1431 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 4:7a9007dfc0e5 1432 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 4:7a9007dfc0e5 1433 sscanf(pcbuf+3, "%d", &i);
dudmuck 4:7a9007dfc0e5 1434 radio.write_u16(REG_LR_PREAMBLEMSB, i);
dudmuck 4:7a9007dfc0e5 1435 }
dudmuck 4:7a9007dfc0e5 1436 lora.RegPreamble = radio.read_u16(REG_LR_PREAMBLEMSB);
dudmuck 4:7a9007dfc0e5 1437 printf("lora PreambleLength:%d\r\n", lora.RegPreamble);
dudmuck 4:7a9007dfc0e5 1438 } else {
dudmuck 4:7a9007dfc0e5 1439 if (pcbuf[3] >= '0' && pcbuf[3] <= '9') {
dudmuck 4:7a9007dfc0e5 1440 sscanf(pcbuf+3, "%d", &i);
dudmuck 4:7a9007dfc0e5 1441 radio.write_u16(REG_FSK_PREAMBLEMSB, i);
dudmuck 4:7a9007dfc0e5 1442 }
dudmuck 4:7a9007dfc0e5 1443 printf("FSK TX PreambleSize:%d\r\n", radio.read_u16(REG_FSK_PREAMBLEMSB));
dudmuck 3:ab386fa756cc 1444 }
dudmuck 2:c6b23a43a9d9 1445 } else if (pcbuf[0] == 'p' && pcbuf[1] == 't' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1446 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 2:c6b23a43a9d9 1447 sscanf(pcbuf+2, "%d", &i);
dudmuck 2:c6b23a43a9d9 1448 fsk.RegPreambleDetect.bits.PreambleDetectorTol = i;
dudmuck 2:c6b23a43a9d9 1449 radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
dudmuck 2:c6b23a43a9d9 1450 }
dudmuck 2:c6b23a43a9d9 1451 fsk.RegPreambleDetect.octet = radio.read_reg(REG_FSK_PREAMBLEDETECT);
dudmuck 2:c6b23a43a9d9 1452 printf("PreambleDetectorTol:%d\r\n", fsk.RegPreambleDetect.bits.PreambleDetectorTol);
dudmuck 2:c6b23a43a9d9 1453 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'd' && !radio.RegOpMode.bits.LongRangeMode) {
dudmuck 2:c6b23a43a9d9 1454 fsk.RegPreambleDetect.bits.PreambleDetectorOn ^= 1;
dudmuck 2:c6b23a43a9d9 1455 radio.write_reg(REG_FSK_PREAMBLEDETECT, fsk.RegPreambleDetect.octet);
dudmuck 2:c6b23a43a9d9 1456 printf("PreambleDetector:");
dudmuck 2:c6b23a43a9d9 1457 if (fsk.RegPreambleDetect.bits.PreambleDetectorOn)
dudmuck 2:c6b23a43a9d9 1458 printf("On\r\n");
dudmuck 2:c6b23a43a9d9 1459 else
dudmuck 2:c6b23a43a9d9 1460 printf("OFF\r\n");
dudmuck 1:1cd0afbed23c 1461 } else if (pcbuf[0] == 'p' && pcbuf[1] == 'l' && radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:be215de91a68 1462 if (pcbuf[2] >= '0' && pcbuf[2] <= '9') {
dudmuck 0:be215de91a68 1463 sscanf(pcbuf+2, "%d", &i);
dudmuck 1:1cd0afbed23c 1464 lora.RegPayloadLength = i;
dudmuck 1:1cd0afbed23c 1465 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 0:be215de91a68 1466 }
dudmuck 1:1cd0afbed23c 1467 lora.RegPayloadLength = radio.read_reg(REG_LR_PAYLOADLENGTH);
dudmuck 1:1cd0afbed23c 1468 printf("PayloadLength:%d\r\n", lora.RegPayloadLength);
dudmuck 0:be215de91a68 1469 } else if (pcbuf[0] == 'd' && pcbuf[1] >= '0' && pcbuf[1] <= '5') {
dudmuck 0:be215de91a68 1470 switch (pcbuf[1]) {
dudmuck 0:be215de91a68 1471 case '0':
dudmuck 0:be215de91a68 1472 radio.RegDioMapping1.bits.Dio0Mapping++;
dudmuck 0:be215de91a68 1473 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1474 break;
dudmuck 0:be215de91a68 1475 case '1':
dudmuck 0:be215de91a68 1476 radio.RegDioMapping1.bits.Dio1Mapping++;
dudmuck 0:be215de91a68 1477 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1478 break;
dudmuck 0:be215de91a68 1479 case '2':
dudmuck 0:be215de91a68 1480 radio.RegDioMapping1.bits.Dio2Mapping++;
dudmuck 0:be215de91a68 1481 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1482 break;
dudmuck 0:be215de91a68 1483 case '3':
dudmuck 0:be215de91a68 1484 radio.RegDioMapping1.bits.Dio3Mapping++;
dudmuck 0:be215de91a68 1485 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping1.octet);
dudmuck 0:be215de91a68 1486 break;
dudmuck 0:be215de91a68 1487 case '4':
dudmuck 0:be215de91a68 1488 radio.RegDioMapping2.bits.Dio4Mapping++;
dudmuck 0:be215de91a68 1489 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping2.octet);
dudmuck 0:be215de91a68 1490 break;
dudmuck 0:be215de91a68 1491 case '5':
dudmuck 0:be215de91a68 1492 radio.RegDioMapping2.bits.Dio5Mapping++;
dudmuck 0:be215de91a68 1493 radio.write_reg(REG_DIOMAPPING1, radio.RegDioMapping2.octet);
dudmuck 0:be215de91a68 1494 break;
dudmuck 0:be215de91a68 1495 } // ...switch (pcbuf[1])
dudmuck 1:1cd0afbed23c 1496 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 1:1cd0afbed23c 1497 lora_print_dio();
dudmuck 1:1cd0afbed23c 1498 else
dudmuck 1:1cd0afbed23c 1499 fsk_print_dio();
dudmuck 0:be215de91a68 1500 } else if (pcbuf[0] == 's' && pcbuf[1] == 't' && pcbuf[2] == 'b') {
dudmuck 0:be215de91a68 1501 radio.set_opmode(RF_OPMODE_STANDBY);
dudmuck 0:be215de91a68 1502 } else if (pcbuf[0] == 's' && pcbuf[1] == 'l' && pcbuf[2] == 'e') {
dudmuck 0:be215de91a68 1503 radio.set_opmode(RF_OPMODE_SLEEP);
dudmuck 0:be215de91a68 1504 } else if (pcbuf[0] == 'c' && pcbuf[1] == 'h' && pcbuf[2] == 'a') {
dudmuck 0:be215de91a68 1505 app = APP_CHAT;
dudmuck 1:1cd0afbed23c 1506 lora.start_rx();
dudmuck 0:be215de91a68 1507 printf("chat start\r\n");
dudmuck 0:be215de91a68 1508 }
dudmuck 0:be215de91a68 1509 }
dudmuck 0:be215de91a68 1510 printf("> ");
dudmuck 0:be215de91a68 1511 fflush(stdout);
dudmuck 0:be215de91a68 1512
dudmuck 0:be215de91a68 1513 }
dudmuck 0:be215de91a68 1514
dudmuck 0:be215de91a68 1515 int main()
dudmuck 0:be215de91a68 1516 {
dudmuck 0:be215de91a68 1517
dudmuck 0:be215de91a68 1518 pc.baud(57600);
dudmuck 0:be215de91a68 1519
dudmuck 0:be215de91a68 1520 radio.frfs = frfs;
dudmuck 0:be215de91a68 1521
dudmuck 0:be215de91a68 1522 while(1) {
dudmuck 0:be215de91a68 1523 switch (app) {
dudmuck 0:be215de91a68 1524 case APP_NONE:
dudmuck 0:be215de91a68 1525 console();
dudmuck 0:be215de91a68 1526 break;
dudmuck 0:be215de91a68 1527 case APP_CHAT:
dudmuck 0:be215de91a68 1528 console_chat();
dudmuck 0:be215de91a68 1529 break;
dudmuck 0:be215de91a68 1530 } // ...switch (app)
dudmuck 0:be215de91a68 1531 } // ...while(1)
dudmuck 0:be215de91a68 1532 }
dudmuck 0:be215de91a68 1533