2.3.1. SCPI server (MATLAB, LabVIEW, Scilab or Python)¶

The Red Pitaya board can be controlled remotely over a LAN or wireless interface using MATLAB, LabVIEW, Scilab, or Python via the Red Pitaya SCPI (Standard Commands for Programmable Instrumentation) list of commands. The SCPI interface/environment is commonly used to control T&M instruments for development, research, or test automation purposes. SCPI uses a set of SCPI commands that are recognised by the instruments to enable specific actions to be taken (e.g., acquiring data from fast analog inputs, generating signals, and controlling other peripheries of the Red Pitaya platform). The SCPI commands are extremely useful when complex signal analysis is required. An SW environment such as MATLAB provides powerful data analysis tools and SCPI commands simple access to raw data acquired on the Red Pitaya board.

Features

Quickly write control routines and programs using MATLAB, LabVIEW, Scilab, or Python.
Use powerful data analysis tools like MATLAB, LabVIEW, Scilab, or Python to analyse raw signals acquired by the Red Pitaya board.
Write testing scripts and routines.
Incorporate your Red Pitaya and LabVIEW into testing and production lines.
Take quick measurements directly on your PC.

2.3.1.1. Quick start¶

Start the SCPI server. This is done simply by clicking on the SCPI server icon and starting the SCPI server. When the SCPI server is started, the IP address of your board will be shown. This IP address must be entered into your scripts. Starting the SCPI server can also be done manually via Terminal (see below).

To run an example, follow the instructions below:

Go to your Red Pitaya main page and select the SCPI server in the Development section.
Start the SCPI server by selecting the RUN button. Please note the IP of your Red Pitaya (192.168.178.100) board as it will be needed to connect to your board.
Follow the instructions below suitable for your environment.

Note

It is not possible to run SCPI commands or programs in parallel with web applications.

MATLAB
Python
LabVIEW
SCILAB

2.3.1.1.1. MATLAB¶

Open MATLAB on your computer.
In the MATLAB workspace, paste the code from the blink tutorial example.
Replace the IP in the example with the IP of your Red Pitaya board.
Hit RUN or F5 on your keyboard to run the code.

More examples of how to control Red Pitaya from MATLAB can be found here.

2.3.1.1.2. Python¶

The PyVISA library, in combination with the PyVISA-py backend, is used.

To install them, do:

$ sudo pip3 install pyvisa pyvisa-py

Note

To run the examples, you need Python version 3. Before running, double-check the Python versions. If the system has Python version 2.7, this version will be used by default.

$ python --version
Python 2.7.17

Then, in order to run the examples, specify explicitly the Python version.

$ python3.5 blink.py 192.168.178.108

Open the blink tutorial and copy the code to your favourite text editor.
Save the file to your working folder as blink.py, for example, examples_py. Copy and save the redpitaya_scpi.py script in the same folder as the blink.py example (in our case, examples_py).

Note

The redpitaya_scpi.py script is a standard script needed to establish the connection between your PC and the Red Pitaya board. The execution of your script will fail without this script being in the same folder as your Python script.
Open the Terminal and navigate to the folder containing your Python script (examples_py), then type: Python blink.py IP, passing a Red Pitaya IP as an argument when calling an execution of the blink.py example. An example is given below, where 192.168.178.108 is the IP of the Red Pitaya board.
```
cd /home/zumy/Desktop/exmples_py
python blink.py 192.168.178.108
```

More examples of how to control Red Pitaya from MATLAB can be found here.

Note

Python examples can also be run directly from the RP device itself. To do so, first start the SCPI server and then use the local device IP: 127.0.0.1

2.3.1.1.3. LabVIEW¶

To install the Red Pitaya LabVIEW driver, download the Red_Pitaya_LabVIEW_Driver&Examples.zip file. Unpack it and copy the Red Pitaya folder to your LabVIEW installation instr.lib folder, e.g. C:/Program Files/National Instruments/LabVIEW 2010/instr.lib. When using the 64-bit LabVIEW version (mostly paid), Or here : C:/Program Files (x86)/National Instruments/LabVIEW 2020/instr.lib when using the 32-bit LabVIEW version, like the free Community Edition.

The Red Pitaya driver should appear after restarting LabVIEW in Block Diagram -> Instrument I/O -> Instr Drivers -> RedPitaya. Depending on your settings, instrument I/O may be hidden. Please consult LabVIEW Help on how to activate or deactivate those categories. You can access example VIs by going to:

Help -> Find Examples…
select the Search tab
In the Enter keyword(s) field, type RedPitaya.

More examples of how to control Red Pitaya from LabVIEW can be found here.

2.3.1.1.4. SCILAB¶

To use the SCPI commands, you will need to set up Scilab sockets. The procedure is described below.

Go to the Scilab download page and download and install Scilab for your OS.
Go to the Scilab socket toolbox page and download the basic socket function for Scilab.
Go to the extracted Scilab folder, then to the folder named contrib.
Copy the socket_toolbox zip file to the contrib folder.
Extract the socket_toolbox zip file inside the contrib folder.
We no longer require the socket_toolbox zip file, so remove it.
Go to the socket_toolbox folder.
Open loader.sce with your Scilab and press RUN (grey run button on SCILAB editor GUI).

These last two steps must be executed each time you start Scilab. To install, you must have an internet connection. Running the examples is the same as on MATALB.

In the MATLAB workspace, paste the code from the blink tutorial example.
Replace the IP in the example with the IP of your Red Pitaya board.
Press RUN to run the code.

Different code examples can be found here.

Note

Communicating with a SCPI server and working with web-based instruments at the same time can diminish the performance of your Red Pitaya. This is because the same resource is used for both tasks.

2.3.1.2. Starting SCPI server manually¶

Assuming you have successfully connected to your Red Pitaya board using these instructions these instructions, remotely connect using Putty on Windows machines or with SSH using Terminal on UNIX (macOSX/Linux) machines.

Connect to your Red Pitaya board via terminal on a Linux machine and start the SCPI server with the following command:

systemctl start redpitaya_scpi &

2.3.1.3. List of supported SCPI commands¶

2.3.1.3.1. LEDs and GPIOs¶

Parameter options:

<dir> = {OUT,IN}
<gpio> = {{DIO0_P...DIO7_P}, {DIO0_N...DIO7_N}}
<led> = {LED0...LED8}
<pin> = {gpio, led}
<state> = {0,1}

Table of correlated SCPI and API commands for the Red Pitaya.

SCPI	API	DESCRIPTION
`DIG:PIN:DIR <dir>,<gpio>` Examples: `DIG:PIN:DIR OUT,DIO0_N` `DIG:PIN:DIR IN,DIO1_P`	`rp_DpinSetDirection`	Set the direction of digital pins to output or input.
`DIG:PIN <pin>,<state>` Examples: `DIG:PIN DIO0_N,1` `DIG:PIN LED2,1`	`rp_DpinSetState`	Set the state of digital outputs to 1 (HIGH) or 0 (LOW).
`DIG:PIN? <pin>` > `<state>` Examples: `DIG:PIN? DIO0_N` `DIG:PIN? LED2`	`rp_DpinGetState`	Get state of digital inputs and outputs.

2.3.1.3.2. Analog Inputs and Outputs¶

Parameter options:

<ain> = {AIN0, AIN1, AIN2, AIN3}
<aout> = {AOUT0, AOUT1, AOUT2, AOUT3}
<pin> = {ain, aout}
<value> = {value in Volts}

SCPI	API	DESCRIPTION
`ANALOG:PIN <pin>,<value>` Examples: `ANALOG:PIN AOUT2,1.34`	`rp_ApinSetValue`	Set the analog voltage on the slow analog outputs. The voltage range of slow analog outputs is: 0 - 1.8 V
`ANALOG:PIN? <pin>` > `<value>` Examples: `ANALOG:PIN? AOUT2` > `1.34` `ANALOG:PIN? AIN1` > `1.12`	`rp_ApinGetValue`	Read the analog voltage from the slow analog inputs. The voltage range of slow analog inputs is: 0 - 3.3 V

2.3.1.3.3. Signal Generator¶

Parameter options:

<n> = {1,2} (set channel OUT1 or OUT2)
<state> = {ON,OFF} Default: OFF
<frequency> = {0Hz...62.5e6Hz} Default: 1000
<func> = {SINE, SQUARE, TRIANGLE, SAWU, SAWD, PWM, ARBITRARY, DC, DC_NEG} Default: SINE
<amplitude> = {-1V...1V} Default: 1 for SIGNALlab 250-12 this value {-5V…5V}
<offset> = {-1V...1V} Default: 0
<phase> = {-360deg ... 360deg} Default: 0
<dcyc> = {0...1} Default: 0.5 Where 1 corresponds to 100%
<array> = {value1, ...} max. 16384 values, floats in the range -1 to 1
<burst> = {BURST , CONTINUOUS} Default: CONTINUOUS
<count> = {1...50000} , Default: 1
<time> = {1µs-500s} Value in µs.
<trigger> = {EXT_PE, EXT_NE, INT, GATED}
- EXT = External
- INT = Internal
- GATED = gated busts

SCPI	API	DESCRIPTION
`OUTPUT:STATE <state>` Examples: `OUTPUT:STATE ON`	`rp_GenOutEnableSync`	Runs or Stops both channels synchronously.
`OUTPUT<n>:STATE <state>` Examples: `OUTPUT1:STATE ON`	`rp_GenOutEnable` `rp_GenOutDisable`	Disable or enable fast analog outputs.
`SOUR<n>:FREQ:FIX <frequency>` Examples: `SOUR2:FREQ:FIX 100000`	`rp_GenFreq`	Set the frequency of fast analog outputs.
`SOUR<n>:FUNC <func>` Examples: `SOUR2:FUNC TRIANGLE`	`rp_GenWaveform`	Set the waveform of fast analog outputs.
`SOUR<n>:VOLT <amplitude>` Examples: `SOUR2:VOLT 0.5`	`rp_GenAmp`	Set the amplitude voltage of fast analog outputs in Volts. Amplitude + offset value must be less than the maximum output range ± 1V.
`SOUR<n>:VOLT:OFFS <offset>` Examples: `SOUR1:VOLT:OFFS 0.2`	`rp_GenOffset`	Set the offset voltage of fast analog outputs in Volts Amplitude + offset value must be less than the maximum output range ± 1V.
`SOUR<n>:PHAS <phase>` Examples: `SOUR2:PHAS 30`	`rp_GenPhase`	Set the phase of fast analog outputs.
`SOUR<n>:DCYC <par>` Examples: `SOUR1:DCYC 0.2`	`rp_GenDutyCycle`	Set the duty cycle of the PWM waveform.
`SOUR<n>:TRAC:DATA:DATA <array>` Examples: `SOUR1:TRAC:DATA:DATA` `1,0.5,0.2`	`rp_GenArbWaveform`	Import data for arbitrary waveform generation.
`SOUR<n>:BURS:STAT <burst>` Examples: `SOUR1:BURS:STAT BURST` `SOUR1:BURS:STAT CONTINUOUS`	`rp_GenMode`	Enable or disable burst (pulse) mode. Red Pitaya will generate R bursts with N signal periods before stopping. P is the time between bursts.
`SOUR<n>:BURS:NCYC <count>` Examples: `SOUR1:BURS:NCYC 3`	`rp_GenBurstCount`	Set the number of periods in a burst (N).
`SOUR<n>:BURS:NOR <count>` Examples: `SOUR1:BURS:NOR 5`	`rp_GenBurstRepetitions`	Set the number of repeated bursts (R) (65536 == INF Repetitions)
`SOUR<n>:BURS:INT:PER <time>` Examples: `SOUR1:BURS:INT:PER 1000000`	`rp_GenBurstPeriod`	Set the duration of a single burst in microseconds (P). This includes the signal and delay.
`SOUR<n>:TRIG:SOUR <trigger>` Examples: `SOUR1:TRIG:SOUR EXT_PE`	`rp_GenTriggerSource`	Set the trigger source for the selected signal.
`SOUR:TRIG:INT` Examples: `SOUR:TRIG:INT`	`rp_GenTrigger`	Triggers both sources/channels immediately.
`SOUR<n>:TRIG:INT` Examples: `SOUR1:TRIG:INT`	`rp_GenTrigger`	Triggers the selected source immediately for the selected channel.
`GEN:RST`	`rp_GenReset`	Reset the generator to default settings.
`PHAS:ALIGN`	`rp_GenSynchronise`	Align the output phases of both channels.

Note

For STEMlab 125-14 4-Input, these commands are not applicable.

2.3.1.3.4. Acquire¶

2.3.1.3.4.1. Control¶

SCPI	API	DESCRIPTION
`ACQ:START`	`rp_AcqStart`	Start the acquisition.
`ACQ:STOP`	`rp_AcqStop`	Stop the acquisition.
`ACQ:RST`	`rp_AcqReset`	Stops the acquisition and sets all parameters to default values.

2.3.1.3.4.2. Sampling rate & decimation¶

Parameter options:

<decimation> = {1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536} Default: 1
<average> = {OFF,ON} Default: ON

SCPI	API	DESCRIPTION
`ACQ:DEC <decimation>` Example: `ACQ:DEC 4`	`rp_AcqSetDecimation`	Set the decimation factor.
`ACQ:DEC?` > `<decimation>` Example: `ACQ:DEC?` > `1`	`rp_AcqGetDecimation`	Get the decimation factor.
`ACQ:AVG <average>`	`rp_AcqSetAveraging`	Enable/disable averaging. Each sample is the average of skipped samples if decimation > 1.
`ACQ:AVG?` > `<average>` Example: `ACQ:AVG?` > `ON`	`rp_AcqGetAveraging`	Get the averaging status.

2.3.1.3.5. Trigger¶

Parameter options:

<n> = {1,2} (set channel IN1 or IN2)
<source> = {DISABLED, NOW, CH1_PE, CH1_NE, CH2_PE, CH2_NE, EXT_PE, EXT_NE, AWG_PE, AWG_NE} Default: DISABLED
<status> = {WAIT, TD}
<time> = {value in ns}
<count> = {value in samples}
<gain> = {LV, HV}
<level> = {value in V}
<mode> = {AC,DC}

Note

For STEMlab 125-14 4-Input <n> = {1,2,3,4} (set channel IN1, IN2, IN3 or IN4)

Note

For STEMlab 125-14 4-Input <source> = {DISABLED, NOW, CH1_PE, CH1_NE, CH2_PE, CH2_NE, CH3_PE, CH3_NE, CH4_PE, CH4_NE, EXT_PE, EXT_NE, AWG_PE, AWG_NE} Default: DISABLED

SCPI	API	DESCRIPTION
`ACQ:TRIG <source>` Example: `ACQ:TRIG CH1_PE`	`rp_AcqSetTriggerSrc`	Disable triggering, trigger immediately or set trigger source & edge.
`ACQ:TRIG:STAT?` Example: `ACQ:TRIG:STAT?` > `WAIT`	`rp_AcqGetTriggerState`	Get trigger status. If DISABLED -> TD else WAIT.
`ACQ:TRIG:FILL?` Example: `ACQ:TRIG:FILL?` > `1`	`rp_AcqGetBufferFillState`	Returns 1 if the buffer is full of data. Otherwise returns 0. (IN FUTURE BETA VERSION)
`ACQ:TRIG:DLY <count>` Example: `ACQ:TRIG:DLY 2314`	`rp_AcqSetTriggerDelay`	Set the trigger delay in samples.
`ACQ:TRIG:DLY?` > `<count>` Example: `ACQ:TRIG:DLY?` > `2314`	`rp_AcqGetTriggerDelay`	Get the trigger delay in samples.
`ACQ:TRIG:DLY:NS <time>` Example: `ACQ:TRIG:DLY:NS 128`	`rp_AcqSetTriggerDelayNs`	Set the trigger delay in ns.
`ACQ:TRIG:DLY:NS?` > `<time>` Example: `ACQ:TRIG:DLY:NS?` > `128ns`	`rp_AcqGetTriggerDelayNs`	Get the trigger delay in ns.
`ACQ:SOUR<n>:GAIN <gain>` Example: `ACQ:SOUR1:GAIN LV`	`rp_AcqSetGain`	Set the gain settings to HIGH or LOW. (For SIGNALlab 250-12 this is 1:20 and 1:1 attenuator). This gain refers to jumper settings on Red Pitaya fast analog inputs.
`ACQ:SOUR<n>:GAIN?` > `<gain>` Example: `ACQ:SOUR1:GAIN?` > `HV`	`rp_AcqGetGain`	Get the gain setting. (For SIGNALlab 250-12 this is 1:20 and 1:1 attenuator).
`ACQ:SOUR<n>:COUP <mode>` Example: `ACQ:SOUR1:COUP AC`	`rp_AcqSetAC_DC`	Sets the AC / DC modes of input. (Only SIGNALlab 250-12)
`ACQ:SOUR<n>:COUP?` > `<mode>` Example: `ACQ:SOUR1:COUP?` > `AC`	`rp_AcqGetAC_DC`	Get the AC / DC modes of input. (Only SIGNALlab 250-12)
`ACQ:TRIG:LEV <level>` Example: `ACQ:TRIG:LEV 0.125 V`	`rp_AcqSetTriggerLevel`	Set the trigger level in V.
`ACQ:TRIG:LEV?` > `level` Example: `ACQ:TRIG:LEV?` > `0.123 V`	`rp_AcqGetTriggerLevel`	Get the trigger level in V.
`ACQ:TRIG:EXT:LEV <level>` Example: `ACQ:TRIG:EXT:LEV 1`	`rp_AcqSetTriggerLevel`	Set the external trigger level in V. (Only SIGNALlab 250-12)
`ACQ:TRIG:EXT:LEV?` > `level` Example: `ACQ:TRIG:EXT:LEV?` > `1`	`rp_AcqGetTriggerLevel`	Get the external trigger level in V. (Only SIGNALlab 250-12)

2.3.1.3.6. Data pointers¶

Parameter options:

<pos> = {position inside circular buffer}

SCPI	API	DESCRIPTION
`ACQ:WPOS?` > `pos` Example: `ACQ:WPOS?` > `1024`	`rp_AcqGetWritePointer`	Returns the current position of the write pointer.
`ACQ:TPOS?` > `pos` Example: `ACQ:TPOS?` > `512`	`rp_AcqGetWritePointerAtTrig`	Returns the position where the trigger event appeared.

2.3.1.3.7. Data read¶

<n> = {1,2} (set channel IN1 or IN2)
<units> = {RAW, VOLTS}
<format> = {BIN, ASCII} Default ASCII
<start_pos> = {0,1,...,16384}
<stop_pos> = {0,1,...,16384}
<m> = {0,1,...,16384}

Note

For STEMlab 125-14 4-Input <n> = {1,2,3,4} (set channel IN1, IN2, IN3 or IN4)

SCPI	API	DESCRIPTION
`ACQ:DATA:UNITS <units>` Example: `ACQ:DATA:UNITS RAW`	`rp_AcqScpiDataUnits`	Select units in which the acquired data will be returned.
`ACQ:DATA:UNITS?` > `<units>` Example: `ACQ:DATA:UNITS?` > `RAW`	`rp_AcqGetScpiDataUnits`	Get units in which the acquired data will be returned.
`ACQ:DATA:FORMAT <format>` Example: `ACQ:DATA:FORMAT ASCII`	`rp_AcqScpiDataFormat`	Select the format in which the acquired data will be returned.
`ACQ:SOUR<n>:DATA:STA:END?` `<start_pos>,<end_pos>` Example: `ACQ:SOUR1:DATA:STA:END? 10,13` > `{123,231,-231}`	`rp_AcqGetDataPosRaw` `rp_AcqGetDataPosV`	Read samples from start to stop position. `<start_pos> = {0,1,...,16384}` `<stop_pos> = {0,1,...,16384}`
`ACQ:SOUR<n>:DATA:STA:N?` `<start_pos>,<m>` Example: `ACQ:SOUR1:DATA:STA:N? 10,3` > `{1.2,3.2,-1.2}`	`rp_AcqGetDataRaw` `rp_AcqGetDataV`	Read `m` samples from the start position onwards.
`ACQ:SOUR<n>:DATA?` Example: `ACQ:SOUR2:DATA?` > `{1.2,3.2,...,-1.2}`	`rp_AcqGetOldestDataRaw` `rp_AcqGetOldestDataV`	Read the full buffer. Starting from the oldest sample in the buffer (first sample after trigger delay). The trigger delay is set to zero by default (in samples or in seconds). If the trigger delay is set to zero, it will read the full buffer size starting from the trigger.
`ACQ:SOUR<n>:DATA:OLD:N? <m>` Example: `ACQ:SOUR2:DATA:OLD:N? 3` > `{1.2,3.2,-1.2}`	`rp_AcqGetOldestDataRaw` `rp_AcqGetOldestDataV`	Read `m` samples after the trigger delay, starting from the oldest sample in the buffer (first sample after trigger delay). The trigger delay is set to zero by default (in samples or in seconds). If the trigger delay is set to zero, it will read m samples starting from the trigger.
`ACQ:SOUR<n>:DATA:LAT:N? <m>` Example: `ACQ:SOUR1:DATA:LAT:N? 3` > `{1.2,3.2,-1.2}`	`rp_AcqGetLatestDataRaw` `rp_AcqGetLatestDataV`	Read `m` samples before the trigger delay. The trigger delay is set to zero by default (in samples or in seconds). If the trigger delay is set to zero, it will read m samples before the trigger.
`ACQ:BUF:SIZE?` > `<size>` Example: `ACQ:BUF:SIZE?` > `16384`	`rp_AcqGetBufSize`	Returns the buffer size.

2.3.1.3.8. UART¶

Parameter options:

<bits> = {CS6, CS7, CS8} Default: CS8
<stop> = {STOP1, STOP2} Default: STOP1
<parity> = {NONE, EVEN, ODD, MARK, SPACE} Default: NONE
<timeout> = {0...255} in (1/10 seconds) Default: 0
<speed> = {1200,2400,4800,9600,19200,38400,57600,115200,230400,576000,921000,1000000,1152000,1500000,2000000,2500000,3000000,3500000,4000000} Default: 9600
<data> = {XXX,... | #HXX,... | #QXXX,... | #BXXXXXXXX,... } Array of data separated comma
- XXX = Dec format
- #HXX = Hex format
- #QXXX = Oct format
- #BXXXXXXXX = Bin format

SCPI	API	DESCRIPTION
`UART:INIT` Example: `UART:INIT`	`rp_UartInit`	Initialises the API for working with UART.
`UART:RELEASE` Example: `UART:RELEASE`	`rp_UartRelease`	Releases all used resources.
`UART:SETUP` Example: `UART:SETUP`	`rp_UartSetSettings`	Applies specified settings to UART.
`UART:BITS <bits>` Example: `UART:BITS CS7`	`rp_UartSetBits`	Sets the character size in bits.
`UART:BITS?` > `<bits>` Example: `UART:BITS?` > `CS7`	`rp_UartGetBits`	Gets the character size in bits.
`UART:SPEED <speed>` Example: `UART:SPEED 115200`	`rp_UartSetSpeed`	Sets the speed of the UART connection.
`UART:SPEED?` > `<speed>` Example: `UART:SPEED?` > `115200`	`rp_UartGetSpeed`	Gets the speed of the UART connection.
`UART:STOPB <stop>` Example: `UART:STOPB STOP2`	`rp_UartSetStopBits`	Sets the length of the stop bit.
`UART:STOPB?` > `<stop>` Example: `UART:STOPB?` > `STOP2`	`rp_UartGetStopBits`	Gets the length of the stop bit.
`UART:PARITY <parity>` Example: `UART:PARITY ODD`	`rp_UartSetParityMode`	Sets parity check mode. - NONE = Disable parity check - EVEN = Set even mode for parity - ODD = Set odd mode for parity - MARK = Set Always 1 - SPACE = Set Always 0
`UART:PARITY?` > `<parity>` Example: `UART:PARITY?` > `ODD`	`rp_UartGetParityMode`	Gets parity check mode.
`UART:TIMEOUT <timeout>` Example: `UART:TIMEOUT 10`	`rp_UartSetTimeout`	Sets the timeout for reading from UART. 0 - Disable timeout. 1 = 1/10 sec. Example: 10 - 1 sec. Max timout: 25.5 sec
`UART:TIMEOUT?` > `<timeout>` Example: `UART:TIMEOUT?` > `10`	`rp_UartGetTimeout`	Gets the timeout.
`UART:WRITE<n> <data>` Example: `UART:WRITE5 1,2,3,4,5`	`rp_UartWrite`	Writes data to UART. <n> - the length of data sent to UART.
`UART:READ<n>` > `<data>` Example: `UART:READ5` > `{1,2,3,4,5}`	`rp_UartRead`	Reads data from UART. <n> - the length of data retrieved from UART.

2.3.1.3.9. SPI¶

Parameter options:

<mode> = {LISL, LIST, HISL, HIST} Default: LISL
<order> = {MSB, LSB} Default: MSB
<bits> = {7,..} Default: 8
<speed> = {1,100000000} Default: 50000000
<data> = {XXX,... | #HXX,... | #QXXX,... | #BXXXXXXXX,... } Array of data separated comma
- XXX = Dec format
- #HXX = Hex format
- #QXXX = Oct format
- #BXXXXXXXX = Bin format

SCPI	API	DESCRIPTION
`SPI:INIT` Example: `SPI:INIT`	`rp_SPI_Init`	Initializes the API for working with SPI.
`SPI:INIT:DEV <path>` Example: `SPI:INIT:DEV "/dev/spidev1.0"`	`rp_SPI_InitDev`	Initializes the API for working with SPI. <path> - Path to the SPI device. On some boards, it may be different from the standard: /dev/spidev1.0
`SPI:RELEASE` Example: `SPI:RELEASE`	`rp_SPI_Release`	Releases all used resources.
`SPI:SETtings:DEF` Example: `SPI:SET:DEF`	`rp_SPI_SetDefault`	Sets the settings for SPI to default values.
`SPI:SETtings:SET` Example: `SPI:SET:SET`	`rp_SPI_SetSettings`	Sets the specified settings for SPI.
`SPI:SETtings:GET` Example: `SPI:SET:GET`	`rp_SPI_GetSettings`	Gets the specified SPI settings.
`SPI:SETtings:MODE <mode>` Example: `SPI:SET:MODE LIST`	`rp_SPI_SetMode`	Sets the mode for SPI. - LISL = Low idle level, Sample on leading edge - LIST = Low idle level, Sample on trailing edge - HISL = High idle level, Sample on leading edge - HIST = High idle level, Sample on trailing edge
`SPI:SETtings:MODE?` > `<mode>` Example: `SPI:SET:MODE?` > `LIST`	`rp_SPI_GetMode`	Gets the specified mode for SPI.
`SPI:SETtings:SPEED <speed>` Example: `SPI:SET:SPEED 1000000`	`rp_SPI_SetSpeed`	Sets the speed of the SPI connection.
`SPI:SETings:SPEED?` > `<speed>` Example: `SPI:SET:SPEED?` > `1000000`	`rp_SPI_GetSpeed`	Gets the speed of the SPI connection.
`SPI:SETtings:WORD <bits>` Example: `SPI:SET:WORD 8`	`rp_SPI_SetWord`	Specifies the length of the word in bits. Must be greater than or equal to 7.
`SPI:SETtings:WORD?` > `<bits>` Example: `SPI:SET:WORD?` > `8`	`rp_SPI_GetWord`	Returns the length of a word.
`SPI:MSG:CREATE <n>` Example: `SPI:MSG:CREATE 1`	`rp_SPI_CreateMessage`	Creates a message queue for SPI. Once created, they need to be initialized. <n> - The number of messages in the queue. The message queue can operate within a single CS state switch.
`SPI:MSG:DEL` Example: `SPI:MSG:DEL`	`rp_SPI_DestoryMessage`	Deletes all messages and data buffers allocated for them.
`SPI:MSG:SIZE?` > `<n>` Example: `SPI:MSG:SIZE?` > `1`	`rp_SPI_GetMessageLen`	Returns the length of the message queue.
`SPI:MSG<n>:TX<m> <data>` `SPI:MSG<n>:TX<m>:CS <data>` Example: `SPI:MSG0:TX4 1,2,3,4` `SPI:MSG1:TX3:CS 2,3,4`	`rp_SPI_SetTX` `rp_SPI_SetTXCS`	Sets data for the write buffer for the specified message. CS - Toggles CS state after sending/receiving this message. <n> - index of message 0 <= n < msg queue size. <m> - TX buffer length.
`SPI:MSG<n>:TX<m>:RX <data>` `SPI:MSG<n>:TX<m>:RX:CS <data>` Example: `SPI:MSG0:TX4:RX 1,2,3,4` `SPI:MSG1:TX3:RX:CS 2,3,4`	`rp_SPI_SetTXRX` `rp_SPI_SetTXRXCS`	Sets data for the read and write buffers for the specified message. CS - Toggles CS state after sending/receiving this message. <n> - index of message 0 <= n < msg queue size. <m> - TX buffer length. The read buffer is also created with the same length and initialized with zeros.
`SPI:MSG<n>:RX<m>` `SPI:MSG<n>:RX<m>:CS` Example: `SPI:MSG0:RX4` `SPI:MSG1:RX5:CS`	`rp_SPI_SetRX` `rp_SPI_SetRXCS`	Initializes a buffer for reading the specified message. CS - Toggles CS state after receiving message. <n> - index of message 0 <= n < msg queue size. <m> - RX buffer length.
`SPI:MSG<n>:RX?` > `<data>` Example: `SPI:MSG1:RX?` > `{2,4,5}`	`rp_SPI_GetRXBuffer`	Returns a read buffer for the specified message.
`SPI:MSG<n>:TX?` > `<data>` Example: `SPI:MSG1:TX?` > `{2,4,5}`	`rp_SPI_GetTXBuffer`	Returns the write buffer for the specified message.
`SPI:MSG<n>:CS?` > `ON\|OFF` Example: `SPI:MSG1:CS?` > `ON`	`rp_SPI_GetCSChangeState`	Returns the setting for CS mode for the specified message.
`SPI:PASS` Example: `SPI:PASS`	`rp_SPI_Pass`	Sends the prepared messages to the SPI device.

2.3.1.3.10. I2C¶

Parameter options:

<mode> = {OFF, ON} Default: OFF
<value> = {XXX | #HXX | #QXXX | #BXXXXXXXX}
<data> = {XXX,... | #HXX,... | #QXXX,... | #BXXXXXXXX,... } Array of data separated comma
- XXX = Dec format
- #HXX = Hex format
- #QXXX = Oct format
- #BXXXXXXXX = Bin format

SCPI	API	DESCRIPTION
`I2C:DEV<addr> <path>` Example: `I2C:DEV80 "/dev/i2c-0"`	`rp_I2C_InitDevice`	Initialises settings for I2C. <path> - Path to the I2C device <addr> - Device address on the I2C bus in dec format.
`I2C:DEV?` > `<addr>` Example: `I2C:DEV?` > `80`	`rp_I2C_getDevAddress`	Returns the current address of the device.
`I2C:FMODE <mode>` Example: `I2C:FMODE ON`	`rp_I2C_setForceMode`	Enables forced bus operation even if the device is in use.
`I2C:FMODE?` > `<mode>` Example: `I2C:FMODE?` > `ON`	`rp_I2C_getForceMode`	Gets the current forced mode setting.
`I2C:Smbus:Read<reg>` > `<value>` Example: `I2C:S:R2` > `0`	`rp_I2C_SMBUS_Read`	Reads 8 bit data from the specified register using the SMBUS protocol. <reg> - Register address in dec format.
`I2C:Smbus:Read<reg>:Word` > `<value>` Example: `I2C:S:R2:W` > `0`	`rp_I2C_SMBUS_ReadWord`	Reads 16 bit data from the specified register using the SMBUS protocol. <reg> - Register address in dec format.
`I2C:Smbus:Read<reg>:Buffer<size>` > `<data>` Example: `I2C:S:R2:B2` > `{0,1}`	`rp_I2C_SMBUS_ReadBuffer`	Reads buffer data from the specified register using the SMBUS protocol. <reg> - Register address in dec format. <size> - Read data size.
`I2C:Smbus:Write<reg> <value>` Example: `I2C:S:W2 10`	`rp_I2C_SMBUS_Write`	Writes 8-bit data to the specified register using the SMBUS protocol. <reg> - Register address in dec format.
`I2C:Smbus:Write<reg>:Word <value>` Example: `I2C:S:W2:W 10`	`rp_I2C_SMBUS_WriteWord`	Writes 16-bit data to the specified register using the SMBUS protocol. <reg> - Register address in dec format.
`I2C:Smbus:Write<reg>:Buffer<size> <data>` Example: `I2C:S:W2:B2 0,1`	`rp_I2C_SMBUS_WriteBuffer`	Writes buffer data to the specified register using the SMBUS protocol. <reg> - Register address in dec format. <size> - Read data size.
`I2C:IOctl:Read:Buffer<size>` > `<data>` Example: `I2C:IO:R:B2` > `{0,1}`	`rp_I2C_IOCTL_ReadBuffer`	Reads data from the I2C device through IOCTL. <size> - Read data size.
`I2C:IOctl:Write:Buffer<size> <data>` Example: `I2C:IO:W:B2 {0,1}`	`rp_I2C_IOCTL_WriteBuffer`	Writes data to the I2C device via IOCTL. <size> - Read data size.

Note

SMBUS is a standardised protocol for communicating with I2C devices. Information about this protocol can be found in this link: SMBUS specifcations. IOCTL writes and reads data directly from I2C.

2.3.1.3.11. Specific LEDs¶

Parameter options:

<mode> = {OFF, ON} Default: ON

SCPI	API	DESCRIPTION
`LED:MMC <mode>` Example: `LED:MMC OFF`	`rp_SetLEDMMCState`	Turns the yellow LED on or off (responsible for indicating the read memory card).
`LED:MMC?` > `<mode>` Example: `LED:MMC?` > `ON`	`rp_GetLEDMMCState`	Gets the state of the MMC indicator.
`LED:HB <mode>` Example: `LED:HB OFF`	`rp_SetLEDHeartBeatState`	Turns the red LED on or off (responsible for indicating board activity).
`LED:HB?` > `<mode>` Example: `LED:HB?` > `ON`	`rp_GetLEDHeartBeatState`	Gets the state of the HeartBeat indicator.
`LED:ETH <mode>` Example: `LED:ETH OFF`	`rp_SetLEDEthState`	Turns the LED indicators on the network card on or off.
`LED:ETH?` > `<mode>` Example: `LED:ETH?` > `ON`	`rp_GetLEDEthState`	Gets the state of the Ethernet indicators.

2.3.1.4. Examples¶

In the list below you will find examples of remote control and C algorithms. These examples cover all basic Red Pitaya functionalities, such as:

signal generation

signal acquisition

digital I/O control

communication protocols

You can edit and change them according to your needs and develop customized programs and routines.

Additional examples: Add a button to control LED