Semtech / Mbed 2 deprecated scpi_sx127x

SCPI interface to SX1272 and SX1276

Dependencies:   SX127x lib_gps lib_mma8451q lib_mpl3115a2 lib_sx9500 libscpi mbed

Description

This program implements a SCPI command parser. When connected via the debug virtual comm port, you can command the radio and peripherals to perform specific tasks or to set specific parameters. The serial port defaults to 9600bps N-8-1.

Example

The following exampling causes the NA Mote to transmit a continuous LoRa signal.

Example SCPI Commands

*IDN?
RA:MOD LORA
RA:FREQ 903
RA:PAS PA_BOOST
RA:OCP 170
RA:BGR 7
RA:POW 15
RA:LORA:TXContinuous ON
RA:FI "test"

Commands

SCPI is case-insensitive. Commands can be entered lower case.

  • RAdio
    • :FIfo "text" write to fifo, and transmit packet
    • :FIfo? read from fifo (last received packet)
    • :REGister { address }, {value} write radio register (SCPI takes #H for hex prefix)
    • :REGister? { address } read radio register (SCPI takes #H for hex prefix)
    • :MODulation { FSK | OOK | LORa } set modem type
    • :MODulation? get modem type
    • :OPmode { SLE | STB | FST | TX | FSR | RXC | RXS | CAD } set mode
    • :OPmode? get mode
    • :DIOMap { 0 - 5 }, { 0 - 3 } set DIO pin function {pin number}, {map value}
    • :DIOMap? { 0 - 5 } get DIO pin function {pin number}
    • :DIO? { 0 - 5 } read DIO pin level
    • :RSSI? read received signal strength (if in RXC mode)
    • :PASelect { RFO | PA_BOOST } set RF output pin
    • :PASelect? get RF output pin selected
    • :OCP {mA} set over current protection
    • :OCP? read current limit
    • :POWer {0 to 15} set OutputPower
    • :POWer? get OutputPower
    • :BGR { 0 - 7 } set PA ref current
    • :BGR? get PA ref current
    • :FREQuency {MHz} set FRF
    • :FREQuency? get FRF
    • :LNABoost { OFF | ON } set LNA boost
    • :LNABoost? get LNA boost
    • :LORa
      • :BW {KHz} set lora bandwidth
      • :BW? get lora bandwidth (in KHz)
      • :SF {7 to 12} set spreading factor
      • :SF? get spreading factor
      • :TXContinuous { OFF | ON } set continuous TX (end transmit by turning off)
      • :TXContinuous? get continuous TX
      • :PRELen {n-symbols} set preamble length
      • :PRELen? get preamble length
      • :CR {0-4} set coding rate
      • :CR? get coding rate
      • :LDRO { OFF | ON } set LowDataRateOptimize bit
      • :LDRO? get LowDataRateOptimize bit
      • :CRC { OFF | ON} enable CRC in transmitted packet
      • :CRC? read CRC enabled state
      • :INVRx { OFF | ON } enable receiver spectral invert
      • :INVRx? get receiver inversion state
      • :INVTx { OFF | ON } enable transmitter spectral invert
      • :INVTx? get transmitter inversion state
      • :FEI? get frequency error of last received packet
      • :PKTSnr? get S/N (dB) of last received packet
    • :FSK
      • :DATAMode { CONT | PKT } select continuous/packet mode
      • :DATAMode? get packet mode / continuous
      • :FDev {Hz} set TX frequency deviation
      • :FDev? get TX frequency deviation
      • :BITRate {bps} set bit rate
      • :BITRate? get bit rate
      • :BT { 1.0 | 0.5 | 0.3 | 0.0 } set transmit shaping
      • :BT? get transmit shaping
      • :PRELen {n} set preamble size
      • :PRELen? get preamble size
      • :RXBW {Hz} set receive bandwidth
      • :RXBW? set receive bandwidth
      • :AFCBW {Hz} set receive bandwidth (during preamble)
      • :AFCBW? set receive bandwidth (during preamble)
      • :DCFree { OFF | MAN | WHIT } set DC-free encoding
      • :DCFree? get DC-free encoding
      • :RXTrigger { OFF | RSSI | PRE | BOTH } set RX trigger mode
      • :RXTrigger? get RX trigger selection

radio events

Radio events are reported into the Questionable Data Status Event Register, which is summarized in Bit 3 (QSB) of Status Byte Register.

enabling event and reading event

RA:MOD?
"LORa"
RA:OP?
"RXC"
STAT:QUES:ENAB 512
*STB?
8
STAT:QUES:EVEN?
512
RA:FI?
"4747474747474747"
*STB?
0

Bit 9 of QUEStionable event register indicates DIO0 event occurred upon radio packet reception.

NA Mote-72 specific commands

  • PD2 { OFF | ON } set power amplifier voltage state
  • PD2? get power amplifier voltage state
  • VBAT? read battery voltage
  • GPS
    • :EN { OFF | ON } enable GPS
    • :EN? get GPS enabled state
    • :NUMCoords {n} set count of coordinates received (use to clear count)
    • :NUMCoords? get count of coordinates received
    • :LOngitude {n} set longitude
    • :LOngitude? get longitude
    • :LAtitude {n} set latitude
    • :LAtitude? get latitude
  • MMA MMA8451Q
    • :ID? read ID register (WHO_AM_I == 0x1a)
  • MPL MPL3115A2
    • :ID? read ID register (WHO_AM_I == 0xc4)
  • SX9500
    • :RST reset SX9500
    • :REGister {addr}, {value} write SX9500 register
    • :REGister? {addr} read SX9500 register

scpi-def.cpp@0:8767be3c1b7f, 2015-08-12 (annotated)

Committer:
dudmuck
Date:
Wed Aug 12 22:20:33 2015 +0000
Revision:
0:8767be3c1b7f
Child:
1:33d322ad66b1
SCPI interface to sx1276/sx1272

Who changed what in which revision?

UserRevisionLine numberNew contents of line
dudmuck 0:8767be3c1b7f 1 #include <stdio.h>
dudmuck 0:8767be3c1b7f 2 #include <stdlib.h>
dudmuck 0:8767be3c1b7f 3 #include <string.h>
dudmuck 0:8767be3c1b7f 4 #include "scpi/scpi.h"
dudmuck 0:8767be3c1b7f 5 #include "scpi-def.h"
dudmuck 0:8767be3c1b7f 6
dudmuck 0:8767be3c1b7f 7 #include "sx127x_lora.h"
dudmuck 0:8767be3c1b7f 8 #include "sx127x_fsk.h"
dudmuck 0:8767be3c1b7f 9
dudmuck 0:8767be3c1b7f 10 /******************************************************************************/
dudmuck 0:8767be3c1b7f 11 #ifdef TARGET_MOTE_L152RC
dudmuck 0:8767be3c1b7f 12
dudmuck 0:8767be3c1b7f 13 #define RFSW1 PC_4 //NorAm_Mote RFSwitch_CNTR_1
dudmuck 0:8767be3c1b7f 14 #define RFSW2 PC_13 //NorAm_Mote RFSwitch_CNTR_2
dudmuck 0:8767be3c1b7f 15 #define RADIO_RESET PC_2 //NorAm_Mote Reset_sx
dudmuck 0:8767be3c1b7f 16 #define RADIO_MOSI PB_15 //NorAm_Mote SPI2 Mosi
dudmuck 0:8767be3c1b7f 17 #define RADIO_MISO PB_14 //NorAm_Mote SPI2 Miso
dudmuck 0:8767be3c1b7f 18 #define RADIO_SCLK PB_13 //NorAm_Mote SPI2 Clk
dudmuck 0:8767be3c1b7f 19 #define RADIO_NSS PB_12 //NorAm_Mote SPI2 Nss
dudmuck 0:8767be3c1b7f 20 #define RADIO_DIO_0 PC_6 //NorAm_Mote DIO0
dudmuck 0:8767be3c1b7f 21 #define RADIO_DIO_1 PC_10 //NorAm_Mote DIO1
dudmuck 0:8767be3c1b7f 22 // mosi, miso, sclk, cs, rst, dio0, dio1
dudmuck 0:8767be3c1b7f 23 SX127x radio(RADIO_MOSI, RADIO_MISO, RADIO_SCLK, RADIO_NSS, RADIO_RESET, RADIO_DIO_0, RADIO_DIO_1);
dudmuck 0:8767be3c1b7f 24
dudmuck 0:8767be3c1b7f 25 DigitalOut rfsw1(RFSW1);
dudmuck 0:8767be3c1b7f 26 DigitalOut rfsw2(RFSW2);
dudmuck 0:8767be3c1b7f 27
dudmuck 0:8767be3c1b7f 28 void rfsw_callback()
dudmuck 0:8767be3c1b7f 29 {
dudmuck 0:8767be3c1b7f 30 if (radio.RegOpMode.bits.Mode == RF_OPMODE_TRANSMITTER) { // start of transmission
dudmuck 0:8767be3c1b7f 31 if (radio.HF) {
dudmuck 0:8767be3c1b7f 32 if (radio.RegPaConfig.bits.PaSelect) { // if PA_BOOST
dudmuck 0:8767be3c1b7f 33 rfsw2 = 0;
dudmuck 0:8767be3c1b7f 34 rfsw1 = 1;
dudmuck 0:8767be3c1b7f 35 } else { // RFO to power amp
dudmuck 0:8767be3c1b7f 36 rfsw2 = 1;
dudmuck 0:8767be3c1b7f 37 rfsw1 = 0;
dudmuck 0:8767be3c1b7f 38 }
dudmuck 0:8767be3c1b7f 39 } else {
dudmuck 0:8767be3c1b7f 40 // todo: sx1276
dudmuck 0:8767be3c1b7f 41 }
dudmuck 0:8767be3c1b7f 42 //hdr_fem_csd = 1; //debug
dudmuck 0:8767be3c1b7f 43 } else if (radio.RegOpMode.bits.Mode == RF_OPMODE_RECEIVER || radio.RegOpMode.bits.Mode == RF_OPMODE_CAD) { // start of reception
dudmuck 0:8767be3c1b7f 44 if (radio.HF) {
dudmuck 0:8767be3c1b7f 45 rfsw2 = 1;
dudmuck 0:8767be3c1b7f 46 rfsw1 = 1;
dudmuck 0:8767be3c1b7f 47 } else {
dudmuck 0:8767be3c1b7f 48 // todo: sx1276
dudmuck 0:8767be3c1b7f 49 }
dudmuck 0:8767be3c1b7f 50 //hdr_fem_csd = 0; //debug
dudmuck 0:8767be3c1b7f 51 } else { // RF switch shutdown
dudmuck 0:8767be3c1b7f 52 rfsw2 = 0;
dudmuck 0:8767be3c1b7f 53 rfsw1 = 0;
dudmuck 0:8767be3c1b7f 54 //hdr_fem_csd = 0; //debug
dudmuck 0:8767be3c1b7f 55 }
dudmuck 0:8767be3c1b7f 56 }
dudmuck 0:8767be3c1b7f 57
dudmuck 0:8767be3c1b7f 58 DigitalOut pd2(PD_2);
dudmuck 0:8767be3c1b7f 59
dudmuck 0:8767be3c1b7f 60 #else // sx1276 shield...
dudmuck 0:8767be3c1b7f 61 // pin: 3 8 1 7 10 12 5
dudmuck 0:8767be3c1b7f 62 // mosi, miso, sclk, cs, rst, dio0, dio1
dudmuck 0:8767be3c1b7f 63 SX127x radio(D11, D12, D13, D10, A0, D2, D3); // sx1276 arduino shield
dudmuck 0:8767be3c1b7f 64
dudmuck 0:8767be3c1b7f 65 #ifdef TARGET_LPC11U6X
dudmuck 0:8767be3c1b7f 66 DigitalOut rfsw(P0_23);
dudmuck 0:8767be3c1b7f 67 #else
dudmuck 0:8767be3c1b7f 68 DigitalOut rfsw(A4); // for SX1276 arduino shield
dudmuck 0:8767be3c1b7f 69 #endif
dudmuck 0:8767be3c1b7f 70
dudmuck 0:8767be3c1b7f 71 void rfsw_callback()
dudmuck 0:8767be3c1b7f 72 {
dudmuck 0:8767be3c1b7f 73 if (radio.RegOpMode.bits.Mode == RF_OPMODE_TRANSMITTER)
dudmuck 0:8767be3c1b7f 74 rfsw = 1;
dudmuck 0:8767be3c1b7f 75 else
dudmuck 0:8767be3c1b7f 76 rfsw = 0;
dudmuck 0:8767be3c1b7f 77 }
dudmuck 0:8767be3c1b7f 78
dudmuck 0:8767be3c1b7f 79 #endif /* !TARGET_MOTE_L152RC */
dudmuck 0:8767be3c1b7f 80
dudmuck 0:8767be3c1b7f 81 SX127x_fsk fsk(radio);
dudmuck 0:8767be3c1b7f 82 SX127x_lora lora(radio);
dudmuck 0:8767be3c1b7f 83
dudmuck 0:8767be3c1b7f 84 volatile bool tx_busy = false;
dudmuck 0:8767be3c1b7f 85
dudmuck 0:8767be3c1b7f 86 void
dudmuck 0:8767be3c1b7f 87 service_radio()
dudmuck 0:8767be3c1b7f 88 {
dudmuck 0:8767be3c1b7f 89 service_action_e act;
dudmuck 0:8767be3c1b7f 90
dudmuck 0:8767be3c1b7f 91 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:8767be3c1b7f 92 act = lora.service();
dudmuck 0:8767be3c1b7f 93 switch (act) {
dudmuck 0:8767be3c1b7f 94 case SERVICE_TX_DONE:
dudmuck 0:8767be3c1b7f 95 tx_busy = false;
dudmuck 0:8767be3c1b7f 96 break;
dudmuck 0:8767be3c1b7f 97 } // ...switch (act)
dudmuck 0:8767be3c1b7f 98 } else {
dudmuck 0:8767be3c1b7f 99 /* FSK: */
dudmuck 0:8767be3c1b7f 100 act = fsk.service();
dudmuck 0:8767be3c1b7f 101 switch (act) {
dudmuck 0:8767be3c1b7f 102 } // ...switch (act)
dudmuck 0:8767be3c1b7f 103 }
dudmuck 0:8767be3c1b7f 104 }
dudmuck 0:8767be3c1b7f 105
dudmuck 0:8767be3c1b7f 106
dudmuck 0:8767be3c1b7f 107 scpi_result_t SCPI_Reset(scpi_t * context)
dudmuck 0:8767be3c1b7f 108 {
dudmuck 0:8767be3c1b7f 109 radio.hw_reset();
dudmuck 0:8767be3c1b7f 110 printf("**Reset\r\n");
dudmuck 0:8767be3c1b7f 111 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 112 }
dudmuck 0:8767be3c1b7f 113
dudmuck 0:8767be3c1b7f 114 const scpi_choice_def_t pa_selects[] = {
dudmuck 0:8767be3c1b7f 115 { "RFO", 0 },
dudmuck 0:8767be3c1b7f 116 { "PA_BOOST", 1 },
dudmuck 0:8767be3c1b7f 117 SCPI_CHOICE_LIST_END
dudmuck 0:8767be3c1b7f 118 };
dudmuck 0:8767be3c1b7f 119
dudmuck 0:8767be3c1b7f 120 scpi_result_t radio_PASelect(scpi_t* context)
dudmuck 0:8767be3c1b7f 121 {
dudmuck 0:8767be3c1b7f 122 int32_t value;
dudmuck 0:8767be3c1b7f 123
dudmuck 0:8767be3c1b7f 124 if (!SCPI_ParamChoice(context, pa_selects, &value, TRUE))
dudmuck 0:8767be3c1b7f 125 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 126
dudmuck 0:8767be3c1b7f 127 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:8767be3c1b7f 128 radio.RegPaConfig.bits.PaSelect = value;
dudmuck 0:8767be3c1b7f 129 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:8767be3c1b7f 130
dudmuck 0:8767be3c1b7f 131 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 132 }
dudmuck 0:8767be3c1b7f 133
dudmuck 0:8767be3c1b7f 134 scpi_result_t radio_PASelectQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 135 {
dudmuck 0:8767be3c1b7f 136 int idx;
dudmuck 0:8767be3c1b7f 137
dudmuck 0:8767be3c1b7f 138 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:8767be3c1b7f 139 idx = radio.RegPaConfig.bits.PaSelect;
dudmuck 0:8767be3c1b7f 140
dudmuck 0:8767be3c1b7f 141 SCPI_ResultText(context, pa_selects[idx].name);
dudmuck 0:8767be3c1b7f 142 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 143 }
dudmuck 0:8767be3c1b7f 144
dudmuck 0:8767be3c1b7f 145 const scpi_choice_def_t modulations[] = {
dudmuck 0:8767be3c1b7f 146 { "FSK", 1 },
dudmuck 0:8767be3c1b7f 147 { "OOK", 2 },
dudmuck 0:8767be3c1b7f 148 { "LORa", 3 },
dudmuck 0:8767be3c1b7f 149 SCPI_CHOICE_LIST_END
dudmuck 0:8767be3c1b7f 150 };
dudmuck 0:8767be3c1b7f 151
dudmuck 0:8767be3c1b7f 152 scpi_result_t radio_modulation(scpi_t* context)
dudmuck 0:8767be3c1b7f 153 {
dudmuck 0:8767be3c1b7f 154 int32_t value;
dudmuck 0:8767be3c1b7f 155
dudmuck 0:8767be3c1b7f 156 /* scpi_bool_t SCPI_ParamChoice(scpi_t * context, const scpi_choice_def_t * options, int32_t * value, scpi_bool_t mandatory); */
dudmuck 0:8767be3c1b7f 157 if (!SCPI_ParamChoice(context, modulations, &value, TRUE))
dudmuck 0:8767be3c1b7f 158 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 159
dudmuck 0:8767be3c1b7f 160 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 161 if (value == 3) {
dudmuck 0:8767be3c1b7f 162 if (!radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 163 lora.enable();
dudmuck 0:8767be3c1b7f 164 } else {
dudmuck 0:8767be3c1b7f 165 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 166 fsk.enable(false);
dudmuck 0:8767be3c1b7f 167 if (radio.RegOpMode.bits.ModulationType) { // radio is OOK
dudmuck 0:8767be3c1b7f 168 if (value == 1) { // change to FSK
dudmuck 0:8767be3c1b7f 169 radio.RegOpMode.bits.ModulationType = 0;
dudmuck 0:8767be3c1b7f 170 radio.write_reg(REG_OPMODE, radio.RegOpMode.octet);
dudmuck 0:8767be3c1b7f 171 }
dudmuck 0:8767be3c1b7f 172 } else { // radio is FSK
dudmuck 0:8767be3c1b7f 173 if (value == 2) { // change to OOK
dudmuck 0:8767be3c1b7f 174 radio.RegOpMode.bits.ModulationType = 1;
dudmuck 0:8767be3c1b7f 175 radio.write_reg(REG_OPMODE, radio.RegOpMode.octet);
dudmuck 0:8767be3c1b7f 176 }
dudmuck 0:8767be3c1b7f 177 }
dudmuck 0:8767be3c1b7f 178 }
dudmuck 0:8767be3c1b7f 179
dudmuck 0:8767be3c1b7f 180 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 181 }
dudmuck 0:8767be3c1b7f 182
dudmuck 0:8767be3c1b7f 183 scpi_result_t radio_modulationQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 184 {
dudmuck 0:8767be3c1b7f 185 int idx;
dudmuck 0:8767be3c1b7f 186
dudmuck 0:8767be3c1b7f 187 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 188 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:8767be3c1b7f 189 idx = 2; // lora
dudmuck 0:8767be3c1b7f 190 } else {
dudmuck 0:8767be3c1b7f 191 if (radio.RegOpMode.bits.ModulationType)
dudmuck 0:8767be3c1b7f 192 idx = 1; // ook
dudmuck 0:8767be3c1b7f 193 else
dudmuck 0:8767be3c1b7f 194 idx = 0; // fsk
dudmuck 0:8767be3c1b7f 195 }
dudmuck 0:8767be3c1b7f 196
dudmuck 0:8767be3c1b7f 197 SCPI_ResultText(context, modulations[idx].name);
dudmuck 0:8767be3c1b7f 198 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 199 }
dudmuck 0:8767be3c1b7f 200
dudmuck 0:8767be3c1b7f 201 scpi_result_t fsk_sync(scpi_t* context)
dudmuck 0:8767be3c1b7f 202 {
dudmuck 0:8767be3c1b7f 203 char buffer[100];
dudmuck 0:8767be3c1b7f 204 size_t copy_len;
dudmuck 0:8767be3c1b7f 205 int len, i;
dudmuck 0:8767be3c1b7f 206 uint8_t addr;
dudmuck 0:8767be3c1b7f 207 uint8_t sync_size;
dudmuck 0:8767be3c1b7f 208
dudmuck 0:8767be3c1b7f 209 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 210 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 211 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 212
dudmuck 0:8767be3c1b7f 213 buffer[0] = 0;
dudmuck 0:8767be3c1b7f 214 SCPI_ParamCopyText(context, buffer, 100, &copy_len, false);
dudmuck 0:8767be3c1b7f 215
dudmuck 0:8767be3c1b7f 216 printf("TEXT: ***%s***\r\n", buffer);
dudmuck 0:8767be3c1b7f 217 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 0:8767be3c1b7f 218 len = strlen(buffer);
dudmuck 0:8767be3c1b7f 219 sync_size = 0;
dudmuck 0:8767be3c1b7f 220 addr = REG_FSK_SYNCVALUE1;
dudmuck 0:8767be3c1b7f 221 printf("len:%d\r\n", len);
dudmuck 0:8767be3c1b7f 222 for (i = 0; i < len; i+=2) {
dudmuck 0:8767be3c1b7f 223 int o;
dudmuck 0:8767be3c1b7f 224 sscanf(buffer+i, "%02x", &o);
dudmuck 0:8767be3c1b7f 225 radio.write_reg(addr++, o);
dudmuck 0:8767be3c1b7f 226 sync_size++;
dudmuck 0:8767be3c1b7f 227 }
dudmuck 0:8767be3c1b7f 228 if (sync_size > 0)
dudmuck 0:8767be3c1b7f 229 fsk.RegSyncConfig.bits.SyncSize = sync_size - 1;
dudmuck 0:8767be3c1b7f 230
dudmuck 0:8767be3c1b7f 231 radio.write_reg(REG_FSK_SYNCCONFIG, fsk.RegSyncConfig.octet);
dudmuck 0:8767be3c1b7f 232
dudmuck 0:8767be3c1b7f 233 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 234 }
dudmuck 0:8767be3c1b7f 235
dudmuck 0:8767be3c1b7f 236 scpi_result_t fsk_syncQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 237 {
dudmuck 0:8767be3c1b7f 238 int i;
dudmuck 0:8767be3c1b7f 239 char txt[64];
dudmuck 0:8767be3c1b7f 240 char *ptr = txt;
dudmuck 0:8767be3c1b7f 241
dudmuck 0:8767be3c1b7f 242 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 243 if (radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 244 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 245
dudmuck 0:8767be3c1b7f 246 fsk.RegSyncConfig.octet = radio.read_reg(REG_FSK_SYNCCONFIG);
dudmuck 0:8767be3c1b7f 247 for (i = 0; i < fsk.RegSyncConfig.bits.SyncSize; i++) {
dudmuck 0:8767be3c1b7f 248 uint8_t o = radio.read_reg(i + REG_FSK_SYNCVALUE1);
dudmuck 0:8767be3c1b7f 249 sprintf(ptr, "%02x", o);
dudmuck 0:8767be3c1b7f 250 ptr += 2;
dudmuck 0:8767be3c1b7f 251 }
dudmuck 0:8767be3c1b7f 252
dudmuck 0:8767be3c1b7f 253 SCPI_ResultText(context, txt);
dudmuck 0:8767be3c1b7f 254 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 255 }
dudmuck 0:8767be3c1b7f 256
dudmuck 0:8767be3c1b7f 257 scpi_result_t radio_rssiQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 258 {
dudmuck 0:8767be3c1b7f 259 int reg_val;
dudmuck 0:8767be3c1b7f 260
dudmuck 0:8767be3c1b7f 261 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 262 if (radio.RegOpMode.bits.Mode != RF_OPMODE_RECEIVER)
dudmuck 0:8767be3c1b7f 263 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 264
dudmuck 0:8767be3c1b7f 265 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:8767be3c1b7f 266 reg_val = radio.read_reg(REG_LR_RSSIVALUE); // 0x1b: dbm = -125 + regvalue
dudmuck 0:8767be3c1b7f 267 SCPI_ResultDouble(context, -125 + reg_val);
dudmuck 0:8767be3c1b7f 268 } else {
dudmuck 0:8767be3c1b7f 269 reg_val = radio.read_reg(REG_FSK_RSSIVALUE); // 0x11: dBm = -regvalue/2
dudmuck 0:8767be3c1b7f 270 SCPI_ResultDouble(context, -reg_val/2.0);
dudmuck 0:8767be3c1b7f 271 }
dudmuck 0:8767be3c1b7f 272
dudmuck 0:8767be3c1b7f 273 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 274 }
dudmuck 0:8767be3c1b7f 275
dudmuck 0:8767be3c1b7f 276 scpi_result_t radio_fifoQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 277 {
dudmuck 0:8767be3c1b7f 278 int i;
dudmuck 0:8767be3c1b7f 279 char txt[520];
dudmuck 0:8767be3c1b7f 280 char *ptr = txt;
dudmuck 0:8767be3c1b7f 281
dudmuck 0:8767be3c1b7f 282 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 283 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:8767be3c1b7f 284 printf("rxnb:%d\r\n", lora.RegRxNbBytes);
dudmuck 0:8767be3c1b7f 285 for (i = 0; i < lora.RegRxNbBytes; i++) {
dudmuck 0:8767be3c1b7f 286 sprintf(ptr, "%02x", radio.rx_buf[i]);
dudmuck 0:8767be3c1b7f 287 printf("%p: %c %c\r\n", ptr, ptr[0], ptr[1]);
dudmuck 0:8767be3c1b7f 288 ptr += 2;
dudmuck 0:8767be3c1b7f 289 }
dudmuck 0:8767be3c1b7f 290 } else {
dudmuck 0:8767be3c1b7f 291 /* fsk todo */
dudmuck 0:8767be3c1b7f 292 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 293 }
dudmuck 0:8767be3c1b7f 294
dudmuck 0:8767be3c1b7f 295 SCPI_ResultText(context, txt);
dudmuck 0:8767be3c1b7f 296 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 297 }
dudmuck 0:8767be3c1b7f 298
dudmuck 0:8767be3c1b7f 299 scpi_result_t radio_fifo(scpi_t* context)
dudmuck 0:8767be3c1b7f 300 {
dudmuck 0:8767be3c1b7f 301 char buffer[100];
dudmuck 0:8767be3c1b7f 302 size_t copy_len, i;
dudmuck 0:8767be3c1b7f 303
dudmuck 0:8767be3c1b7f 304 if (tx_busy)
dudmuck 0:8767be3c1b7f 305 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 306
dudmuck 0:8767be3c1b7f 307 buffer[0] = 0;
dudmuck 0:8767be3c1b7f 308 SCPI_ParamCopyText(context, buffer, 100, &copy_len, false);
dudmuck 0:8767be3c1b7f 309
dudmuck 0:8767be3c1b7f 310 //printf("TEXT: ***%s***\r\n", buffer);
dudmuck 0:8767be3c1b7f 311
dudmuck 0:8767be3c1b7f 312 for (i = 0; i < copy_len; i++)
dudmuck 0:8767be3c1b7f 313 radio.tx_buf[i] = buffer[i];
dudmuck 0:8767be3c1b7f 314
dudmuck 0:8767be3c1b7f 315 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 316 if (radio.RegOpMode.bits.LongRangeMode) {
dudmuck 0:8767be3c1b7f 317 lora.RegPayloadLength = copy_len;
dudmuck 0:8767be3c1b7f 318 radio.write_reg(REG_LR_PAYLOADLENGTH, lora.RegPayloadLength);
dudmuck 0:8767be3c1b7f 319 lora.start_tx(lora.RegPayloadLength);
dudmuck 0:8767be3c1b7f 320 } else {
dudmuck 0:8767be3c1b7f 321 /* fsk todo */
dudmuck 0:8767be3c1b7f 322 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 323 }
dudmuck 0:8767be3c1b7f 324
dudmuck 0:8767be3c1b7f 325 tx_busy = true;
dudmuck 0:8767be3c1b7f 326
dudmuck 0:8767be3c1b7f 327 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 328 }
dudmuck 0:8767be3c1b7f 329
dudmuck 0:8767be3c1b7f 330 const scpi_choice_def_t opmodes[] = {
dudmuck 0:8767be3c1b7f 331 { "SLE", 0 },
dudmuck 0:8767be3c1b7f 332 { "STB", 1 },
dudmuck 0:8767be3c1b7f 333 { "FST", 2 },
dudmuck 0:8767be3c1b7f 334 { "FSR", 3 },
dudmuck 0:8767be3c1b7f 335 { "TX", 4 },
dudmuck 0:8767be3c1b7f 336 { "RXC", 5 },
dudmuck 0:8767be3c1b7f 337 { "RXS", 6 },
dudmuck 0:8767be3c1b7f 338 { "CAD", 7 },
dudmuck 0:8767be3c1b7f 339 SCPI_CHOICE_LIST_END
dudmuck 0:8767be3c1b7f 340 };
dudmuck 0:8767be3c1b7f 341
dudmuck 0:8767be3c1b7f 342 scpi_result_t radio_opmode(scpi_t* context)
dudmuck 0:8767be3c1b7f 343 {
dudmuck 0:8767be3c1b7f 344 int32_t value;
dudmuck 0:8767be3c1b7f 345
dudmuck 0:8767be3c1b7f 346 if (!SCPI_ParamChoice(context, opmodes, &value, TRUE))
dudmuck 0:8767be3c1b7f 347 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 348
dudmuck 0:8767be3c1b7f 349 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 350 radio.RegOpMode.bits.Mode = value;
dudmuck 0:8767be3c1b7f 351 radio.write_reg(REG_OPMODE, radio.RegOpMode.octet);
dudmuck 0:8767be3c1b7f 352
dudmuck 0:8767be3c1b7f 353 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 354 }
dudmuck 0:8767be3c1b7f 355
dudmuck 0:8767be3c1b7f 356 scpi_result_t radio_opmodeQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 357 {
dudmuck 0:8767be3c1b7f 358 int idx;
dudmuck 0:8767be3c1b7f 359
dudmuck 0:8767be3c1b7f 360 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 361 idx = radio.RegOpMode.bits.Mode;
dudmuck 0:8767be3c1b7f 362 SCPI_ResultText(context, opmodes[idx].name);
dudmuck 0:8767be3c1b7f 363
dudmuck 0:8767be3c1b7f 364 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 365 }
dudmuck 0:8767be3c1b7f 366
dudmuck 0:8767be3c1b7f 367
dudmuck 0:8767be3c1b7f 368 /*scpi_result_t wbr_set_bit9(scpi_t* context)
dudmuck 0:8767be3c1b7f 369 {
dudmuck 0:8767be3c1b7f 370 SCPI_RegSetBits(context, SCPI_REG_QUES, 0x200);
dudmuck 0:8767be3c1b7f 371 printf("set bit9\r\n");
dudmuck 0:8767be3c1b7f 372 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 373 }*/
dudmuck 0:8767be3c1b7f 374 scpi_result_t radio_ocp(scpi_t* context)
dudmuck 0:8767be3c1b7f 375 {
dudmuck 0:8767be3c1b7f 376 int32_t i;
dudmuck 0:8767be3c1b7f 377
dudmuck 0:8767be3c1b7f 378 if (!SCPI_ParamInt(context, &i, TRUE))
dudmuck 0:8767be3c1b7f 379 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 380
dudmuck 0:8767be3c1b7f 381 radio.RegOcp.octet = radio.read_reg(REG_OCP);
dudmuck 0:8767be3c1b7f 382 if (i < 130)
dudmuck 0:8767be3c1b7f 383 radio.RegOcp.bits.OcpTrim = (i - 45) / 5;
dudmuck 0:8767be3c1b7f 384 else
dudmuck 0:8767be3c1b7f 385 radio.RegOcp.bits.OcpTrim = (i + 30) / 10;
dudmuck 0:8767be3c1b7f 386 radio.write_reg(REG_OCP, radio.RegOcp.octet);
dudmuck 0:8767be3c1b7f 387 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 388 }
dudmuck 0:8767be3c1b7f 389
dudmuck 0:8767be3c1b7f 390 scpi_result_t radio_ocpQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 391 {
dudmuck 0:8767be3c1b7f 392 int32_t i;
dudmuck 0:8767be3c1b7f 393
dudmuck 0:8767be3c1b7f 394 radio.RegOcp.octet = radio.read_reg(REG_OCP);
dudmuck 0:8767be3c1b7f 395
dudmuck 0:8767be3c1b7f 396 if (radio.RegOcp.bits.OcpTrim < 16)
dudmuck 0:8767be3c1b7f 397 i = 45 + (5 * radio.RegOcp.bits.OcpTrim);
dudmuck 0:8767be3c1b7f 398 else if (radio.RegOcp.bits.OcpTrim < 28)
dudmuck 0:8767be3c1b7f 399 i = (10 * radio.RegOcp.bits.OcpTrim) - 30;
dudmuck 0:8767be3c1b7f 400 else
dudmuck 0:8767be3c1b7f 401 i = 240;
dudmuck 0:8767be3c1b7f 402
dudmuck 0:8767be3c1b7f 403 SCPI_ResultInt(context, i);
dudmuck 0:8767be3c1b7f 404 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 405 }
dudmuck 0:8767be3c1b7f 406
dudmuck 0:8767be3c1b7f 407 scpi_result_t radio_power(scpi_t* context)
dudmuck 0:8767be3c1b7f 408 {
dudmuck 0:8767be3c1b7f 409 int32_t i;
dudmuck 0:8767be3c1b7f 410
dudmuck 0:8767be3c1b7f 411 if (!SCPI_ParamInt(context, &i, TRUE))
dudmuck 0:8767be3c1b7f 412 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 413
dudmuck 0:8767be3c1b7f 414 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:8767be3c1b7f 415 radio.RegPaConfig.bits.OutputPower = i;
dudmuck 0:8767be3c1b7f 416 radio.write_reg(REG_PACONFIG, radio.RegPaConfig.octet);
dudmuck 0:8767be3c1b7f 417
dudmuck 0:8767be3c1b7f 418 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 419 }
dudmuck 0:8767be3c1b7f 420
dudmuck 0:8767be3c1b7f 421 scpi_result_t radio_powerQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 422 {
dudmuck 0:8767be3c1b7f 423 radio.RegPaConfig.octet = radio.read_reg(REG_PACONFIG);
dudmuck 0:8767be3c1b7f 424 SCPI_ResultInt(context, radio.RegPaConfig.bits.OutputPower);
dudmuck 0:8767be3c1b7f 425 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 426 }
dudmuck 0:8767be3c1b7f 427
dudmuck 0:8767be3c1b7f 428 scpi_result_t radio_freq(scpi_t* context)
dudmuck 0:8767be3c1b7f 429 {
dudmuck 0:8767be3c1b7f 430 double MHz;
dudmuck 0:8767be3c1b7f 431
dudmuck 0:8767be3c1b7f 432 if (!SCPI_ParamDouble(context, &MHz, TRUE))
dudmuck 0:8767be3c1b7f 433 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 434
dudmuck 0:8767be3c1b7f 435 radio.set_frf_MHz(MHz);
dudmuck 0:8767be3c1b7f 436
dudmuck 0:8767be3c1b7f 437 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 438 }
dudmuck 0:8767be3c1b7f 439
dudmuck 0:8767be3c1b7f 440 scpi_result_t radio_freqQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 441 {
dudmuck 0:8767be3c1b7f 442 SCPI_ResultDouble(context, radio.get_frf_MHz());
dudmuck 0:8767be3c1b7f 443 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 444 }
dudmuck 0:8767be3c1b7f 445
dudmuck 0:8767be3c1b7f 446 scpi_result_t lora_bw(scpi_t* context)
dudmuck 0:8767be3c1b7f 447 {
dudmuck 0:8767be3c1b7f 448 double KHz;
dudmuck 0:8767be3c1b7f 449
dudmuck 0:8767be3c1b7f 450 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 451 if (!radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 452 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 453
dudmuck 0:8767be3c1b7f 454 if (!SCPI_ParamDouble(context, &KHz, TRUE))
dudmuck 0:8767be3c1b7f 455 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 456
dudmuck 0:8767be3c1b7f 457 lora.setBw_KHz(KHz);
dudmuck 0:8767be3c1b7f 458 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 459 }
dudmuck 0:8767be3c1b7f 460
dudmuck 0:8767be3c1b7f 461 scpi_result_t lora_bwQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 462 {
dudmuck 0:8767be3c1b7f 463 int bw;
dudmuck 0:8767be3c1b7f 464 double khz;
dudmuck 0:8767be3c1b7f 465
dudmuck 0:8767be3c1b7f 466 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 467 if (!radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 468 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 469
dudmuck 0:8767be3c1b7f 470 bw = lora.getBw();
dudmuck 0:8767be3c1b7f 471
dudmuck 0:8767be3c1b7f 472 if (radio.type == SX1272) {
dudmuck 0:8767be3c1b7f 473 switch (bw) {
dudmuck 0:8767be3c1b7f 474 case 0: khz = 125; break;
dudmuck 0:8767be3c1b7f 475 case 1: khz = 250; break;
dudmuck 0:8767be3c1b7f 476 case 2: khz = 500; break;
dudmuck 0:8767be3c1b7f 477 }
dudmuck 0:8767be3c1b7f 478 } else if (radio.type == SX1276) {
dudmuck 0:8767be3c1b7f 479 switch (bw) {
dudmuck 0:8767be3c1b7f 480 case 0: khz = 7.8; break;
dudmuck 0:8767be3c1b7f 481 case 1: khz = 10.4; break;
dudmuck 0:8767be3c1b7f 482 case 2: khz = 15.6; break;
dudmuck 0:8767be3c1b7f 483 case 3: khz = 20.8; break;
dudmuck 0:8767be3c1b7f 484 case 4: khz = 31.25; break;
dudmuck 0:8767be3c1b7f 485 case 5: khz = 41.7; break;
dudmuck 0:8767be3c1b7f 486 case 6: khz = 62.5; break;
dudmuck 0:8767be3c1b7f 487 case 7: khz = 125; break;
dudmuck 0:8767be3c1b7f 488 case 8: khz = 250; break;
dudmuck 0:8767be3c1b7f 489 case 9: khz = 500; break;
dudmuck 0:8767be3c1b7f 490 }
dudmuck 0:8767be3c1b7f 491 }
dudmuck 0:8767be3c1b7f 492
dudmuck 0:8767be3c1b7f 493 SCPI_ResultDouble(context, khz);
dudmuck 0:8767be3c1b7f 494 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 495 }
dudmuck 0:8767be3c1b7f 496
dudmuck 0:8767be3c1b7f 497 scpi_result_t lora_sf(scpi_t* context)
dudmuck 0:8767be3c1b7f 498 {
dudmuck 0:8767be3c1b7f 499 int32_t i;
dudmuck 0:8767be3c1b7f 500
dudmuck 0:8767be3c1b7f 501 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 502 if (!radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 503 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 504
dudmuck 0:8767be3c1b7f 505 if (!SCPI_ParamInt(context, &i, TRUE))
dudmuck 0:8767be3c1b7f 506 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 507
dudmuck 0:8767be3c1b7f 508 lora.setSf(i);
dudmuck 0:8767be3c1b7f 509 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 510 }
dudmuck 0:8767be3c1b7f 511
dudmuck 0:8767be3c1b7f 512 scpi_result_t lora_sfQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 513 {
dudmuck 0:8767be3c1b7f 514 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 515 if (!radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 516 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 517
dudmuck 0:8767be3c1b7f 518 SCPI_ResultInt(context, lora.getSf());
dudmuck 0:8767be3c1b7f 519 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 520 }
dudmuck 0:8767be3c1b7f 521
dudmuck 0:8767be3c1b7f 522 scpi_result_t lora_txc(scpi_t* context)
dudmuck 0:8767be3c1b7f 523 {
dudmuck 0:8767be3c1b7f 524 scpi_bool_t param1;
dudmuck 0:8767be3c1b7f 525
dudmuck 0:8767be3c1b7f 526 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 527 if (!radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 528 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 529
dudmuck 0:8767be3c1b7f 530 if (!SCPI_ParamBool(context, &param1, TRUE))
dudmuck 0:8767be3c1b7f 531 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 532
dudmuck 0:8767be3c1b7f 533 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 0:8767be3c1b7f 534 lora.RegModemConfig2.sx1276bits.TxContinuousMode = param1;
dudmuck 0:8767be3c1b7f 535 radio.write_reg(REG_LR_MODEMCONFIG2, lora.RegModemConfig2.octet);
dudmuck 0:8767be3c1b7f 536
dudmuck 0:8767be3c1b7f 537 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 538 }
dudmuck 0:8767be3c1b7f 539
dudmuck 0:8767be3c1b7f 540 scpi_result_t lora_txcQ(scpi_t* context)
dudmuck 0:8767be3c1b7f 541 {
dudmuck 0:8767be3c1b7f 542 radio.RegOpMode.octet = radio.read_reg(REG_OPMODE);
dudmuck 0:8767be3c1b7f 543 if (!radio.RegOpMode.bits.LongRangeMode)
dudmuck 0:8767be3c1b7f 544 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 545
dudmuck 0:8767be3c1b7f 546 lora.RegModemConfig2.octet = radio.read_reg(REG_LR_MODEMCONFIG2);
dudmuck 0:8767be3c1b7f 547 SCPI_ResultBool(context, lora.RegModemConfig2.sx1276bits.TxContinuousMode);
dudmuck 0:8767be3c1b7f 548
dudmuck 0:8767be3c1b7f 549 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 550 }
dudmuck 0:8767be3c1b7f 551
dudmuck 0:8767be3c1b7f 552
dudmuck 0:8767be3c1b7f 553 #ifdef TARGET_MOTE_L152RC
dudmuck 0:8767be3c1b7f 554 scpi_result_t pd2_set(scpi_t* context)
dudmuck 0:8767be3c1b7f 555 {
dudmuck 0:8767be3c1b7f 556 scpi_bool_t param1;
dudmuck 0:8767be3c1b7f 557 if (!SCPI_ParamBool(context, &param1, TRUE)) {
dudmuck 0:8767be3c1b7f 558 return SCPI_RES_ERR;
dudmuck 0:8767be3c1b7f 559 }
dudmuck 0:8767be3c1b7f 560
dudmuck 0:8767be3c1b7f 561 pd2 = param1;
dudmuck 0:8767be3c1b7f 562 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 563 }
dudmuck 0:8767be3c1b7f 564
dudmuck 0:8767be3c1b7f 565 scpi_result_t pd2_get(scpi_t* context)
dudmuck 0:8767be3c1b7f 566 {
dudmuck 0:8767be3c1b7f 567 SCPI_ResultBool(context, pd2.read());
dudmuck 0:8767be3c1b7f 568 return SCPI_RES_OK;
dudmuck 0:8767be3c1b7f 569 }
dudmuck 0:8767be3c1b7f 570 #endif /* TARGET_MOTE_L152RC */
dudmuck 0:8767be3c1b7f 571
dudmuck 0:8767be3c1b7f 572 static const scpi_command_t scpi_commands[] = {
dudmuck 0:8767be3c1b7f 573 // http://na.support.keysight.com/pna/help/latest/Programming/GP-IB_Command_Finder/Common_Commands.htm
dudmuck 0:8767be3c1b7f 574 /* IEEE Mandated Commands (SCPI std V1999.0 4.1.1) */
dudmuck 0:8767be3c1b7f 575 { .pattern = "*CLS", .callback = SCPI_CoreCls,}, // clear status
dudmuck 0:8767be3c1b7f 576 { .pattern = "*ESE", .callback = SCPI_CoreEse,}, // standard event status enable
dudmuck 0:8767be3c1b7f 577 { .pattern = "*ESE?", .callback = SCPI_CoreEseQ,},
dudmuck 0:8767be3c1b7f 578 { .pattern = "*ESR?", .callback = SCPI_CoreEsrQ,}, // event status query
dudmuck 0:8767be3c1b7f 579 { .pattern = "*IDN?", .callback = SCPI_CoreIdnQ,}, // identification query
dudmuck 0:8767be3c1b7f 580 { .pattern = "*OPC", .callback = SCPI_CoreOpc,}, // operation complete command
dudmuck 0:8767be3c1b7f 581 { .pattern = "*OPC?", .callback = SCPI_CoreOpcQ,}, // operation complete query
dudmuck 0:8767be3c1b7f 582 { .pattern = "*RST", .callback = SCPI_CoreRst,}, // reset command
dudmuck 0:8767be3c1b7f 583 { .pattern = "*SRE", .callback = SCPI_CoreSre,}, // service request enable command
dudmuck 0:8767be3c1b7f 584 { .pattern = "*SRE?", .callback = SCPI_CoreSreQ,}, // service request enable query
dudmuck 0:8767be3c1b7f 585 { .pattern = "*STB?", .callback = SCPI_CoreStbQ,}, // status byte register query
dudmuck 0:8767be3c1b7f 586 { .pattern = "*TST?", .callback = SCPI_CoreTstQ,}, // self-test query
dudmuck 0:8767be3c1b7f 587 { .pattern = "*WAI", .callback = SCPI_CoreWai,}, // wait to continue
dudmuck 0:8767be3c1b7f 588
dudmuck 0:8767be3c1b7f 589 /* Required SCPI commands (SCPI std V1999.0 4.2.1) */
dudmuck 0:8767be3c1b7f 590 {.pattern = "SYSTem:ERRor[:NEXT]?", .callback = SCPI_SystemErrorNextQ,},
dudmuck 0:8767be3c1b7f 591 {.pattern = "SYSTem:ERRor:COUNt?", .callback = SCPI_SystemErrorCountQ,},
dudmuck 0:8767be3c1b7f 592 {.pattern = "SYSTem:VERSion?", .callback = SCPI_SystemVersionQ,},
dudmuck 0:8767be3c1b7f 593
dudmuck 0:8767be3c1b7f 594 //{.pattern = "STATus:OPERation?", .callback = scpi_stub_callback,},
dudmuck 0:8767be3c1b7f 595 //{.pattern = "STATus:OPERation:EVENt?", .callback = scpi_stub_callback,},
dudmuck 0:8767be3c1b7f 596 //{.pattern = "STATus:OPERation:CONDition?", .callback = scpi_stub_callback,},
dudmuck 0:8767be3c1b7f 597 //{.pattern = "STATus:OPERation:ENABle", .callback = scpi_stub_callback,},
dudmuck 0:8767be3c1b7f 598 //{.pattern = "STATus:OPERation:ENABle?", .callback = scpi_stub_callback,},
dudmuck 0:8767be3c1b7f 599
dudmuck 0:8767be3c1b7f 600 {.pattern = "STATus:QUEStionable[:EVENt]?", .callback = SCPI_StatusQuestionableEventQ,},
dudmuck 0:8767be3c1b7f 601 //{.pattern = "STATus:QUEStionable:CONDition?", .callback = scpi_stub_callback,},
dudmuck 0:8767be3c1b7f 602 {.pattern = "STATus:QUEStionable:ENABle", .callback = SCPI_StatusQuestionableEnable,},
dudmuck 0:8767be3c1b7f 603 {.pattern = "STATus:QUEStionable:ENABle?", .callback = SCPI_StatusQuestionableEnableQ,},
dudmuck 0:8767be3c1b7f 604
dudmuck 0:8767be3c1b7f 605 {.pattern = "STATus:PRESet", .callback = SCPI_StatusPreset,},
dudmuck 0:8767be3c1b7f 606
dudmuck 0:8767be3c1b7f 607 /* DMM */
dudmuck 0:8767be3c1b7f 608 /*
dudmuck 0:8767be3c1b7f 609 {.pattern = "SYSTem:COMMunication:TCPIP:CONTROL?", .callback = SCPI_SystemCommTcpipControlQ,},
dudmuck 0:8767be3c1b7f 610
dudmuck 0:8767be3c1b7f 611 {.pattern = "TEST:BOOL", .callback = TEST_Bool,},
dudmuck 0:8767be3c1b7f 612 {.pattern = "TEST#:NUMbers#", .callback = TEST_Numbers,},*/
dudmuck 0:8767be3c1b7f 613
dudmuck 0:8767be3c1b7f 614 /*{.pattern = "TEST:CHOice?", .callback = TEST_ChoiceQ,},*/
dudmuck 0:8767be3c1b7f 615
dudmuck 0:8767be3c1b7f 616
dudmuck 0:8767be3c1b7f 617 {.pattern = "RAdio:FIfo", .callback = radio_fifo,},
dudmuck 0:8767be3c1b7f 618 {.pattern = "RAdio:FIfo?", .callback = radio_fifoQ,},
dudmuck 0:8767be3c1b7f 619 {.pattern = "RAdio:MODulation", .callback = radio_modulation,},
dudmuck 0:8767be3c1b7f 620 {.pattern = "RAdio:MODulation?", .callback = radio_modulationQ,},
dudmuck 0:8767be3c1b7f 621 {.pattern = "RAdio:RSSI?", .callback = radio_rssiQ,},
dudmuck 0:8767be3c1b7f 622 {.pattern = "RAdio:OPmode", .callback = radio_opmode,},
dudmuck 0:8767be3c1b7f 623 {.pattern = "RAdio:OPmode?", .callback = radio_opmodeQ,},
dudmuck 0:8767be3c1b7f 624 {.pattern = "RAdio:PASelect", .callback = radio_PASelect,},
dudmuck 0:8767be3c1b7f 625 {.pattern = "RAdio:PASelect?", .callback = radio_PASelectQ,},
dudmuck 0:8767be3c1b7f 626 {.pattern = "RAdio:OCP", .callback = radio_ocp,},
dudmuck 0:8767be3c1b7f 627 {.pattern = "RAdio:OCP?", .callback = radio_ocpQ,},
dudmuck 0:8767be3c1b7f 628 {.pattern = "RAdio:POWer", .callback = radio_power,},
dudmuck 0:8767be3c1b7f 629 {.pattern = "RAdio:POWer?", .callback = radio_powerQ,},
dudmuck 0:8767be3c1b7f 630 {.pattern = "RAdio:FREQuency", .callback = radio_freq,},
dudmuck 0:8767be3c1b7f 631 {.pattern = "RAdio:FREQuency?", .callback = radio_freqQ,},
dudmuck 0:8767be3c1b7f 632
dudmuck 0:8767be3c1b7f 633 {.pattern = "RAdio:FSK:SYNC", .callback = fsk_sync,},
dudmuck 0:8767be3c1b7f 634 {.pattern = "RAdio:FSK:SYNC?", .callback = fsk_syncQ,},
dudmuck 0:8767be3c1b7f 635
dudmuck 0:8767be3c1b7f 636 {.pattern = "RAdio:LORa:BW", .callback = lora_bw,},
dudmuck 0:8767be3c1b7f 637 {.pattern = "RAdio:LORa:BW?", .callback = lora_bwQ,},
dudmuck 0:8767be3c1b7f 638 {.pattern = "RAdio:LORa:SF", .callback = lora_sf,},
dudmuck 0:8767be3c1b7f 639 {.pattern = "RAdio:LORa:SF?", .callback = lora_sfQ,},
dudmuck 0:8767be3c1b7f 640 {.pattern = "RAdio:LORa:TXContinuous", .callback = lora_txc,},
dudmuck 0:8767be3c1b7f 641 {.pattern = "RAdio:LORa:TXContinuous?", .callback = lora_txcQ,},
dudmuck 0:8767be3c1b7f 642
dudmuck 0:8767be3c1b7f 643 //{.pattern = "SET9", .callback = wbr_set_bit9,},
dudmuck 0:8767be3c1b7f 644
dudmuck 0:8767be3c1b7f 645 #ifdef TARGET_MOTE_L152RC
dudmuck 0:8767be3c1b7f 646 {.pattern = "PD2", .callback = pd2_set,},
dudmuck 0:8767be3c1b7f 647 {.pattern = "PD2?", .callback = pd2_get,},
dudmuck 0:8767be3c1b7f 648 #endif /* TARGET_MOTE_L152RC */
dudmuck 0:8767be3c1b7f 649
dudmuck 0:8767be3c1b7f 650 SCPI_CMD_LIST_END
dudmuck 0:8767be3c1b7f 651 };
dudmuck 0:8767be3c1b7f 652
dudmuck 0:8767be3c1b7f 653 static scpi_interface_t scpi_interface = {
dudmuck 0:8767be3c1b7f 654 .error = SCPI_Error,
dudmuck 0:8767be3c1b7f 655 .write = SCPI_Write,
dudmuck 0:8767be3c1b7f 656 .control = SCPI_Control,
dudmuck 0:8767be3c1b7f 657 .flush = SCPI_Flush,
dudmuck 0:8767be3c1b7f 658 .reset = SCPI_Reset,
dudmuck 0:8767be3c1b7f 659 };
dudmuck 0:8767be3c1b7f 660
dudmuck 0:8767be3c1b7f 661 #define SCPI_INPUT_BUFFER_LENGTH 256
dudmuck 0:8767be3c1b7f 662 static char scpi_input_buffer[SCPI_INPUT_BUFFER_LENGTH];
dudmuck 0:8767be3c1b7f 663 static scpi_reg_val_t scpi_regs[SCPI_REG_COUNT];
dudmuck 0:8767be3c1b7f 664
dudmuck 0:8767be3c1b7f 665 scpi_t scpi_context = {
dudmuck 0:8767be3c1b7f 666 .cmdlist = scpi_commands,
dudmuck 0:8767be3c1b7f 667 .buffer = {
dudmuck 0:8767be3c1b7f 668 .length = SCPI_INPUT_BUFFER_LENGTH,
dudmuck 0:8767be3c1b7f 669 .data = scpi_input_buffer,
dudmuck 0:8767be3c1b7f 670 },
dudmuck 0:8767be3c1b7f 671 .interface = &scpi_interface,
dudmuck 0:8767be3c1b7f 672 .registers = scpi_regs,
dudmuck 0:8767be3c1b7f 673 .units = scpi_units_def,
dudmuck 0:8767be3c1b7f 674 .idn = {"mbed", "mbed-platform", NULL, "01-02"},
dudmuck 0:8767be3c1b7f 675 };
dudmuck 0:8767be3c1b7f 676
dudmuck 0:8767be3c1b7f 677 void scpi_def_init()
dudmuck 0:8767be3c1b7f 678 {
dudmuck 0:8767be3c1b7f 679 radio.rf_switch.attach(rfsw_callback);
dudmuck 0:8767be3c1b7f 680 }