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:
Wed May 13 20:57:14 2015 +0000
Revision:
5:360069ec9953
Parent:
4:7a9007dfc0e5
Child:
6:fe16f96ee335
correct error in chat function

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