UART console application for testing SX1272/SX1276

Dependencies:   SX127x

/media/uploads/dudmuck/lora.png

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

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

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

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

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

Using with SX1276MB1xAS Shield

This component plugs into any board with arduino uno headers.

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


Using with your own production board

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

Transmitter Test Guidelines

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

commands used for transmitter testing:

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

LoRa transmitter testing

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

Receiver Test Guidelines

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

commands used for receiver testing:

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

Full command list

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

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

command list: common commands (both LoRa and FSK)

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

command list: LoRa modem commands

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

command list: FSK modem commands

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

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