From 79f0f05bfe595518a9db31e677cac6c7196e9dba Mon Sep 17 00:00:00 2001 From: Edgar Bonet Date: Sun, 8 Feb 2026 00:07:34 +0100 Subject: [PATCH] Mention the "C++ API" instead if the "C API" Many files still refer to the C language or API when they actually mean C++. Fix them. --- TODO.inc | 4 +- appsFeatures/appsFeatures.rst | 2 +- appsFeatures/introAcqGen.rst | 18 +- appsFeatures/multichannel/multichannel.rst | 2 +- appsFeatures/remoteControl/API_scripts.rst | 8 +- appsFeatures/remoteControl/command_list.rst | 4 +- .../command_list/commands-acq.rst | 182 +++---- .../command_list/commands-analog.rst | 28 +- .../command_list/commands-board.rst | 158 +++--- .../command_list/commands-can.rst | 506 +++++++++--------- .../command_list/commands-daisy.rst | 28 +- .../command_list/commands-digital.rst | 30 +- .../command_list/commands-dmm.rst | 64 +-- .../command_list/commands-gen.rst | 314 +++++------ .../command_list/commands-i2c.rst | 30 +- .../command_list/commands-init.rst | 10 +- .../command_list/commands-lcr.rst | 42 +- .../command_list/commands-logic-analyzer.rst | 2 +- .../command_list/commands-pll.rst | 6 +- .../command_list/commands-spi.rst | 298 +++++------ .../command_list/commands-status-leds.rst | 12 +- .../command_list/commands-temp-prot.rst | 26 +- .../command_list/commands-uart.rst | 32 +- appsFeatures/remoteControl/deepMemoryMode.rst | 10 +- appsFeatures/remoteControl/remoteAndProg.rst | 2 +- appsFeatures/remoteControl/scpi.rst | 2 +- appsFeatures/supportedFeaturesAndApps.rst | 4 +- .../systemtool/calibration/calibration.rst | 2 +- .../fpga/advanced/fpga_advanced_loading.rst | 2 +- .../fpga/advanced/fpga_boot_loading.rst | 4 +- .../fpga/getting_started/reprogram_fpga.rst | 2 +- .../fpga/getting_started/sdk_install.rst | 2 +- .../app_development/C_and_Python_API.rst | 2 +- .../app_development/app_development.rst | 2 +- developerGuide/software/intro.rst | 6 +- developerGuide/software/software.rst | 2 +- .../known_issues/known_sw_issues.rst | 2 +- intro.rst | 2 +- 38 files changed, 926 insertions(+), 926 deletions(-) diff --git a/TODO.inc b/TODO.inc index 61da6126..679cc83e 100644 --- a/TODO.inc +++ b/TODO.inc @@ -104,7 +104,7 @@ - IQ modulation/demodulation - Simple Lock-In amplifier - Interfacing with C and Python: + Interfacing with C++ and Python: - Creating an FPGA register - Reading and writing from registers @@ -220,7 +220,7 @@ It all depends on the board you're capturing on. If you're using a 125-14 board, you need to divide the values ​​by 8192. If the resolution is different, divide accordingly. Keep in mind that the RAW data is likely uncalibrated. -##. Simple lessons on Data acquisition and generation - C & Python API commands. +##. Simple lessons on Data acquisition and generation - C++ & Python API commands. ##. Move the code examples to GitHub and only link them in the documentation - much easier maintenance. diff --git a/appsFeatures/appsFeatures.rst b/appsFeatures/appsFeatures.rst index 6002f63b..2ccaa73d 100644 --- a/appsFeatures/appsFeatures.rst +++ b/appsFeatures/appsFeatures.rst @@ -13,7 +13,7 @@ For additional resources, please see the :ref:`Developer Guide * **Applications** - Guides for oscilloscope, spectrum analyzer, Bode analyzer, streaming, and community applications * **System Tools** - Network configuration, OS updates, calibration, and system information management * **Multiboard Synchronisation** - Create multi-channel systems with Click Shield or X-Channel configurations -* **Programming & Remote Control** - SCPI commands, Python/C APIs, MATLAB, LabVIEW, JupyterLab, and Deep Memory Mode +* **Programming & Remote Control** - SCPI commands, Python/C++ APIs, MATLAB, LabVIEW, JupyterLab, and Deep Memory Mode * **Command Line Tools** - Terminal utilities for scripting and automation * **Supported Features by Model** - Compatibility information for different Red Pitaya board models diff --git a/appsFeatures/introAcqGen.rst b/appsFeatures/introAcqGen.rst index c046c0d7..5271aa7b 100644 --- a/appsFeatures/introAcqGen.rst +++ b/appsFeatures/introAcqGen.rst @@ -14,7 +14,7 @@ Ordered from simplest to most complex: * `Oscilloscope and other applications`_. * `SCPI commands`_. -* `API commands (C, Python)`_. +* `API commands (C++, Python)`_. * `Deep Memory Acquisition (DMA)`_. * `Streaming application`_. * `Custom acquisition and generation (FPGA)`_. @@ -52,7 +52,7 @@ SCPI commands To remotely control the Red Pitaya from a Python, MATLAB or LabVIEW program running on your computer, and to acquire data from the Red Pitaya to your computer for further processing, use the SCPI commands. The code is executed on a computer and string commands are sent between Red Pitaya and your computer via |wiki-network-socket|. Once the SCPI commands reach Red Pitaya, -they are interpreted and an appropriate C API function is executed in the background. +they are interpreted and an appropriate C++ API function is executed in the background. .. note:: @@ -317,29 +317,29 @@ More information about the SCPI server can be found here: * :ref:`SCPI examples`. -API commands (C, Python) +API commands (C++, Python) ========================== -Another way to control the Red Pitaya is to use the C and Python API commands that run on the Red Pitaya's Linux OS. The advantage over +Another way to control the Red Pitaya is to use the C++ and Python API commands that run on the Red Pitaya's Linux OS. The advantage over the SCPI commands is that the API commands are faster because there is no need to convert the data into strings, send it over the Ethernet and then reconstruct it. In addition, you have full access to the Linux operating system, which means you can configure programs to run directly at boot time, customise data interpretation, or write your own drivers to enhance the existing code. Finally, you have direct access to the FPGA's registry space, making it much easier to write your own software. -The Python API commands are the same as the C API commands, as they are simply a Python front-end to the C commands. You can run Python +The Python API commands are the same as the C++ API commands, as they are simply a Python front-end to the C++ commands. You can run Python code directly on Red Pitaya starting with Red Pitaya 2.00-30 OS (out of the box). The overall functionality is exactly the same as with the SCPI commands, with the exception of using functions instead of string commands and the fact that there are more commands available that have not yet received their SCPI versions. -One thing to note here is that deep memory acquisition of long sequences of data can be speeded up by using a C or Python program to +One thing to note here is that deep memory acquisition of long sequences of data can be speeded up by using a C++ or Python program to acquire the data and then establishing a TCP connection to the computer to achieve a much faster transfer than using the SCPI commands. This requires custom code to establish the connection, transmit the data to the computer, and receive the data from a program such as MATLAB, where it can be processed. -All information about running C and Python programs can be found here: +All information about running C++ and Python programs can be found here: -* :ref:`C & Python API commands `. +* :ref:`C++ & Python API commands `. * :rp-github:`GitHub API source code `. | @@ -378,7 +378,7 @@ of DDR for proper operation of the Linux OS. Deep memory acquisition is based on `AXI protocol (AXI DMA and AXI4-Stream) `_ (double the acronym for double the meaning). Once the acquisition is complete, Red Pitaya needs some time to transfer the entire file to the computer (RAM needs to be cleared) before the acquisition can be reset. -DMA can be configured using SCPI, Python API and C API commands. The triggering options are also the same. +DMA can be configured using SCPI, Python API and C++ API commands. The triggering options are also the same. To increase the speed of transferring the DMA data to the computer with SCPI, the data should be acquired in binary format (``ACQ:DATA:FORMAT BIN``). diff --git a/appsFeatures/multichannel/multichannel.rst b/appsFeatures/multichannel/multichannel.rst index f44fec2c..48ed744e 100644 --- a/appsFeatures/multichannel/multichannel.rst +++ b/appsFeatures/multichannel/multichannel.rst @@ -34,7 +34,7 @@ How can I control synchronised boards? ====================================== * :ref:`SCPI commands `. -* :ref:`C & Python API commands ` (harder to configure as a program must be executed on each board separately). +* :ref:`C++ & Python API commands ` (harder to configure as a program must be executed on each board separately). * :ref:`Streaming application ` (either :ref:`Desktop client application ` or :ref:`command line client `). .. note:: diff --git a/appsFeatures/remoteControl/API_scripts.rst b/appsFeatures/remoteControl/API_scripts.rst index 45846a94..7d8a507a 100644 --- a/appsFeatures/remoteControl/API_scripts.rst +++ b/appsFeatures/remoteControl/API_scripts.rst @@ -1,8 +1,8 @@ .. _API_commands: -########################## -C and Python Applications -########################## +############################ +C++ and Python Applications +############################ .. include:: ../../developerGuide/software/app_development/C_and_Python_API.inc - \ No newline at end of file + diff --git a/appsFeatures/remoteControl/command_list.rst b/appsFeatures/remoteControl/command_list.rst index 0d7c56a1..7b390a53 100644 --- a/appsFeatures/remoteControl/command_list.rst +++ b/appsFeatures/remoteControl/command_list.rst @@ -4,12 +4,12 @@ List of supported SCPI & API commands ******************************************** -Here is a list of all available SCPI, API, and JupyterLab commands. The commands are organized into tables by functionality. Each table row represents the same command in SCPI, Python API, C API, and JupyterLAB. +Here is a list of all available SCPI, API, and JupyterLab commands. The commands are organized into tables by functionality. Each table row represents the same command in SCPI, Python API, C++ API, and JupyterLAB. The Jupyter commands are identical to Python API commands, so please refer to them. In the final two columns is a command description and ecosystem version in which the command first appeared. At the beginning of each table are all command parameter options and available macros. -For API commands you can find a detailed description in these C header files: +For API commands you can find a detailed description in these C++ header files: * `Red Pitaya GitHub API header files `_. diff --git a/appsFeatures/remoteControl/command_list/commands-acq.rst b/appsFeatures/remoteControl/command_list/commands-acq.rst index ad0a7314..4352d80c 100644 --- a/appsFeatures/remoteControl/command_list/commands-acq.rst +++ b/appsFeatures/remoteControl/command_list/commands-acq.rst @@ -65,68 +65,68 @@ Acquisition Control +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +=====================================+=================================================+============================================================================+====================+ -| | ``ACQ:START`` | | C: ``rp_AcqStart()`` | Start the acquisition. | 1.04-18 and up | +| | ``ACQ:START`` | | C++: ``rp_AcqStart()`` | Start the acquisition. | 1.04-18 and up | | | | | | | | | | | | Python: ``rp_AcqStart()`` | | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:START:CH`` | | C: ``rp_AcqStartCh(rp_channel_t channel)`` | | Start the acquisition. | 2.05-37 and up | +| | ``ACQ:START:CH`` | | C++: ``rp_AcqStartCh(rp_channel_t channel)`` | | Start the acquisition. | 2.05-37 and up | | | | | | | Used only in split trigger mode | | | | | | Python: ``rp_AcqStartCh()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:STOP`` | | C: ``rp_AcqStop()`` | Stop the acquisition. | 1.04-18 and up | +| | ``ACQ:STOP`` | | C++: ``rp_AcqStop()`` | Stop the acquisition. | 1.04-18 and up | | | | | | | | | | | | Python: ``rp_AcqStop()`` | | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:STOP:CH`` | | C: ``rp_AcqStopCh(rp_channel_t channel)`` | | Stop the acquisition. | 2.05-37 and up | +| | ``ACQ:STOP:CH`` | | C++: ``rp_AcqStopCh(rp_channel_t channel)`` | | Stop the acquisition. | 2.05-37 and up | | | | | | | Used only in split trigger mode | | | | | | Python: ``rp_AcqStopCh()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:RST`` | | C: ``rp_AcqReset()`` | | Stop the acquisition and reset all acquisition parameters to | 1.04-18 and up | +| | ``ACQ:RST`` | | C++: ``rp_AcqReset()`` | | Stop the acquisition and reset all acquisition parameters to | 1.04-18 and up | | | | | | | default values. | | | | | | Python: ``rp_AcqReset()`` | | | | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:RST:CH`` | | C: ``rp_AcqResetCh(rp_channel_t channel)`` | | Stop the acquisition and reset all acquisition parameters to | 2.05-37 and up | +| | ``ACQ:RST:CH`` | | C++: ``rp_AcqResetCh(rp_channel_t channel)`` | | Stop the acquisition and reset all acquisition parameters to | 2.05-37 and up | | | | | | | default values. | | | | | | Python: ``rp_AcqResetCh()`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SPLIT:TRig `` | | C: ``rp_AcqSetSplitTrigger(bool enable)`` | | Enables split trigger mode. | 2.05-37 and up | +| | ``ACQ:SPLIT:TRig `` | | C++: ``rp_AcqSetSplitTrigger(bool enable)`` | | Enables split trigger mode. | 2.05-37 and up | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | Python: ``rp_AcqSetSplitTrigger()`` | | (All boards from 2.07-48) | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SPLIT:TRig?`` > ```` | | C: ``rp_AcqGetSplitTrigger(bool* state)`` | | Returns the split trigger mode status | 2.05-37 and up | +| | ``ACQ:SPLIT:TRig?`` > ```` | | C++: ``rp_AcqGetSplitTrigger(bool* state)`` | | Returns the split trigger mode status | 2.05-37 and up | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | Python: ``rp_AcqGetSplitTrigger()`` | | (All boards from 2.07-48) | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:M16BIT `` | | C: ``rp_AcqSet16BitMode(bool enable)`` | | Enables the mode when the FPGA returns data in 16-bit format. | in dev | +| | ``ACQ:M16BIT `` | | C++: ``rp_AcqSet16BitMode(bool enable)`` | | Enables the mode when the FPGA returns data in 16-bit format. | in dev | | | | | | | | | | | | Python: ``rp_AcqSet16BitMode()`` | | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | ``ACQ:M16BIT?`` > ```` | | C: ``rp_AcqGet16BitMode(bool* state)`` | | Returns the 16-bit mode status | in dev | +| | ``ACQ:M16BIT?`` > ```` | | C++: ``rp_AcqGet16BitMode(bool* state)`` | | Returns the 16-bit mode status | in dev | | | | | | | | | | | | Python: ``rp_AcqGet16BitMode()`` | | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AcqResetFpga()`` | Reset the acqusition writing state machine. | 1.04-18 and up | +| | - | | C++: ``rp_AcqResetFpga()`` | Reset the acqusition writing state machine. | 1.04-18 and up | | | | | | | | | | | | Python: ``rp_AcqResetFpga()`` | | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AcqSetArmKeep(bool enable)`` | Enable continous acquisition even after trigger has happened. | 1.04-18 and up | +| | - | | C++: ``rp_AcqSetArmKeep(bool enable)`` | Enable continous acquisition even after trigger has happened. | 1.04-18 and up | | | | | | | | | | | | Python: ``rp_AcqSetArmKeep()`` | | | | | | | | | | +-------------------------------------+-------------------------------------------------+----------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AcqGetArmKeep(bool* state)`` | Get the status of continous acquisition after trigger setting. | 1.04-18 and up | +| | - | | C++: ``rp_AcqGetArmKeep(bool* state)`` | Get the status of continous acquisition after trigger setting. | 1.04-18 and up | | | | | | | | | | | | Python: ``rp_AcqGetArmKeep()`` | | | | | | | | | | @@ -176,157 +176,157 @@ Acquisition settings +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +=====================================================+================================================================================================+===============================================================================+====================+ -| | ``ACQ:DEC `` | | C: ``rp_AcqSetDecimation(rp_acq_decimation_t decimation)`` | | Set the decimation factor (power of 2 from 1 to 65536). | 1.04-18 and up | +| | ``ACQ:DEC `` | | C++: ``rp_AcqSetDecimation(rp_acq_decimation_t decimation)`` | | Set the decimation factor (power of 2 from 1 to 65536). | 1.04-18 and up | | | Example: | | | | | | | | ``ACQ:DEC 4`` | | Python: ``rp_AcqSetDecimation()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DEC:CH `` | | C: ``rp_AcqSetDecimationCh(rp_channel_t channel, rp_acq_decimation_t decimation)`` | | Set the decimation factor (power of 2 from 1 to 65536). | 2.05-37 and up | +| | ``ACQ:DEC:CH `` | | C++: ``rp_AcqSetDecimationCh(rp_channel_t channel, rp_acq_decimation_t decimation)`` | | Set the decimation factor (power of 2 from 1 to 65536). | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:DEC:CH1 4`` | | Python: ``rp_AcqSetDecimationCh(, )`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DEC?`` > ```` | | C: ``rp_AcqGetDecimation(rp_acq_decimation_t* decimation)`` | Get the decimation factor. | 1.04-18 and up | +| | ``ACQ:DEC?`` > ```` | | C++: ``rp_AcqGetDecimation(rp_acq_decimation_t* decimation)`` | Get the decimation factor. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:DEC?`` > ``1`` | | Python: ``rp_AcqGetDecimation()`` | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DEC:CH?`` > ```` | | C: ``rp_AcqGetDecimationCh(rp_channel_t channel, rp_acq_decimation_t* decimation)`` | | Get the decimation factor. | 2.05-37 and up | +| | ``ACQ:DEC:CH?`` > ```` | | C++: ``rp_AcqGetDecimationCh(rp_channel_t channel, rp_acq_decimation_t* decimation)`` | | Get the decimation factor. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:DEC:CH1?`` > ``1`` | | Python: ``rp_AcqGetDecimationCh()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DEC:Factor `` | | C: ``rp_AcqSetDecimationFactor(uint32_t decimation)`` | | Set the extended decimation factor (power of 2 up to 16 then any | 2.00-30 and up | +| | ``ACQ:DEC:Factor `` | | C++: ``rp_AcqSetDecimationFactor(uint32_t decimation)`` | | Set the extended decimation factor (power of 2 up to 16 then any | 2.00-30 and up | | | Example: | | | | whole number up to 65536). | | | | ``ACQ:DEC:Factor 17`` | | Python: ``rp_AcqSetDecimationFactor()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DEC:Factor:CH `` | | C: ``rp_AcqSetDecimationFactorCh(rp_channel_t channel, uint32_t decimation)`` | | Set the extended decimation factor (power of 2 up to 16 then any | 2.05-37 and up | +| | ``ACQ:DEC:Factor:CH `` | | C++: ``rp_AcqSetDecimationFactorCh(rp_channel_t channel, uint32_t decimation)`` | | Set the extended decimation factor (power of 2 up to 16 then any | 2.05-37 and up | | | Example: | | | | whole number up to 65536). | | | | ``ACQ:DEC:Factor:CH1 17`` | | Python: ``rp_AcqSetDecimationFactorCh(, )`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DEC:Factor?`` > ```` | | C: ``rp_AcqGetDecimationFactor(uint32_t* decimation)`` | Get the extended decimation factor. | 2.00-30 and up | +| | ``ACQ:DEC:Factor?`` > ```` | | C++: ``rp_AcqGetDecimationFactor(uint32_t* decimation)`` | Get the extended decimation factor. | 2.00-30 and up | | | Example: | | | | | | | ``ACQ:DEC:Factor?`` > ``1`` | | Python: ``rp_AcqGetDecimationFactor()`` | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DEC:Factor:CH?`` > ```` | | C: ``rp_AcqGetDecimationFactorCh(rp_channel_t channel, uint32_t* decimation)`` | | Get the extended decimation factor. | 2.05-37 and up | +| | ``ACQ:DEC:Factor:CH?`` > ```` | | C++: ``rp_AcqGetDecimationFactorCh(rp_channel_t channel, uint32_t* decimation)`` | | Get the extended decimation factor. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:DEC:Factor:CH1?`` > ``1`` | | Python: ``rp_AcqGetDecimationFactorCh()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AcqConvertFactorToDecimation(uint32_t factor,rp_acq_decimation_t* decimation)`` | | Convert the decimation factor to the closest available decimation value | 1.04-18 and up | +| | - | | C++: ``rp_AcqConvertFactorToDecimation(uint32_t factor,rp_acq_decimation_t* decimation)`` | | Convert the decimation factor to the closest available decimation value | 1.04-18 and up | | | | | | | (closest power of 2). | | | | | | Python: ``rp_AcqConvertFactorToDecimation()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AcqGetSamplingRateHz(float* sampling_rate)`` | | Get the current sampling rate in Hertz. | 1.04-18 and up | +| | - | | C++: ``rp_AcqGetSamplingRateHz(float* sampling_rate)`` | | Get the current sampling rate in Hertz. | 1.04-18 and up | | | | | | | | | | | | | Python: ``rp_AcqGetSamplingRateHz()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AVG `` | | C: ``rp_AcqSetAveraging(bool enabled)`` | | Enable/disable averaging. | 1.04-18 and up | +| | ``ACQ:AVG `` | | C++: ``rp_AcqSetAveraging(bool enabled)`` | | Enable/disable averaging. | 1.04-18 and up | | | | | | | Each sample is the average of skipped samples if ``DEC`` > 1. | | | | | | Python: ``rp_AcqSetAveraging()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AVG?`` > ```` | | C: ``rp_AcqGetAveraging(bool *enabled)`` | | Get the averaging status. | 1.04-18 and up | +| | ``ACQ:AVG?`` > ```` | | C++: ``rp_AcqGetAveraging(bool *enabled)`` | | Get the averaging status. | 1.04-18 and up | | | Example: | | | | Averages the skipped samples when ``DEC`` > 1 | | | | ``ACQ:AVG?`` > ``ON`` | | Python: ``rp_AcqGetAveraging()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AVG:CH `` | | C: ``rp_AcqSetAveragingCh(rp_channel_t channel, bool enabled)`` | | Enable/disable averaging. | 2.05-37 and up | +| | ``ACQ:AVG:CH `` | | C++: ``rp_AcqSetAveragingCh(rp_channel_t channel, bool enabled)`` | | Enable/disable averaging. | 2.05-37 and up | | | | | | | Each sample is the average of skipped samples if ``DEC`` > 1. | | | | | | Python: ``rp_AcqSetAveragingCh(, )`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AVG:CH?`` > ```` | | C: ``rp_AcqGetAveragingCh(rp_channel_t channel, bool *enabled)`` | | Get the averaging status. | 2.05-37 and up | +| | ``ACQ:AVG:CH?`` > ```` | | C++: ``rp_AcqGetAveragingCh(rp_channel_t channel, bool *enabled)`` | | Get the averaging status. | 2.05-37 and up | | | Example: | | | | Averages the skipped samples when ``DEC`` > 1 | | | | ``ACQ:AVG:CH1?`` > ``ON`` | | Python: ``rp_AcqGetAveragingCh()`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:FILTER:BYPASS:CH `` | | C: ``rp_AcqSetBypassFilter(rp_channel_t channel, bool enabled)`` | | The function enables or disables the filter in the FPGA. | 2.07-43 and up | +| | ``ACQ:FILTER:BYPASS:CH `` | | C++: ``rp_AcqSetBypassFilter(rp_channel_t channel, bool enabled)`` | | The function enables or disables the filter in the FPGA. | 2.07-43 and up | | | | | | | | | | | | | Python: ``rp_AcqSetBypassFilter(, )`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:FILTER:BYPASS:CH?`` > ```` | | C: ``rp_AcqGetBypassFilter(rp_channel_t channel, bool *enabled)`` | | Gets the current filter bypass from the FPGA | 2.07-43 and up | +| | ``ACQ:FILTER:BYPASS:CH?`` > ```` | | C++: ``rp_AcqGetBypassFilter(rp_channel_t channel, bool *enabled)`` | | Gets the current filter bypass from the FPGA | 2.07-43 and up | | | Example: | | | | | | | | ``ACQ:FILTER:BYPASS:CH1?`` > ``ON`` | | Python: ``rp_AcqGetBypassFilter()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:GAIN `` | | C: ``rp_AcqSetGain(rp_channel_t channel, rp_pinState_t state)`` | | Set the gain for the specified channel to HIGH or LOW. | 1.04-18 and up | +| | ``ACQ:SOUR:GAIN `` | | C++: ``rp_AcqSetGain(rp_channel_t channel, rp_pinState_t state)`` | | Set the gain for the specified channel to HIGH or LOW. | 1.04-18 and up | | | | | | | (For SIGNALlab 250-12 this is 1:20 and 1:1 attenuator). | | | | Example: | | Python: ``rp_AcqSetGain(, )`` | | The gain refers to jumper settings on the Red Pitaya fast analog input. | | | | ``ACQ:SOUR1:GAIN LV`` | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:GAIN?`` > ```` | | C: ``rp_AcqGetGain(rp_channel_t channel, rp_pinState_t* state)`` | | Get the gain setting for the specified channel | 1.04-18 and up | +| | ``ACQ:SOUR:GAIN?`` > ```` | | C++: ``rp_AcqGetGain(rp_channel_t channel, rp_pinState_t* state)`` | | Get the gain setting for the specified channel | 1.04-18 and up | | | | | | | (For SIGNALlab 250-12 this is 1:20 and 1:1 attenuator). | | | | Example: | | Python: ``rp_AcqGetGain()`` | | | | | | ``ACQ:SOUR1:GAIN?`` > ``HV`` | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AcqGetGainV(rp_channel_t channel, float* voltage)`` | | Get specified channel gain in Volts. | 1.04-18 and up | +| | - | | C++: ``rp_AcqGetGainV(rp_channel_t channel, float* voltage)`` | | Get specified channel gain in Volts. | 1.04-18 and up | | | | | | | | | | | | | Python: ``rp_AcqGetGainV()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:COUP `` | | C: ``rp_AcqSetAC_DC(rp_channel_t channel, rp_acq_ac_dc_mode_t mode)`` | Set the AC / DC mode of the specified input (only SIGNALlab 250-12). | 1.04-18 and up | +| | ``ACQ:SOUR:COUP `` | | C++: ``rp_AcqSetAC_DC(rp_channel_t channel, rp_acq_ac_dc_mode_t mode)`` | Set the AC / DC mode of the specified input (only SIGNALlab 250-12). | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:SOUR1:COUP AC`` | | Python: ``rp_AcqSetAC_DC(, )`` | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:COUP?`` > ```` | | C: ``rp_AcqGetAC_DC(rp_channel_t channel, rp_acq_ac_dc_mode_t *status)`` | Get the AC / DC mode of the specified input (only SIGNALlab 250-12). | 1.04-18 and up | +| | ``ACQ:SOUR:COUP?`` > ```` | | C++: ``rp_AcqGetAC_DC(rp_channel_t channel, rp_acq_ac_dc_mode_t *status)`` | Get the AC / DC mode of the specified input (only SIGNALlab 250-12). | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:SOUR1:COUP?`` > ``AC`` | | Python: ``rp_AcqGetAC_DC()`` | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DATA:Units `` | | C: - (See specific acquisition command) | | Select units in which the acquired data will be returned. For API commands | 1.04-18 and up | +| | ``ACQ:DATA:Units `` | | C++: - (See specific acquisition command) | | Select units in which the acquired data will be returned. For API commands | 1.04-18 and up | | | Example: | | | | this depends on which function is called (see specific functions for | | | | ``ACQ:DATA:Units RAW`` | | Python: - (See specific acquisition command) | | details). | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DATA:Units?`` > ```` | | C: - (See specific acquisition command) | Get units in which the acquired data will be returned. | 1.04-18 and up | +| | ``ACQ:DATA:Units?`` > ```` | | C++: - (See specific acquisition command) | Get units in which the acquired data will be returned. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:DATA:Units?`` > ``RAW`` | | Python: - (See specific acquisition command) | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DATA:FORMAT `` | | C: - (N/A) | | Select the format in which the acquired data will be returned. | 1.04-18 and up | +| | ``ACQ:DATA:FORMAT `` | | C++: - (N/A) | | Select the format in which the acquired data will be returned. | 1.04-18 and up | | | Example: | | | | Only for remote SCPI control. | | | | ``ACQ:DATA:FORMAT ASCII`` | | Python: - (N/A) | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DATA:FORMAT?`` > ```` | | C: - (N/A) | | Returns the current format setting. | 1.04-18 and up | +| | ``ACQ:DATA:FORMAT?`` > ```` | | C++: - (N/A) | | Returns the current format setting. | 1.04-18 and up | | | Example: | | | | Only for remote SCPI control. | | | | ``ACQ:DATA:FORMAT?`` > ``ASCII`` | | Python: - (N/A) | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DATA:BYTE:ORDER `` | | C: - (N/A) | | Sets the byte order that the server returns when queried in BIN mode. | 2.07-43 and up | +| | ``ACQ:DATA:BYTE:ORDER `` | | C++: - (N/A) | | Sets the byte order that the server returns when queried in BIN mode. | 2.07-43 and up | | | Example: | | | | For maximum performance, set the mode to LEND | | | | ``ACQ:DATA:BYTE:ORDER LEND`` | | Python: - (N/A) | | Only for remote SCPI control. | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:DATA:BYTE:ORDER?`` > ```` | | C: - (N/A) | | Returns the current byte order setting. | 2.07-43 and up | +| | ``ACQ:DATA:BYTE:ORDER?`` > ```` | | C++: - (N/A) | | Returns the current byte order setting. | 2.07-43 and up | | | Example: | | | | Only for remote SCPI control. | | | | ``ACQ:DATA:BYTE:ORDER?`` > ``LEND`` | | Python: - (N/A) | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:BUF:SIZE?`` > ```` | | C: ``rp_AcqGetBufSize(uint32_t *size)`` | | Returns the buffer size. | 1.04-18 and up | +| | ``ACQ:BUF:SIZE?`` > ```` | | C++: ``rp_AcqGetBufSize(uint32_t *size)`` | | Returns the buffer size. | 1.04-18 and up | | | Example: | | | | For Python API specifically, the input parameter is the buffer itself. | | | | ``ACQ:BUF:SIZE?`` > ``16384`` | | Python: ``rp_AcqGetBufSize()`` | | | | | | | | | | | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | - (N/A) | | C: - (look for *malloc* function online) | | Performs memory allocation and returns the requested buffer. | 2.00-18 - 2.04-35 | +| | - (N/A) | | C++: - (look for *malloc* function online) | | Performs memory allocation and returns the requested buffer. | 2.00-18 - 2.04-35 | | | | | | | - ```` - how many channels will be acquired | | | | | | Python: ``rp_createBuffer(, , , , )`` | | - ```` - length of the buffer in samples (max 16384) | | | | | | | | - ``, , `` - buffer sample type, set one | | | | | | | | to ``true``, others are ``false``. | | | | | | | | For Python API specifically. Replaced by functions returning NumPy buffers. | | +-----------------------------------------------------+------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+--------------------+ -| | - (N/A) | | C: - (look for *free* function online) | | Free the allocated resources. | 2.00-18 - 2.04-35 | +| | - (N/A) | | C++: - (look for *free* function online) | | Free the allocated resources. | 2.00-18 - 2.04-35 | | | | | | | - ```` - buffer to be released/freed | | | | | | Python: ``rp_deleteBuffer()`` | | For Python API specifically. | | | | | | | | Replaced by functions returning NumPy buffers. | | @@ -374,156 +374,156 @@ Acquisition trigger +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +========================================================+======================================================================================+===============================================================================+=========================+ -| | ``ACQ:TRig `` | | C: ``rp_AcqSetTriggerSrc(rp_acq_trig_src_t source)`` | | Set acquisition trigger source. The options are disabled, trigger | 1.04-18 and up | +| | ``ACQ:TRig `` | | C++: ``rp_AcqSetTriggerSrc(rp_acq_trig_src_t source)`` | | Set acquisition trigger source. The options are disabled, trigger | 1.04-18 and up | | | Example: | | | | immediately, or set trigger source & edge. | | | | ``ACQ:TRig CH1_PE`` | | Python: ``rp_AcqSetTriggerSrc()`` | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:CH `` | | C: ``rp_AcqSetTriggerSrcCh(rp_channel_t channel, rp_acq_trig_src_t source)`` | | Set acquisition trigger source. The options are disabled, trigger | 2.05-37 and up | +| | ``ACQ:TRig:CH `` | | C++: ``rp_AcqSetTriggerSrcCh(rp_channel_t channel, rp_acq_trig_src_t source)`` | | Set acquisition trigger source. The options are disabled, trigger | 2.05-37 and up | | | Example: | | | | immediately, or set trigger source & edge. | | | | ``ACQ:TRig:CH1 CH1_PE`` | | Python: ``rp_AcqSetTriggerSrcCh(, )`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | - | | C: ``rp_AcqGetTriggerSrc(rp_acq_trig_src_t* source)`` | | Get acquisition trigger source. | 1.04-18 and up | +| | - | | C++: ``rp_AcqGetTriggerSrc(rp_acq_trig_src_t* source)`` | | Get acquisition trigger source. | 1.04-18 and up | | | | | | | | | | | | | Python: ``rp_AcqGetTriggerSrc()`` | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:STAT?`` > ```` | | C: ``rp_AcqGetTriggerState(rp_acq_trig_state_t* state)`` | | Get acquisition trigger status. If the trigger is ``DISABLED`` or the | 1.04-18 and up | +| | ``ACQ:TRig:STAT?`` > ```` | | C++: ``rp_AcqGetTriggerState(rp_acq_trig_state_t* state)`` | | Get acquisition trigger status. If the trigger is ``DISABLED`` or the | 1.04-18 and up | | | Example: | | | | acquisition is triggered, the state is ``TD``. Otherwise, it is ``WAIT``. | | | | ``ACQ:TRig:STAT?`` > ``WAIT`` | | Python: ``rp_AcqGetTriggerState()`` | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:STAT:CH?`` > ```` | | C: ``rp_AcqGetTriggerStateCh(rp_channel_t channel, rp_acq_trig_state_t* state)`` | | Get acquisition trigger status. If the trigger is ``DISABLED`` or the | 2.05-37 and up | +| | ``ACQ:TRig:STAT:CH?`` > ```` | | C++: ``rp_AcqGetTriggerStateCh(rp_channel_t channel, rp_acq_trig_state_t* state)`` | | Get acquisition trigger status. If the trigger is ``DISABLED`` or the | 2.05-37 and up | | | Example: | | | | acquisition is triggered, the state is ``TD``. Otherwise, it is ``WAIT``. | | | | ``ACQ:TRig:STAT:CH1?`` > ``WAIT`` | | Python: ``rp_AcqGetTriggerStateCh()`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:FILL?`` > ```` | | C: ``rp_AcqGetBufferFillState(bool* state)`` | Returns 1 if the buffer is full of data. Otherwise returns 0. | 2.00-15 and up | +| | ``ACQ:TRig:FILL?`` > ```` | | C++: ``rp_AcqGetBufferFillState(bool* state)`` | Returns 1 if the buffer is full of data. Otherwise returns 0. | 2.00-15 and up | | | Example: | | | | | | | ``ACQ:TRig:FILL?`` > ``1`` | | Python: ``rp_AcqGetBufferFillState()`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:FILL:CH?`` > ```` | | C: ``rp_AcqGetBufferFillStateCh(rp_channel_t channel, bool* state)`` | | Returns 1 if the buffer is full of data. Otherwise returns 0. | 2.05-37 and up | +| | ``ACQ:TRig:FILL:CH?`` > ```` | | C++: ``rp_AcqGetBufferFillStateCh(rp_channel_t channel, bool* state)`` | | Returns 1 if the buffer is full of data. Otherwise returns 0. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:TRig:FILL:CH1?`` > ``1`` | | Python: ``rp_AcqGetBufferFillStateCh()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | | | | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:DLY `` | | C: ``rp_AcqSetTriggerDelay(int32_t decimated_data_num)`` | | Set the trigger delay in samples. The triggering moment is by default in | 1.04-18 and up | +| | ``ACQ:TRig:DLY `` | | C++: ``rp_AcqSetTriggerDelay(int32_t decimated_data_num)`` | | Set the trigger delay in samples. The triggering moment is by default in | 1.04-18 and up | | | Example: | | | | the middle of acquired buffer (at 8192th sample) (trigger delay set to 0). | | | | ``ACQ:TRig:DLY 2314`` | | Python: ``rp_AcqSetTriggerDelay()`` | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:DLY:CH `` | | C: ``rp_AcqSetTriggerDelayCh(rp_channel_t channel, int32_t decimated_data_num)`` | | Set the trigger delay in samples. The triggering moment is by default in | 2.05-37 and up | +| | ``ACQ:TRig:DLY:CH `` | | C++: ``rp_AcqSetTriggerDelayCh(rp_channel_t channel, int32_t decimated_data_num)`` | | Set the trigger delay in samples. The triggering moment is by default in | 2.05-37 and up | | | Example: | | | | the middle of acquired buffer (at 8192th sample) (trigger delay set to 0). | | | | ``ACQ:TRig:DLY:CH1 2314`` | | Python: ``rp_AcqSetTriggerDelayCh(,)`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:DLY?`` > ```` | | C: ``rp_AcqGetTriggerDelay(int32_t* decimated_data_num)`` | Get the trigger delay in samples. | 1.04-18 and up | +| | ``ACQ:TRig:DLY?`` > ```` | | C++: ``rp_AcqGetTriggerDelay(int32_t* decimated_data_num)`` | Get the trigger delay in samples. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:TRig:DLY?`` > ``2314`` | | Python: ``rp_AcqGetTriggerDelay()`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:DLY:CH?`` > ```` | | C: ``rp_AcqGetTriggerDelayCh(rp_channel_t channel, int32_t* decimated_data_num)`` | | Get the trigger delay in samples. | 2.05-37 and up | +| | ``ACQ:TRig:DLY:CH?`` > ```` | | C++: ``rp_AcqGetTriggerDelayCh(rp_channel_t channel, int32_t* decimated_data_num)``| | Get the trigger delay in samples. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:TRig:DLY:CH1?`` > ``2314`` | | Python: ``rp_AcqGetTriggerDelayCh()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | | | | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:DLY:NS `` | | C: ``rp_AcqSetTriggerDelayNs(int64_t time_ns)`` | | Set the trigger delay in ns. Must be multiple of the board's clock | 1.04-18 and up | +| | ``ACQ:TRig:DLY:NS `` | | C++: ``rp_AcqSetTriggerDelayNs(int64_t time_ns)`` | | Set the trigger delay in ns. Must be multiple of the board's clock | 1.04-18 and up | | | Example: | | | | resolution (125 MHz clock == 8 ns resolution, 250 MHz == 4 ns resolution). | | | | ``ACQ:TRig:DLY:NS 128`` | | Python: ``rp_AcqSetTriggerDelayNs()`` | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:DLY:NS:CH `` | | C: ``rp_AcqSetTriggerDelayNsCh(rp_channel_t channel, int64_t time_ns)`` | | Set the trigger delay in ns. Must be multiple of the board's clock | 2.05-37 and up | +| | ``ACQ:TRig:DLY:NS:CH `` | | C++: ``rp_AcqSetTriggerDelayNsCh(rp_channel_t channel, int64_t time_ns)`` | | Set the trigger delay in ns. Must be multiple of the board's clock | 2.05-37 and up | | | Example: | | | | resolution (125 MHz clock == 8 ns resolution, 250 MHz == 4 ns resolution). | | | | ``ACQ:TRig:DLY:NS:CH1 128`` | | Python: ``rp_AcqSetTriggerDelayNsCh(,)`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:DLY:NS?`` > ```` | | C: ``rp_AcqGetTriggerDelayNs(int64_t* time_ns)`` | Get the trigger delay in ns. | 1.04-18 and up | +| | ``ACQ:TRig:DLY:NS?`` > ```` | | C++: ``rp_AcqGetTriggerDelayNs(int64_t* time_ns)`` | Get the trigger delay in ns. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:TRig:DLY:NS?`` > ``128`` ns | | Python: ``rp_AcqGetTriggerDelayNs()`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:DLY:NS:CH?`` > ```` | | C: ``rp_AcqGetTriggerDelayNsCh(rp_channel_t channel, int64_t* time_ns)`` | | Get the trigger delay in ns. | 2.05-37 and up | +| | ``ACQ:TRig:DLY:NS:CH?`` > ```` | | C++: ``rp_AcqGetTriggerDelayNsCh(rp_channel_t channel, int64_t* time_ns)`` | | Get the trigger delay in ns. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:TRig:DLY:NS:CH1?`` > ``128`` ns | | Python: ``rp_AcqGetTriggerDelayNsCh()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | | | | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | - | | C: ``rp_AcqGetPreTriggerCounter(uint32_t* value)`` | | Get the pretrigger sample count (how many samples are in the buffer before | 1.04-18 and up | +| | - | | C++: ``rp_AcqGetPreTriggerCounter(uint32_t* value)`` | | Get the pretrigger sample count (how many samples are in the buffer before | 1.04-18 and up | | | | | | | the trigger position). | | | | | | Python: ``rp_AcqGetPreTriggerCounter()`` | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:HYST `` | | C: ``rp_AcqSetTriggerHyst(float voltage)`` | Set the trigger hysteresis threshold value in Volts. | 1.04-18 and up | +| | ``ACQ:TRig:HYST `` | | C++: ``rp_AcqSetTriggerHyst(float voltage)`` | Set the trigger hysteresis threshold value in Volts. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:TRig:HYST 0.005`` | | Python: ``rp_AcqSetTriggerHyst()`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:HYST?`` > ```` | | C: ``rp_AcqGetTriggerHyst(float* voltage)`` | Get the trigger hysteresis threshold value in Volts. | 1.04-18 and up | +| | ``ACQ:TRig:HYST?`` > ```` | | C++: ``rp_AcqGetTriggerHyst(float* voltage)`` | Get the trigger hysteresis threshold value in Volts. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:TRig:HYST?`` > ``0.005`` V | | Python: ``rp_AcqGetTriggerHyst()`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:LEV `` | | C: ``rp_AcqSetTriggerLevel(rp_channel_trigger_t channel, float voltage)`` | Set the trigger level in V. | 1.04-18 and up | +| | ``ACQ:TRig:LEV `` | | C++: ``rp_AcqSetTriggerLevel(rp_channel_trigger_t channel, float voltage)`` | Set the trigger level in V. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:TRig:LEV 0.125 V`` | | Python: ``rp_AcqSetTriggerLevel(, )`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:LEV:CH `` | | C: ``rp_AcqSetTriggerLevel(rp_channel_trigger_t channel, float voltage)`` | | Set the trigger level in V. | 2.05-37 and up | +| | ``ACQ:TRig:LEV:CH `` | | C++: ``rp_AcqSetTriggerLevel(rp_channel_trigger_t channel, float voltage)`` | | Set the trigger level in V. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:TRig:LEV:CH1 0.125 V`` | | Python: ``rp_AcqSetTriggerLevel(, )`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | | | | | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:LEV?`` > ```` | | C: ``rp_AcqGetTriggerLevel(rp_channel_trigger_t channel, float* voltage)`` | Get the trigger level in V. | 1.04-18 and up | +| | ``ACQ:TRig:LEV?`` > ```` | | C++: ``rp_AcqGetTriggerLevel(rp_channel_trigger_t channel, float* voltage)`` | Get the trigger level in V. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:TRig:LEV?`` > ``0.123`` V | | Python: ``rp_AcqGetTriggerLevel()`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:LEV:CH?`` > ```` | | C: ``rp_AcqGetTriggerLevel(rp_channel_trigger_t channel, float* voltage)`` | | Get the trigger level in V. | 2.05-37 and up | +| | ``ACQ:TRig:LEV:CH?`` > ```` | | C++: ``rp_AcqGetTriggerLevel(rp_channel_trigger_t channel, float* voltage)`` | | Get the trigger level in V. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:TRig:LEV:CH1?`` > ``0.123`` V | | Python: ``rp_AcqGetTriggerLevel()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | | | | | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:EXT:LEV `` | | C: ``rp_AcqSetTriggerLevel(rp_channel_trigger_t channel, float voltage)`` | Set the external trigger level in V. | 1.04-18 - 2.00-30 | +| | ``ACQ:TRig:EXT:LEV `` | | C++: ``rp_AcqSetTriggerLevel(rp_channel_trigger_t channel, float voltage)`` | Set the external trigger level in V. | 1.04-18 - 2.00-30 | | | Example: | | | (Only SIGNALlab 250-12) | | | | ``ACQ:TRig:EXT:LEV 1`` | | Python: ``rp_AcqSetTriggerLevel(, )`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:EXT:LEV?`` > ```` | | C: ``rp_AcqGetTriggerLevel(rp_channel_trigger_t channel, float* voltage)`` | Get the external trigger level in V. | 1.04-18 - 2.00-30 | +| | ``ACQ:TRig:EXT:LEV?`` > ```` | | C++: ``rp_AcqGetTriggerLevel(rp_channel_trigger_t channel, float* voltage)`` | Get the external trigger level in V. | 1.04-18 - 2.00-30 | | | Example: | | | (Only SIGNALlab 250-12) | | | | ``ACQ:TRig:EXT:LEV?`` > ``1`` | | Python: ``rp_AcqGetTriggerLevel()`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:EXT:DEBouncer:[US] `` | | C: ``rp_AcqSetExtTriggerDebouncerUs(double value)`` | | Set the external trigger acquisition debouncer in microseconds (value must | 2.00-15 and up | +| | ``ACQ:TRig:EXT:DEBouncer:[US] `` | | C++: ``rp_AcqSetExtTriggerDebouncerUs(double value)`` | | Set the external trigger acquisition debouncer in microseconds (value must | 2.00-15 and up | | | Example: | | | | be positive). | | | | ``ACQ:TRig:EXT:DEBouncer:US 1`` | | Python: ``rp_AcqSetExtTriggerDebouncerUs()`` | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``ACQ:TRig:EXT:DEBouncer:[US]?`` > ```` | | C: ``rp_AcqGetExtTriggerDebouncerUs(double *value)`` | | Set the external trigger acquisition debouncer in microseconds. | 2.00-15 and up | +| | ``ACQ:TRig:EXT:DEBouncer:[US]?`` > ```` | | C++: ``rp_AcqGetExtTriggerDebouncerUs(double *value)`` | | Set the external trigger acquisition debouncer in microseconds. | 2.00-15 and up | | | Example: | | | | | | | | ``ACQ:TRig:EXT:DEBouncer:US?`` > ``1`` | | Python: ``rp_AcqGetExtTriggerDebouncerUs()`` | | | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``TRig:EXT:LEV `` | | C: ``rp_SetExternalTriggerLevel(float voltage)`` | Set the external trigger level in V. | 2.04-35 and up | +| | ``TRig:EXT:LEV `` | | C++: ``rp_SetExternalTriggerLevel(float voltage)`` | Set the external trigger level in V. | 2.04-35 and up | | | Example: | | | (Only SIGNALlab 250-12) | | | | ``TRig:EXT:LEV 1`` | | Python: ``rp_SetExternalTriggerLevel()`` | | | | | | | | | | +--------------------------------------------------------+--------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+-------------------------+ -| | ``TRig:EXT:LEV?`` > ```` | | C: ``rp_GetExternalTriggerLevel(float* voltage)`` | Get the external trigger level in V. | 2.04-35 and up | +| | ``TRig:EXT:LEV?`` > ```` | | C++: ``rp_GetExternalTriggerLevel(float* voltage)`` | Get the external trigger level in V. | 2.04-35 and up | | | Example: | | | (Only SIGNALlab 250-12) | | | | ``TRig:EXT:LEV?`` > ``1`` | | Python: ``rp_GetExternalTriggerLevel()`` | | | | | | | | | | @@ -553,23 +553,23 @@ even though it is displayed to happen at approximately 8192nd sample in the acqu +---------------------------------------+-----------------------------------------------------------------------------------+----------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +=======================================+===================================================================================+==========================================================+====================+ -| | ``ACQ:WPOS?`` > ```` | | C: ``rp_AcqGetWritePointer(uint32_t* pos)`` | | Returns the current position of the write pointer, | 1.04-18 and up | +| | ``ACQ:WPOS?`` > ```` | | C++: ``rp_AcqGetWritePointer(uint32_t* pos)`` | | Returns the current position of the write pointer, | 1.04-18 and up | | | Example: | | | | i.e the index of the most recent sample in the buffer. | | | | ``ACQ:WPOS?`` > ``1024`` | | Python: ``rp_AcqGetWritePointer()`` | | | | | | | | | | | | +---------------------------------------+-----------------------------------------------------------------------------------+----------------------------------------------------------+--------------------+ -| | ``ACQ:TPOS?`` > ```` | | C: ``rp_AcqGetWritePointerAtTrig(uint32_t* pos)`` | Returns the position where the trigger event appeared. | 1.04-18 and up | +| | ``ACQ:TPOS?`` > ```` | | C++: ``rp_AcqGetWritePointerAtTrig(uint32_t* pos)`` | Returns the position where the trigger event appeared. | 1.04-18 and up | | | Example: | | | | | | | ``ACQ:TPOS?`` > ``512`` | | Python: ``rp_AcqGetWritePointerAtTrig()`` | | | | | | | | | | +---------------------------------------+-----------------------------------------------------------------------------------+----------------------------------------------------------+--------------------+ -| | ``ACQ:WPOS:CH?`` > ```` | | C: ``rp_AcqGetWritePointerCh(rp_channel_t channel, uint32_t* pos)`` | | Returns the current position of the write pointer, | 2.05-37 and up | +| | ``ACQ:WPOS:CH?`` > ```` | | C++: ``rp_AcqGetWritePointerCh(rp_channel_t channel, uint32_t* pos)`` | | Returns the current position of the write pointer, | 2.05-37 and up | | | Example: | | | | i.e the index of the most recent sample in the buffer. | | | | ``ACQ:WPOS:CH1?`` > ``1024`` | | Python: ``rp_AcqGetWritePointerCh()`` | | Used only in split trigger mode | | | | | | | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | +---------------------------------------+-----------------------------------------------------------------------------------+----------------------------------------------------------+--------------------+ -| | ``ACQ:TPOS:CH?`` > ```` | | C: ``rp_AcqGetWritePointerAtTrigCh(rp_channel_t channel, uint32_t* pos)`` | | Returns the position where the trigger event appeared. | 2.05-37 and up | +| | ``ACQ:TPOS:CH?`` > ```` | | C++: ``rp_AcqGetWritePointerAtTrigCh(rp_channel_t channel, uint32_t* pos)`` | | Returns the position where the trigger event appeared. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:TPOS:CH1?`` > ``512`` | | Python: ``rp_AcqGetWritePointerAtTrigCh()`` | | (Only STEMlab 125-14 4-Input) | | | | | | | | (All boards from 2.07-48) | | @@ -586,7 +586,7 @@ Data read - `` = {1,2}`` (set channel IN1 or IN2) - ``, , = {0, 1, ..., 16383}`` -- ```` Array to store the data into. For Python API use ``rp_createBuffer`` and for C API use *malloc*. +- ```` Array to store the data into. For Python API use ``rp_createBuffer`` and for C++ API use *malloc*. - ```` Size of the array for data storage. - `` = {PRE_TRIG, POST_TRIG, PRE_POST_TRIG}`` Buffer reading direction mode relative to trigger @@ -608,9 +608,9 @@ Data read +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +=============================================+==========================================================================================================================================+========================================================================================+====================+ -| | ``ACQ:SOUR:DATA:STArt:End?`` | | C: ``rp_AcqGetDataPosRaw(rp_channel_t channel, uint32_t start_pos, uint32_t end_pos, int16_t* buffer, uint32_t* buffer_size)`` | | Read samples from ``start_pos`` to ``end_pos``. For API commands, the buffer for | 1.04-18 and up | -| | ``,`` | | ``rp_AcqGetDataPosV(rp_channel_t channel, uint32_t start_pos, uint32_t end_pos, float* buffer, uint32_t* buffer_size)`` | | data storage and its size must also be provided. Use ``rp_createBuffer`` to allocate | | -| | Example: | | Python: ``rp_AcqGetDataPosRaw(, , , , )`` | | data for Python and *malloc* for C. API commands have two functions to return data | | +| | ``ACQ:SOUR:DATA:STArt:End?`` | | C++: ``rp_AcqGetDataPosRaw(rp_channel_t channel, uint32_t start_pos, uint32_t end_pos, int16_t* buffer, uint32_t* buffer_size)`` | | Read samples from ``start_pos`` to ``end_pos``. For API commands, the buffer for | 1.04-18 and up | +| | ``,`` | | ``rp_AcqGetDataPosV(rp_channel_t channel, uint32_t start_pos, uint32_t end_pos, float* buffer, uint32_t* buffer_size)`` | | data storage and its size must also be provided. Use ``rp_createBuffer`` to allocate | | +| | Example: | | Python: ``rp_AcqGetDataPosRaw(, , , , )`` | | data for Python and *malloc* for C++. API commands have two functions to return data | | | | ``ACQ:SOUR1:DATA:STArt:End? 10,13`` > | | ``rp_AcqGetDataPosV(, , , , )`` | | in Volts or RAW. | | | | ``{123,231,-231}`` | | | | | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ @@ -619,20 +619,20 @@ Data read | | | | | | Faster than the Python functions above. | | | | | | | | | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AcqGetDataRawWithCalib(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)`` | | Read ```` samples from the ```` onwards. The data is returned in RAW | 1.04-18 and up | +| | - | | C++: ``rp_AcqGetDataRawWithCalib(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)`` | | Read ```` samples from the ```` onwards. The data is returned in RAW | 1.04-18 and up | | | | | | | format with calibration applied. | | | | | | Python: ``rp_AcqGetDataRawWithCalib(, , , )`` | | Numpy buffer must have the specified ``dtype`` format. | | | | | | ``rp_AcqGetDataRawWithCalibNP(channel, pos, np_buffer)`` (Numpy buffer ``dtype=np.int16``) | | Faster than the Python functions above. | | | | | | | | | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AcqGetNormalizedDataPos(uint32_t pos)`` | | Normalizes the ADC buffer position. Returns the modulo operation of ADC buffer size. | 1.04-18 and up | +| | - | | C++: ``rp_AcqGetNormalizedDataPos(uint32_t pos)`` | | Normalizes the ADC buffer position. Returns the modulo operation of ADC buffer size. | 1.04-18 and up | | | | | | | | | | | | | Python: ``rp_AcqGetNormalizedDataPos()`` | | | | | | | | | | | | | | | | | | | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:DATA:STArt:N?`` | | C: ``rp_AcqGetDataRaw(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)`` | | Read ``size`` samples from the ```` onwards. | 1.04-18 and up | -| | ``,`` | | ``rp_AcqGetDataV(rp_channel_t channel, uint32_t pos, uint32_t* size, float* buffer)`` | | | | +| | ``ACQ:SOUR:DATA:STArt:N?`` | | C++: ``rp_AcqGetDataRaw(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)`` | | Read ``size`` samples from the ```` onwards. | 1.04-18 and up | +| | ``,`` | | ``rp_AcqGetDataV(rp_channel_t channel, uint32_t pos, uint32_t* size, float* buffer)`` | | | | | | Example: | | Python: ``rp_AcqGetDataRaw(, , , )`` | | | | | | ``ACQ:SOUR1:DATA:STArt:N? 10,3`` > | | ``rp_AcqGetDataV(, , , )`` | | | | | | ``{1.2,3.2,-1.2}`` | | | | | | @@ -642,8 +642,8 @@ Data read | | | | | | Numpy buffer must have the specified ``dtype`` format. | | | | | | | | Faster than the Python functions above. | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:DATA?`` | | C: ``rp_AcqGetOldestDataRaw(rp_channel_t channel, uint32_t* size, int16_t* buffer)`` | | Read the full buffer. | 1.04-18 and up | -| | Example: | | ``rp_AcqGetOldestDataV(rp_channel_t channel, uint32_t* size, float* buffer)`` | | Starting from the oldest sample in the buffer (first sample after trigger delay). | | +| | ``ACQ:SOUR:DATA?`` | | C++: ``rp_AcqGetOldestDataRaw(rp_channel_t channel, uint32_t* size, int16_t* buffer)`` | | Read the full buffer. | 1.04-18 and up | +| | Example: | | ``rp_AcqGetOldestDataV(rp_channel_t channel, uint32_t* size, float* buffer)`` | | Starting from the oldest sample in the buffer (first sample after trigger delay). | | | | ``ACQ:SOUR2:DATA?`` > | | Python: ``rp_AcqGetOldestDataRaw(, , )`` | | If the trigger delay is set to zero, it will read the full buffer size starting | | | | ``{1.2,3.2,...,-1.2}`` | | ``rp_AcqGetOldestDataV(, , )`` | | from the trigger. | | | | | | | | | | @@ -653,8 +653,8 @@ Data read | | | | | | Numpy buffer must have the specified ``dtype`` format. | | | | | | | | Faster than the Python functions above. | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:DATA:Old:N? `` | | C: ``rp_AcqGetOldestDataRaw(rp_channel_t channel, uint32_t* size, int16_t* buffer)`` | | Read the oldest ```` samples in the buffer. | 1.04-18 and up | -| | Example: | | ``rp_AcqGetOldestDataV(rp_channel_t channel, uint32_t* size, float* buffer)`` | | | | +| | ``ACQ:SOUR:DATA:Old:N? `` | | C++: ``rp_AcqGetOldestDataRaw(rp_channel_t channel, uint32_t* size, int16_t* buffer)`` | | Read the oldest ```` samples in the buffer. | 1.04-18 and up | +| | Example: | | ``rp_AcqGetOldestDataV(rp_channel_t channel, uint32_t* size, float* buffer)`` | | | | | | ``ACQ:SOUR2:DATA:Old:N? 3`` > | | Python: ``rp_AcqGetOldestDataRaw(, , )`` | | | | | | ``{1.2,3.2,-1.2}`` | | ``rp_AcqGetOldestDataV(, , )`` | | | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ @@ -663,8 +663,8 @@ Data read | | | | | | Numpy buffer must have the specified ``dtype`` format. | | | | | | | | Faster than the Python functions above. | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:DATA:LATest:N? `` | | C: ``rp_AcqGetLatestDataRaw(rp_channel_t channel, uint32_t* size, int16_t* buffer)`` | | Read the latest ```` samples in the buffer. | 1.04-18 and up | -| | Example: | | ``rp_AcqGetLatestDataV(rp_channel_t channel, uint32_t* size, float* buffer)`` | | | | +| | ``ACQ:SOUR:DATA:LATest:N? `` | | C++: ``rp_AcqGetLatestDataRaw(rp_channel_t channel, uint32_t* size, int16_t* buffer)`` | | Read the latest ```` samples in the buffer. | 1.04-18 and up | +| | Example: | | ``rp_AcqGetLatestDataV(rp_channel_t channel, uint32_t* size, float* buffer)`` | | | | | | ``ACQ:SOUR1:DATA:LATest:N? 3`` > | | Python: ``rp_AcqGetLatestDataRaw(, , )`` | | | | | | ``{1.2,3.2,-1.2}`` | | ``rp_AcqGetLatestDataV(, , )`` | | | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ @@ -673,8 +673,8 @@ Data read | | | | | | Faster than the Python functions above. | | | | | | | | | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:SOUR:DATA:TRig? ,`` | | C: ``rp_AcqGetDataRaw(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)`` | | Read ```` samples relative to the trigger, depending on the setting. | 2.05-37 and up | -| | Example: | | ``rp_AcqGetDataV(rp_channel_t channel, uint32_t pos, uint32_t* size, float* buffer)`` | | ``PRE_TRIG``, ``POST_TRIG`` trigger configuration returns ``size`` data samples. | | +| | ``ACQ:SOUR:DATA:TRig? ,`` | | C++: ``rp_AcqGetDataRaw(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)`` | | Read ```` samples relative to the trigger, depending on the setting. | 2.05-37 and up | +| | Example: | | ``rp_AcqGetDataV(rp_channel_t channel, uint32_t pos, uint32_t* size, float* buffer)`` | | ``PRE_TRIG``, ``POST_TRIG`` trigger configuration returns ``size`` data samples. | | | | ``ACQ:SOUR1:DATA:TRig? 3,POST_TRIG`` > | | Python: ``rp_AcqGetDataRaw(, , , )`` | | ``PRE_POST_TRIG`` returns ``size`` * 2 + 1 data samples, including the triggering | | | | ``{1.2,3.2,-1.2}`` | | ``rp_AcqGetDataV(, , , )`` | | moment | | +---------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------+--------------------+ diff --git a/appsFeatures/remoteControl/command_list/commands-analog.rst b/appsFeatures/remoteControl/command_list/commands-analog.rst index 2010f232..6ae63cfc 100644 --- a/appsFeatures/remoteControl/command_list/commands-analog.rst +++ b/appsFeatures/remoteControl/command_list/commands-analog.rst @@ -48,42 +48,42 @@ Parameters and command table +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +=======================================+====================================================================================+===================================================================================+====================+ -| | ``ANALOG:RST`` | | C: ``rp_ApinReset()`` | Sets analog outputs to default values (0 V). | 1.04-18 and up | +| | ``ANALOG:RST`` | | C++: ``rp_ApinReset()`` | Sets analog outputs to default values (0 V). | 1.04-18 and up | | | Examples: | | | | | | | ``ANALOG:RST`` | | Python: ``rp_ApinReset()`` | | | | | | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | ``ANALOG:PIN ,`` | | C: ``rp_ApinSetValue(rp_apin_t pin, float value)`` | | Set the analog voltage on the slow analog outputs. | 1.04-18 and up | -| | Examples: | | ``rp_ApinSetValueRaw(rp_apin_t pin, uint32_t value)`` | | The voltage range of slow analog outputs is: 0 - 1.8 V | | +| | ``ANALOG:PIN ,`` | | C++: ``rp_ApinSetValue(rp_apin_t pin, float value)`` | | Set the analog voltage on the slow analog outputs. | 1.04-18 and up | +| | Examples: | | ``rp_ApinSetValueRaw(rp_apin_t pin, uint32_t value)`` | | The voltage range of slow analog outputs is: 0 - 1.8 V | | | | ``ANALOG:PIN AOUT2,1.34`` | | Python: ``rp_ApinSetValue(, )`` | | | | | | | ``rp_ApinSetValueRaw(, )`` | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | ``ANALOG:PIN? `` > ```` | | C: ``rp_ApinGetValue(rp_apin_t pin, float* value, uint32_t* raw)`` | | Read the analog voltage from the slow analog inputs. | 1.04-18 and up | -| | Examples: | | ``rp_ApinGetValueRaw(rp_apin_t pin, uint32_t* value)`` | | The voltage range of slow analog inputs is: 0 - 3.3 V | | +| | ``ANALOG:PIN? `` > ```` | | C++: ``rp_ApinGetValue(rp_apin_t pin, float* value, uint32_t* raw)`` | | Read the analog voltage from the slow analog inputs. | 1.04-18 and up | +| | Examples: | | ``rp_ApinGetValueRaw(rp_apin_t pin, uint32_t* value)`` | | The voltage range of slow analog inputs is: 0 - 3.3 V | | | | ``ANALOG:PIN? AOUT2`` > ``1.34`` | | Python: ``rp_ApinGetValue()`` | | | | | ``ANALOG:PIN? AIN1`` > ``1.12`` | | ``rp_ApinGetValueRaw()`` | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_ApinGetRange(rp_apin_t pin, float* min_val, float* max_val)`` | Get voltage range of the specified analog pin. | 1.04-18 and up | +| | - | | C++: ``rp_ApinGetRange(rp_apin_t pin, float* min_val, float* max_val)`` | Get voltage range of the specified analog pin. | 1.04-18 and up | | | | | | | | | | | | Python: ``rp_ApinGetRange()`` | | | | | | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AIpinGetValue(int unsigned pin, float* value, uint32_t* raw)`` | Get the analog voltage on the slow analog inputs (Volts or RAW). | 1.04-18 and up | -| | | | ``rp_AIpinGetValueRaw(int unsigned pin, uint32_t* value)`` | | | +| | - | | C++: ``rp_AIpinGetValue(int unsigned pin, float* value, uint32_t* raw)`` | Get the analog voltage on the slow analog inputs (Volts or RAW). | 1.04-18 and up | +| | | | ``rp_AIpinGetValueRaw(int unsigned pin, uint32_t* value)`` | | | | | | | Python: ``rp_AIpinGetValue()`` | | | | | | | ``rp_AIpinGetValueRaw()`` | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AOpinSetValue(int unsigned pin, float value)`` | Set the output voltage on slow analog outputs. | 1.04-18 and up | -| | | | ``rp_AOpinSetValueRaw(int unsigned pin, uint32_t value)`` | | | +| | - | | C++: ``rp_AOpinSetValue(int unsigned pin, float value)`` | Set the output voltage on slow analog outputs. | 1.04-18 and up | +| | | | ``rp_AOpinSetValueRaw(int unsigned pin, uint32_t value)`` | | | | | | | Python: ``rp_AOpinSetValue(, )`` | | | | | | | ``rp_AOpinSetValueRaw(, )`` | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AOpinGetValue(int unsigned pin, float* value, uint32_t* raw)`` | Get the output voltage on slow analog outputs. | 1.04-18 and up | -| | | | ``rp_AOpinGetValueRaw(int unsigned pin, uint32_t* value)`` | | | +| | - | | C++: ``rp_AOpinGetValue(int unsigned pin, float* value, uint32_t* raw)`` | Get the output voltage on slow analog outputs. | 1.04-18 and up | +| | | | ``rp_AOpinGetValueRaw(int unsigned pin, uint32_t* value)`` | | | | | | | Python: ``rp_AOpinGetValue()`` | | | | | | | ``rp_AOpinGetValueRaw()`` | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_AOpinGetRange(int unsigned pin, float* min_val, float* max_val)`` | Get voltage range of the specified analog output pin. | 1.04-18 and up | +| | - | | C++: ``rp_AOpinGetRange(int unsigned pin, float* min_val, float* max_val)`` | Get voltage range of the specified analog output pin. | 1.04-18 and up | | | | | | | | | | | | Python: ``rp_AOpinGetRange()`` | | | | | | | | | | @@ -92,4 +92,4 @@ Parameters and command table | * :ref:`Back to top ` -* :ref:`Back to command list ` \ No newline at end of file +* :ref:`Back to command list ` diff --git a/appsFeatures/remoteControl/command_list/commands-board.rst b/appsFeatures/remoteControl/command_list/commands-board.rst index d84365ea..a8c052d0 100644 --- a/appsFeatures/remoteControl/command_list/commands-board.rst +++ b/appsFeatures/remoteControl/command_list/commands-board.rst @@ -77,86 +77,86 @@ Parameters and command table .. tabularcolumns:: |p{50mm}|p{50mm}|p{60mm}|p{30mm}| -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | -+======================================================+==================================================+===========================================================+========================+ -| | ``RP:LOGmode `` | | - | Enables scpi-server log output mode. | 1.04-18 and up | -| | Examples: | | | | | -| | ``RP:LOGmode SYSLOG`` | | | | | -| | | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``RP:RET_ON_ERROR `` | | N/A | | Enables a special mode for compatibility | 2.07-43 and up | -| | Examples: | | | | with older SCPI clients. When this mode is enabled, | | -| | ``RP:RET_ON_ERROR ON`` | | | | if errors occur when executing query commands, | | -| | | | | | the server will return empty data with delimiters "\r\n"| | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:TIME ,,`` | | - | Sets the time on the board. | 2.00-18 and 2.00-36 | -| | Examples: | | | | | -| | ``SYSTem:TIME 16,12,45`` | | | | | -| | ``SYST:TIME 11,23,01`` | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:TIME "::"`` | | - | Sets the time on the board. | 2.05-37 and up | -| | Examples: | | | | | -| | ``SYSTem:TIME "16:12:45"`` | | | | | -| | ``SYST:TIME "11:23:01"`` | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:TIME?`` > ``time`` | | - | Returns the current time on the board. | 2.00-18 and up | -| | Examples: | | | | | -| | ``SYSTem:TIME?`` > ``16:12:45`` | | | | | -| | ``SYST:TIME?`` > ``11:23:01`` | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:DATE ,,`` | | - | Sets the date on the board. | 2.00-18 and 2.00-36 | -| | Examples: | | | | | -| | ``SYSTem:DATE 2023,04,04`` | | | | | -| | ``SYST:DATE 2002,12,29`` | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:DATE "--"`` | | - | Sets the date on the board. | 2.05-37 and up | -| | Examples: | | | | | -| | ``SYSTem:DATE "2023-04-04"`` | | | | | -| | ``SYST:DATE "2002-12-29"`` | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:DATE?`` > ``date`` | | - | Returns the current date on the board. | 2.00-18 and up | -| | Examples: | | | | | -| | ``SYSTem:DATE?`` > ``2023-04-04`` | | | | | -| | ``SYST:DATE?`` > ``2002-12-29`` | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:BRD:ID?`` > ```` | | C: ``rp_IdGetID(uint32_t *id)`` | Returns the Red Pitaya board ID. | 2.00-18 and up | -| | Examples: | | | | | -| | ``SYSTem:BRD:ID?`` > ``1`` | | Python: ``rp_IdGetID()`` | | | -| | | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:BRD:Name?`` > ``board name`` | | C: ``const char* rp_GetVersion()`` | Returns the Red Pitaya board version. | 2.00-18 and up | -| | Examples: | | | | | -| | ``SYSTem:BRD:Name?`` > ``STEMlab 125-14 v1.0`` | | Python: ``rp_GetVersion()`` | | | -| | | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:VERSion?`` > ``OS version`` | | C: - | Returns the Red Pitaya OS version. | 2.07-48 and up | -| | Examples: | | | | | -| | ``SYSTem:VERSion?`` > ``2.07-651`` | | Python: - | | | -| | | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | ``SYSTem:Help?`` > ```` | | - | | Returns a list of all commands | 2.04-35 and up | -| | Examples: | | | | that the SCPI server can process. | | -| | ``SYSTem:Help?`` > ``*CLS\n*ESE\n...`` | | | | | -| | | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | - | | C: ``rp_IdGetDNA(uint64_t *dna)`` | Returns the unique DNA code of the FPGA chip. | 2.00-18 and up | -| | | | | | | -| | | | Python: ``rp_IdGetDNA()`` | | | -| | | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | - | | C: ``const char* rp_GetError(int errorCode)`` | Returns the description of the input error code. | 2.00-18 and up | -| | | | | | | -| | | | Python: ``rp_GetError()`` | | | -| | | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ -| | - | | C: ``rp_EnableDigitalLoop(bool enable)`` | | Enables/disables the Digital Loop (internal FPGA | 2.00-18 and up | -| | | | | | connection between fast analog inputs and outputs). | | -| | | | Python: ``rp_EnableDigitalLoop()`` | | | | -| | | | | | | | -+------------------------------------------------------+--------------------------------------------------+-----------------------------------------------------------+------------------------+ ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | ++======================================================+===================================================+===========================================================+========================+ +| | ``RP:LOGmode `` | | - | Enables scpi-server log output mode. | 1.04-18 and up | +| | Examples: | | | | | +| | ``RP:LOGmode SYSLOG`` | | | | | +| | | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``RP:RET_ON_ERROR `` | | N/A | | Enables a special mode for compatibility | 2.07-43 and up | +| | Examples: | | | | with older SCPI clients. When this mode is enabled, | | +| | ``RP:RET_ON_ERROR ON`` | | | | if errors occur when executing query commands, | | +| | | | | | the server will return empty data with delimiters "\r\n"| | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:TIME ,,`` | | - | Sets the time on the board. | 2.00-18 and 2.00-36 | +| | Examples: | | | | | +| | ``SYSTem:TIME 16,12,45`` | | | | | +| | ``SYST:TIME 11,23,01`` | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:TIME "::"`` | | - | Sets the time on the board. | 2.05-37 and up | +| | Examples: | | | | | +| | ``SYSTem:TIME "16:12:45"`` | | | | | +| | ``SYST:TIME "11:23:01"`` | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:TIME?`` > ``time`` | | - | Returns the current time on the board. | 2.00-18 and up | +| | Examples: | | | | | +| | ``SYSTem:TIME?`` > ``16:12:45`` | | | | | +| | ``SYST:TIME?`` > ``11:23:01`` | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:DATE ,,`` | | - | Sets the date on the board. | 2.00-18 and 2.00-36 | +| | Examples: | | | | | +| | ``SYSTem:DATE 2023,04,04`` | | | | | +| | ``SYST:DATE 2002,12,29`` | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:DATE "--"`` | | - | Sets the date on the board. | 2.05-37 and up | +| | Examples: | | | | | +| | ``SYSTem:DATE "2023-04-04"`` | | | | | +| | ``SYST:DATE "2002-12-29"`` | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:DATE?`` > ``date`` | | - | Returns the current date on the board. | 2.00-18 and up | +| | Examples: | | | | | +| | ``SYSTem:DATE?`` > ``2023-04-04`` | | | | | +| | ``SYST:DATE?`` > ``2002-12-29`` | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:BRD:ID?`` > ```` | | C++: ``rp_IdGetID(uint32_t *id)`` | Returns the Red Pitaya board ID. | 2.00-18 and up | +| | Examples: | | | | | +| | ``SYSTem:BRD:ID?`` > ``1`` | | Python: ``rp_IdGetID()`` | | | +| | | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:BRD:Name?`` > ``board name`` | | C++: ``const char* rp_GetVersion()`` | Returns the Red Pitaya board version. | 2.00-18 and up | +| | Examples: | | | | | +| | ``SYSTem:BRD:Name?`` > ``STEMlab 125-14 v1.0`` | | Python: ``rp_GetVersion()`` | | | +| | | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:VERSion?`` > ``OS version`` | | C++: - | Returns the Red Pitaya OS version. | 2.07-48 and up | +| | Examples: | | | | | +| | ``SYSTem:VERSion?`` > ``2.07-651`` | | Python: - | | | +| | | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | ``SYSTem:Help?`` > ```` | | - | | Returns a list of all commands | 2.04-35 and up | +| | Examples: | | | | that the SCPI server can process. | | +| | ``SYSTem:Help?`` > ``*CLS\n*ESE\n...`` | | | | | +| | | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | - | | C++: ``rp_IdGetDNA(uint64_t *dna)`` | Returns the unique DNA code of the FPGA chip. | 2.00-18 and up | +| | | | | | | +| | | | Python: ``rp_IdGetDNA()`` | | | +| | | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | - | | C++: ``const char* rp_GetError(int errorCode)`` | Returns the description of the input error code. | 2.00-18 and up | +| | | | | | | +| | | | Python: ``rp_GetError()`` | | | +| | | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ +| | - | | C++: ``rp_EnableDigitalLoop(bool enable)`` | | Enables/disables the Digital Loop (internal FPGA | 2.00-18 and up | +| | | | | | connection between fast analog inputs and outputs). | | +| | | | Python: ``rp_EnableDigitalLoop()`` | | | | +| | | | | | | | ++------------------------------------------------------+---------------------------------------------------+-----------------------------------------------------------+------------------------+ | * :ref:`Back to top ` -* :ref:`Back to command list ` \ No newline at end of file +* :ref:`Back to command list ` diff --git a/appsFeatures/remoteControl/command_list/commands-can.rst b/appsFeatures/remoteControl/command_list/commands-can.rst index 0d3dbcd7..4b6269d9 100644 --- a/appsFeatures/remoteControl/command_list/commands-can.rst +++ b/appsFeatures/remoteControl/command_list/commands-can.rst @@ -111,259 +111,259 @@ Parameters and command table .. tabularcolumns:: |p{50mm}|p{50mm}|p{60mm}|p{30mm}| -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | -+=====================================================================================+==============================================================================================================+=============================================================================+====================+ -| | ``CAN:FPGA `` | | C: ``rp_CanSetFPGAEnable(bool enable)`` | Enables FPGA forwarding from CAN controller to GPIO. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN:FPGA ON`` | | Python: ``rp_CanSetFPGAEnable(enable)`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:FPGA?`` > ```` | | C: ``rp_CanGetFPGAEnable(bool *state)`` | Gets the status of FPGA forwarding from CAN controller to GPIO. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN:FPGA?`` > ``ON`` | | Python: ``rp_CanGetFPGAEnable()`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:START`` | | C: ``rp_CanStart(rp_can_interface_t interface)`` | | Sets the state of the specified interface to UP. | 2.00-30 and up | -| | Example: | | | | Bitrate must be set before starting or restarting the interface. | | -| | ``CAN0:START`` | | Python: ``rp_CanStart()`` | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:STOP`` | | C: ``rp_CanStop(rp_can_interface_t interface)`` | Sets the state of the specified interface to DOWN. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:STOP`` | | Python: ``rp_CanStop()`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:RESTART`` | | C: ``rp_CanRestart(rp_can_interface_t interface)`` | | Restarts the specified interface. | 2.00-30 and up | -| | Example: | | | | Bitrate must be set before starting or restarting the interface. | | -| | ``CAN0:RESTART`` | | Python: ``rp_CanRestart()`` | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:STATE?`` > ```` | | C: ``rp_CanGetState(rp_can_interface_t interface, rp_can_state_t *state)`` | | Returns the current state of the CAN interface. | 2.00-30 and up | -| | Example: | | | | ``ERROR_ACTIVE`` - RX/TX error count < 96 | | -| | ``CAN0:STATE?`` > ``ERROR_ACTIVE`` | | Python: ``rp_CanGetState()`` | | ``ERROR_WARNING`` - RX/TX error count < 128 | | -| | | | | | ``ERROR_PASSIVE`` - RX/TX error count < 256 | | -| | | | | | ``BUS_OFF`` - RX/TX error count >= 256 | | -| | | | | | ``STOPPED`` - Device is stopped | | -| | | | | | ``SLEEPING`` - Device is sleeping | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:BITRate `` | | C: ``rp_CanSetBitrate(rp_can_interface_t interface, uint32_t bitRate)`` | | Sets the bitrate (Hz) for the specified interface. Sample point is | 2.00-30 and up | -| | Example: | | | | set automatically. | | -| | ``CAN0:BITRate 200000`` | | Python: ``rp_CanGetStateName()`` | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:BITRate:SP ,`` | | C: ``rp_CanSetBitrateAndSamplePoint(rp_can_interface_t interface, uint32_t bitRate, float samplePoint)`` | Sets the bitrate (Hz) and sample point (0.1%) for the specified interface. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:BITRate:SP 200000,0.8`` | | Python: ``rp_CanSetBitrateAndSamplePoint(, , )`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:BITRate:SP?`` > ``,`` | | C: ``rp_CanGetBitrateAndSamplePoint(rp_can_interface_t interface, uint32_t *bitRate, float *samplePoint)`` | | Shows the real bit-rate ``speed``in bits/sec and the sample-point ``sp`` | 2.00-30 and up | -| | Example: | | | | in the range 0.000...0.999. | | -| | ``CAN0:BITRate:SP?`` > ``200000,0.8`` | | Python: ``rp_CanGetBitrateAndSamplePoint()`` | | If the calculation of bit-timing parameters is enabled in the kernel | | -| | | | | | (CONFIG_CAN_CALC_BITTIMING=y), the bit-timing can be defined by setting | | -| | | | | | the "bitrate" argument. Optionally, the "sample-point" can be specified. | | -| | | | | | By default it's 0.000 assuming CIA-recommended sample-points. | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:BITTiming ,,,,,`` | | C: ``rp_CanSetBitTiming(rp_can_interface_t interface, rp_can_bittiming_t bitTiming)`` | | Set bit-timing settings. | 2.00-30 and up | -| | Example: | | | | `Bit timming info `_ | | -| | ``CAN0:BITTiming 1000,1,2,1,1,10`` | | Python: ``rp_CanSetBitTiming(, )`` | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:BITTiming?`` > ``,,,,,`` | | C: ``rp_CanGetBitTiming(rp_can_interface_t interface, rp_can_bittiming_t *bitTiming)`` | | Shows the time quanta ``tq`` in ns, propagation segment ``prop_seg``, | 2.00-30 and up | -| | Example: | | | | phase buffer segment 1 and 2 ``phase_seg1, phase_seg2``, and the | | -| | ``CAN0:BITTiming?`` > ``1000,1,2,1,1,10`` | | Python: ``rp_CanGetBitTiming(, )`` | | synchronisation jump width ``sjw`` in units of time quanta. | | -| | | | | | These settings define CAN bit timing in a hardware-independent format | | -| | | | | | proposed by Bosch CAN 2.0 specification (Chapter 8). | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:BITTiming:Limits?`` > ```` | | C: ``rp_CanGetBitTimingLimits(rp_can_interface_t interface, rp_can_bittiming_limits_t *bitTiming)`` | | Displays the CAN controller bit timing constants ("sja1000"), the | 2.00-30 and up | -| | Example: | | | | minimum and maximum values of time segment 1 and 2, the synchronisation | | -| | ``CAN0:BITTiming:Limits?`` > ``1,16,1,8,4,1,256,1`` | | Python: ``rp_CanGetBitTimingLimits(, )`` | | jump width ``swj`` in time quanta (``tq``) units, the bit rate | | -| | | | | | prescaler ``brp`` and the CAN system clock frequency in Hz. | | -| | | | | | These constants can be used for user defined (non-standard) bit timing | | -| | | | | | calculation algorithms in user space. | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:CLOCK?`` > ```` | | C: ``rp_CanGetClockFreq(rp_can_interface_t interface, uint32_t *freq)`` | Returns the CAN clock frequency in Hz. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:CLOCK?`` > ``10000000`` | | Python: ``rp_CanGetClockFreq()`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:BUS:ERROR?`` > ``,`` | | C: ``rp_CanGetBusErrorCounters(rp_can_interface_t interface, uint16_t *tx, uint16_t *rx)`` | Returns the number of errors on the RX and TX busses. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:BUS:ERROR?`` > ``0,0`` | | Python: ``rp_CanGetBusErrorCounters()`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Restart:Time `` | | C: ``rp_CanSetRestartTime(rp_can_interface_t interface, uint32_t ms)`` | | Automatic restart delay time. If set to a non-zero value, the CAN | 2.00-30 and up | -| | Example: | | | | controller will automatically restart after the specified delay time | | -| | ``CAN0:Restart:Time 10`` | | Python: ``rp_CanSetRestartTime(, )`` | | in milliseconds in the event of a bus-off condition. | | -| | | | | | Set to ``0`` (OFF) by default. | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Restart:Time?`` > ```` | | C: ``rp_CanGetRestartTime(rp_can_interface_t interface, uint32_t *ms)`` | Returns the current restart delay time (ms). | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:Restart:Time?`` > ``10`` | | Python: ``rp_CanGetRestartTime()`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:MODE ,`` | | C: ``rp_CanSetControllerMode(rp_can_interface_t interface, rp_can_mode_t mode, bool state)`` | | Sets the controller mode: | 2.00-30 and up | -| | Example: | | | | ``LOOPBACK`` - Internal connection between TX and RX | | -| | ``CAN0:MODE LOOPBACK,ON`` | | Python: ``rp_CanSetControllerMode(, , )`` | | ``LISTENONLY`` - Disabled TX, RX only, CAN bus monitoring | | -| | | | | | ``3_SAMPLES`` - Tripple sampling mode | | -| | | | | | ``ONE_SHOT`` - One shot mode | | -| | | | | | ``BERR_REPORTING`` - Buss error reporting | | -| | | | | | Multiple modes can be selected at the same time. | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:MODE? `` > ```` | | C: ``rp_CanGetControllerMode(rp_can_interface_t interface, rp_can_mode_t mode, bool *state)`` | Checks the status of the selected mode. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:MODE? LOOPBACK`` > ``ON`` | | Python: ``rp_CanGetControllerMode(, )`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:OPEN`` | | C: ``rp_CanOpen(rp_can_interface_t interface)`` | Opens a socket connection for the specified interface. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:OPEN`` | | Python: ``rp_CanOpen()`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:CLOSE`` | | C: ``rp_CanClose(rp_can_interface_t interface)`` | Closes an open connection. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:CLOSE`` | | Python: ``rp_CanClose()`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Send `` | | C: ``rp_CanSend(rp_can_interface_t interface, uint32_t canId, unsigned char *data, uint8_t dataSize,`` | | Sends the frame to the specified address ``can_id``. | 2.00-30 and up | -| | Example: | | ``bool isExtended, bool rtr, uint32_t timeout)`` | | Data exceeding 8 bytes will be ignored. | | -| | ``CAN0:Send123 1,2,3`` | | Python: ``rp_CanSend(, , , , , , )`` | | | | -| | | | | | C, Python: Option to enable RTR, Extended Frame and add timeout | | -| | | | | | (see below). | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Send:RTR `` | | C: '' (See above) | | Sends the frame to the specified address ``can_id`` marked as | 2.00-30 and up | -| | Example: | | | | the "Remote Transmission Request" (``rtr`` == true). | | -| | Example: | | Python: '' (See above) | | | | -| | ``CAN0:Send123 1,2,3`` | | | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Send:Timeout `` | | C: '' (See above) | | Sends the frame to the specified address ``can_id`` with a ``timeout`` | 2.00-30 and up | -| | Example: | | | | for sending if the send buffer is full. | | -| | ``CAN0:Send123:Timeout2000 1,2,3`` | | Python: '' (See above) | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Send:Ext`` | | C: '' (See above) | | Sends the frame to the specified address ``can_id`` using the extended | 2.00-30 and up | -| | Example: | | | | packet frame (``isExtended`` == True). | | -| | ``CAN0:Send123:Ext 1,2,3`` | | Python: '' (See above) | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Send:Timeout:Ext `` | | C: '' (See above) | | Sends the frame to the specified address ``can_id`` using the extended | 2.00-30 and up | -| | Example: | | | | packet frame (``isExtended`` == True) with a ``timeout`` for sending if | | -| | ``CAN0:Send123:Timeout2000:Ext 1,2,3`` | | Python: '' (See above) | | send buffer is full. | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Send:Timeout:RTR `` | | C: '' (See above) | | Sends the frame to the specified address ``can_id`` marked as the | 2.00-30 and up | -| | Example: | | | | "Remote Transmission Request" (``rtr`` == true). | | -| | ``CAN0:Send123:Timeout2000:RTR 1,2,3`` | | Python: '' (See above) | | There is a ``timeout`` for sending if the send buffer is full. | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Send:Ext:RTR`` | | C: '' (See above) | | Sends the frame to the specified address ``can_id`` using the extended | 2.00-30 and up | -| | Example: | | | | packet frame (``isExtended`` == True) and marked as the | | -| | ``CAN0:Send123:Ext:RTR 1,2,3`` | | Python: '' (See above) | | the "Remote Transmission Request" (``rtr`` == true). | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Send:Timeout:Ext:RTR `` | | C: '' (See above) | | Sends the frame to the specified address ``can_id`` using the extended | 2.00-30 and up | -| | Example: | | | | packet frame (``isExtended`` == True) and marked as the | | -| | ``CAN0:Send123:Timeout2000:Ext:RTR 1,2,3`` | | Python: '' (See above) | | the "Remote Transmission Request" (``rtr`` == true). | | -| | | | | | There is a ``timeout`` for sending if the send buffer is full. | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Read?`` > ```` | | C: ``rp_CanRead(rp_can_interface_t interface, uint32_t timeout, rp_can_frame_t *frame)`` | | Reads 1 frame from the specified CAN interface. | 2.00-30 and up | -| | Example: | | | | | | -| | ``CAN0:Read?`` > ``123,123,0,0,0,3,{1,2,3}`` | | Python: ``rp_CanRead(, , )`` | | | | -| | | | | | C, Python: Option to add timeout (see below). | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Read:Timeout?`` > ```` | | C: '' (See above) | | Reads 1 frame from the specified CAN interface. If no frame is received | 2.00-30 and up | -| | Example: | | | | within the ``timeout`` time, an empty frame is returned. | | -| | ``CAN0:Read:Timeout2000?`` > ``123,123,0,0,0,3,{1,2,3}`` | | Python: '' (See above) | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Filter:Add ,`` | | C: ``rp_CanAddFilter(rp_can_interface_t interface, uint32_t filter, uint32_t mask)`` | | Adds the specified "ID filter" ``filter`` (with mask ``mask``) to the | 2.00-30 and up | -| | Example: | | | | list of filters. Once all the filters have been added, the command to | | -| | ``CAN0:Filter:Add 0,0`` | | Python: ``rp_CanAddFilter(, , )`` | | apply filters to the socket must be called ``CAN:Filter:Set``. | | -| | | | | | A filter matches if `` & mask == filter & mask`` | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Filter:Remove ,`` | | C: ``rp_CanRemoveFilter(rp_can_interface_t interface, uint32_t filter, uint32_t mask)`` | | Deletes the specified "ID filter" from the filter list of the specified | 2.00-30 and up | -| | Example: | | | | CAN interface. | | -| | ``CAN0:Filter:Remove 0,0`` | | Python: ``rp_CanRemoveFilter(, , )`` | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Filter:Clear`` | | C: ``rp_CanClearFilter(rp_can_interface_t interface)`` | Removes all filters from the filter list of the specified CAN interface. | 2.00-30 and up | -| | Example: | | | | | -| | ``CAN0:Filter:Clear`` | | Python: ``rp_CanClearFilter()`` | | | -| | | | | | | -| | | | | | | -| | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:Filter:Set`` | | C: ``rp_CanSetFilter(rp_can_interface_t interface, bool isJoinFilter)`` | | Applies the list of ID filters to the socket connection of the specified | 2.00-30 and up | -| | Example: | | | | CAN interface. | | -| | ``CAN0:Filter:Set`` | | Python: ``rp_CanSetFilter(, )`` | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ -| | ``CAN:SHOW:ERROR`` | | C: ``rp_CanShowErrorFrames(rp_can_interface_t interface, bool enable)`` | | When this mode is on, all errors will be converted to data frames with | 2.00-30 and up | -| | Example: | | | | the error frame marker. | | -| | ``CAN0:SHOW:ERROR`` | | Python: ``rp_CanShowErrorFrames(, )`` | | | | -| | | | | | | | -| | | | | | | | -| | | | | | | | -+-------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | ++=====================================================================================+================================================================================================================+=============================================================================+====================+ +| | ``CAN:FPGA `` | | C++: ``rp_CanSetFPGAEnable(bool enable)`` | Enables FPGA forwarding from CAN controller to GPIO. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN:FPGA ON`` | | Python: ``rp_CanSetFPGAEnable(enable)`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:FPGA?`` > ```` | | C++: ``rp_CanGetFPGAEnable(bool *state)`` | Gets the status of FPGA forwarding from CAN controller to GPIO. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN:FPGA?`` > ``ON`` | | Python: ``rp_CanGetFPGAEnable()`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:START`` | | C++: ``rp_CanStart(rp_can_interface_t interface)`` | | Sets the state of the specified interface to UP. | 2.00-30 and up | +| | Example: | | | | Bitrate must be set before starting or restarting the interface. | | +| | ``CAN0:START`` | | Python: ``rp_CanStart()`` | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:STOP`` | | C++: ``rp_CanStop(rp_can_interface_t interface)`` | Sets the state of the specified interface to DOWN. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:STOP`` | | Python: ``rp_CanStop()`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:RESTART`` | | C++: ``rp_CanRestart(rp_can_interface_t interface)`` | | Restarts the specified interface. | 2.00-30 and up | +| | Example: | | | | Bitrate must be set before starting or restarting the interface. | | +| | ``CAN0:RESTART`` | | Python: ``rp_CanRestart()`` | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:STATE?`` > ```` | | C++: ``rp_CanGetState(rp_can_interface_t interface, rp_can_state_t *state)`` | | Returns the current state of the CAN interface. | 2.00-30 and up | +| | Example: | | | | ``ERROR_ACTIVE`` - RX/TX error count < 96 | | +| | ``CAN0:STATE?`` > ``ERROR_ACTIVE`` | | Python: ``rp_CanGetState()`` | | ``ERROR_WARNING`` - RX/TX error count < 128 | | +| | | | | | ``ERROR_PASSIVE`` - RX/TX error count < 256 | | +| | | | | | ``BUS_OFF`` - RX/TX error count >= 256 | | +| | | | | | ``STOPPED`` - Device is stopped | | +| | | | | | ``SLEEPING`` - Device is sleeping | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:BITRate `` | | C++: ``rp_CanSetBitrate(rp_can_interface_t interface, uint32_t bitRate)`` | | Sets the bitrate (Hz) for the specified interface. Sample point is | 2.00-30 and up | +| | Example: | | | | set automatically. | | +| | ``CAN0:BITRate 200000`` | | Python: ``rp_CanGetStateName()`` | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:BITRate:SP ,`` | | C++: ``rp_CanSetBitrateAndSamplePoint(rp_can_interface_t interface, uint32_t bitRate, float samplePoint)`` | Sets the bitrate (Hz) and sample point (0.1%) for the specified interface. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:BITRate:SP 200000,0.8`` | | Python: ``rp_CanSetBitrateAndSamplePoint(, , )`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:BITRate:SP?`` > ``,`` | | C++: ``rp_CanGetBitrateAndSamplePoint(rp_can_interface_t interface, uint32_t *bitRate, float *samplePoint)`` | | Shows the real bit-rate ``speed``in bits/sec and the sample-point ``sp`` | 2.00-30 and up | +| | Example: | | | | in the range 0.000...0.999. | | +| | ``CAN0:BITRate:SP?`` > ``200000,0.8`` | | Python: ``rp_CanGetBitrateAndSamplePoint()`` | | If the calculation of bit-timing parameters is enabled in the kernel | | +| | | | | | (CONFIG_CAN_CALC_BITTIMING=y), the bit-timing can be defined by setting | | +| | | | | | the "bitrate" argument. Optionally, the "sample-point" can be specified. | | +| | | | | | By default it's 0.000 assuming CIA-recommended sample-points. | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:BITTiming ,,,,,`` | | C++: ``rp_CanSetBitTiming(rp_can_interface_t interface, rp_can_bittiming_t bitTiming)`` | | Set bit-timing settings. | 2.00-30 and up | +| | Example: | | | | `Bit timming info `_ | | +| | ``CAN0:BITTiming 1000,1,2,1,1,10`` | | Python: ``rp_CanSetBitTiming(, )`` | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:BITTiming?`` > ``,,,,,`` | | C++: ``rp_CanGetBitTiming(rp_can_interface_t interface, rp_can_bittiming_t *bitTiming)`` | | Shows the time quanta ``tq`` in ns, propagation segment ``prop_seg``, | 2.00-30 and up | +| | Example: | | | | phase buffer segment 1 and 2 ``phase_seg1, phase_seg2``, and the | | +| | ``CAN0:BITTiming?`` > ``1000,1,2,1,1,10`` | | Python: ``rp_CanGetBitTiming(, )`` | | synchronisation jump width ``sjw`` in units of time quanta. | | +| | | | | | These settings define CAN bit timing in a hardware-independent format | | +| | | | | | proposed by Bosch CAN 2.0 specification (Chapter 8). | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:BITTiming:Limits?`` > ```` | | C++: ``rp_CanGetBitTimingLimits(rp_can_interface_t interface, rp_can_bittiming_limits_t *bitTiming)`` | | Displays the CAN controller bit timing constants ("sja1000"), the | 2.00-30 and up | +| | Example: | | | | minimum and maximum values of time segment 1 and 2, the synchronisation | | +| | ``CAN0:BITTiming:Limits?`` > ``1,16,1,8,4,1,256,1`` | | Python: ``rp_CanGetBitTimingLimits(, )`` | | jump width ``swj`` in time quanta (``tq``) units, the bit rate | | +| | | | | | prescaler ``brp`` and the CAN system clock frequency in Hz. | | +| | | | | | These constants can be used for user defined (non-standard) bit timing | | +| | | | | | calculation algorithms in user space. | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:CLOCK?`` > ```` | | C++: ``rp_CanGetClockFreq(rp_can_interface_t interface, uint32_t *freq)`` | Returns the CAN clock frequency in Hz. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:CLOCK?`` > ``10000000`` | | Python: ``rp_CanGetClockFreq()`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:BUS:ERROR?`` > ``,`` | | C++: ``rp_CanGetBusErrorCounters(rp_can_interface_t interface, uint16_t *tx, uint16_t *rx)`` | Returns the number of errors on the RX and TX busses. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:BUS:ERROR?`` > ``0,0`` | | Python: ``rp_CanGetBusErrorCounters()`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Restart:Time `` | | C++: ``rp_CanSetRestartTime(rp_can_interface_t interface, uint32_t ms)`` | | Automatic restart delay time. If set to a non-zero value, the CAN | 2.00-30 and up | +| | Example: | | | | controller will automatically restart after the specified delay time | | +| | ``CAN0:Restart:Time 10`` | | Python: ``rp_CanSetRestartTime(, )`` | | in milliseconds in the event of a bus-off condition. | | +| | | | | | Set to ``0`` (OFF) by default. | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Restart:Time?`` > ```` | | C++: ``rp_CanGetRestartTime(rp_can_interface_t interface, uint32_t *ms)`` | Returns the current restart delay time (ms). | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:Restart:Time?`` > ``10`` | | Python: ``rp_CanGetRestartTime()`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:MODE ,`` | | C++: ``rp_CanSetControllerMode(rp_can_interface_t interface, rp_can_mode_t mode, bool state)`` | | Sets the controller mode: | 2.00-30 and up | +| | Example: | | | | ``LOOPBACK`` - Internal connection between TX and RX | | +| | ``CAN0:MODE LOOPBACK,ON`` | | Python: ``rp_CanSetControllerMode(, , )`` | | ``LISTENONLY`` - Disabled TX, RX only, CAN bus monitoring | | +| | | | | | ``3_SAMPLES`` - Tripple sampling mode | | +| | | | | | ``ONE_SHOT`` - One shot mode | | +| | | | | | ``BERR_REPORTING`` - Buss error reporting | | +| | | | | | Multiple modes can be selected at the same time. | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:MODE? `` > ```` | | C++: ``rp_CanGetControllerMode(rp_can_interface_t interface, rp_can_mode_t mode, bool *state)`` | Checks the status of the selected mode. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:MODE? LOOPBACK`` > ``ON`` | | Python: ``rp_CanGetControllerMode(, )`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:OPEN`` | | C++: ``rp_CanOpen(rp_can_interface_t interface)`` | Opens a socket connection for the specified interface. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:OPEN`` | | Python: ``rp_CanOpen()`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:CLOSE`` | | C++: ``rp_CanClose(rp_can_interface_t interface)`` | Closes an open connection. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:CLOSE`` | | Python: ``rp_CanClose()`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Send `` | | C++: ``rp_CanSend(rp_can_interface_t interface, uint32_t canId, unsigned char *data, uint8_t dataSize,`` | | Sends the frame to the specified address ``can_id``. | 2.00-30 and up | +| | Example: | | ``bool isExtended, bool rtr, uint32_t timeout)`` | | Data exceeding 8 bytes will be ignored. | | +| | ``CAN0:Send123 1,2,3`` | | Python: ``rp_CanSend(, , , , , , )`` | | | | +| | | | | | C++, Python: Option to enable RTR, Extended Frame and add timeout | | +| | | | | | (see below). | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Send:RTR `` | | C++: '' (See above) | | Sends the frame to the specified address ``can_id`` marked as | 2.00-30 and up | +| | Example: | | | | the "Remote Transmission Request" (``rtr`` == true). | | +| | Example: | | Python: '' (See above) | | | | +| | ``CAN0:Send123 1,2,3`` | | | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Send:Timeout `` | | C++: '' (See above) | | Sends the frame to the specified address ``can_id`` with a ``timeout`` | 2.00-30 and up | +| | Example: | | | | for sending if the send buffer is full. | | +| | ``CAN0:Send123:Timeout2000 1,2,3`` | | Python: '' (See above) | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Send:Ext`` | | C++: '' (See above) | | Sends the frame to the specified address ``can_id`` using the extended | 2.00-30 and up | +| | Example: | | | | packet frame (``isExtended`` == True). | | +| | ``CAN0:Send123:Ext 1,2,3`` | | Python: '' (See above) | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Send:Timeout:Ext `` | | C++: '' (See above) | | Sends the frame to the specified address ``can_id`` using the extended | 2.00-30 and up | +| | Example: | | | | packet frame (``isExtended`` == True) with a ``timeout`` for sending if | | +| | ``CAN0:Send123:Timeout2000:Ext 1,2,3`` | | Python: '' (See above) | | send buffer is full. | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Send:Timeout:RTR `` | | C++: '' (See above) | | Sends the frame to the specified address ``can_id`` marked as the | 2.00-30 and up | +| | Example: | | | | "Remote Transmission Request" (``rtr`` == true). | | +| | ``CAN0:Send123:Timeout2000:RTR 1,2,3`` | | Python: '' (See above) | | There is a ``timeout`` for sending if the send buffer is full. | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Send:Ext:RTR`` | | C++: '' (See above) | | Sends the frame to the specified address ``can_id`` using the extended | 2.00-30 and up | +| | Example: | | | | packet frame (``isExtended`` == True) and marked as the | | +| | ``CAN0:Send123:Ext:RTR 1,2,3`` | | Python: '' (See above) | | the "Remote Transmission Request" (``rtr`` == true). | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Send:Timeout:Ext:RTR `` | | C++: '' (See above) | | Sends the frame to the specified address ``can_id`` using the extended | 2.00-30 and up | +| | Example: | | | | packet frame (``isExtended`` == True) and marked as the | | +| | ``CAN0:Send123:Timeout2000:Ext:RTR 1,2,3`` | | Python: '' (See above) | | the "Remote Transmission Request" (``rtr`` == true). | | +| | | | | | There is a ``timeout`` for sending if the send buffer is full. | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Read?`` > ```` | | C++: ``rp_CanRead(rp_can_interface_t interface, uint32_t timeout, rp_can_frame_t *frame)`` | | Reads 1 frame from the specified CAN interface. | 2.00-30 and up | +| | Example: | | | | | | +| | ``CAN0:Read?`` > ``123,123,0,0,0,3,{1,2,3}`` | | Python: ``rp_CanRead(, , )`` | | | | +| | | | | | C++, Python: Option to add timeout (see below). | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Read:Timeout?`` > ```` | | C++: '' (See above) | | Reads 1 frame from the specified CAN interface. If no frame is received | 2.00-30 and up | +| | Example: | | | | within the ``timeout`` time, an empty frame is returned. | | +| | ``CAN0:Read:Timeout2000?`` > ``123,123,0,0,0,3,{1,2,3}`` | | Python: '' (See above) | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Filter:Add ,`` | | C++: ``rp_CanAddFilter(rp_can_interface_t interface, uint32_t filter, uint32_t mask)`` | | Adds the specified "ID filter" ``filter`` (with mask ``mask``) to the | 2.00-30 and up | +| | Example: | | | | list of filters. Once all the filters have been added, the command to | | +| | ``CAN0:Filter:Add 0,0`` | | Python: ``rp_CanAddFilter(, , )`` | | apply filters to the socket must be called ``CAN:Filter:Set``. | | +| | | | | | A filter matches if `` & mask == filter & mask`` | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Filter:Remove ,`` | | C++: ``rp_CanRemoveFilter(rp_can_interface_t interface, uint32_t filter, uint32_t mask)`` | | Deletes the specified "ID filter" from the filter list of the specified | 2.00-30 and up | +| | Example: | | | | CAN interface. | | +| | ``CAN0:Filter:Remove 0,0`` | | Python: ``rp_CanRemoveFilter(, , )`` | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Filter:Clear`` | | C++: ``rp_CanClearFilter(rp_can_interface_t interface)`` | Removes all filters from the filter list of the specified CAN interface. | 2.00-30 and up | +| | Example: | | | | | +| | ``CAN0:Filter:Clear`` | | Python: ``rp_CanClearFilter()`` | | | +| | | | | | | +| | | | | | | +| | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:Filter:Set`` | | C++: ``rp_CanSetFilter(rp_can_interface_t interface, bool isJoinFilter)`` | | Applies the list of ID filters to the socket connection of the specified | 2.00-30 and up | +| | Example: | | | | CAN interface. | | +| | ``CAN0:Filter:Set`` | | Python: ``rp_CanSetFilter(, )`` | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ +| | ``CAN:SHOW:ERROR`` | | C++: ``rp_CanShowErrorFrames(rp_can_interface_t interface, bool enable)`` | | When this mode is on, all errors will be converted to data frames with | 2.00-30 and up | +| | Example: | | | | the error frame marker. | | +| | ``CAN0:SHOW:ERROR`` | | Python: ``rp_CanShowErrorFrames(, )`` | | | | +| | | | | | | | +| | | | | | | | +| | | | | | | | ++-------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------+--------------------+ | diff --git a/appsFeatures/remoteControl/command_list/commands-daisy.rst b/appsFeatures/remoteControl/command_list/commands-daisy.rst index f6c5457f..513635c9 100644 --- a/appsFeatures/remoteControl/command_list/commands-daisy.rst +++ b/appsFeatures/remoteControl/command_list/commands-daisy.rst @@ -46,72 +46,72 @@ Parameters and command table +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +===========================================+====================================================================================+============================================================================================================+===============================+ -| | ``DAISY:ENable `` | | C: ``rp_SetEnableDaisyChainSync`` | | Enables clock and trigger sync over SATA daisy chain connectors. | only 2.00-15 | +| | ``DAISY:ENable `` | | C++: ``rp_SetEnableDaisyChainSync`` | | Enables clock and trigger sync over SATA daisy chain connectors. | only 2.00-15 | | | Examples: | | | | Once the primary board will be triggered, the trigger will be forwarded to the secondary board over | | | | ``DAISY:ENable ON`` | | Python: ~ | | the SATA connector where the trigger can be detected using rp_GenTriggerSource with EXT_NE selector. | | | | | | | Noticed that the trigger that is received over SATA is ORed with the external trigger from GPIO. | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:ENable?`` > ```` | | C: ``rp_GetEnableDaisyChainSync`` | Returns the current state of the SATA daisy chain mode. | only 2.00-15 | +| | ``DAISY:ENable?`` > ```` | | C++: ``rp_GetEnableDaisyChainSync`` | Returns the current state of the SATA daisy chain mode. | only 2.00-15 | | | Examples: | | | | | | | ``DAISY:ENable?`` > ``ON`` | | Python: ~ | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:SYNC:TRIG `` | | C: ``rp_SetEnableDaisyChainTrigSync(bool enable)`` | | Enables trigger sync over SATA daisy chain connectors. Once the primary board will be triggered, | 2.00-18 and up | +| | ``DAISY:SYNC:TRIG `` | | C++: ``rp_SetEnableDaisyChainTrigSync(bool enable)`` | | Enables trigger sync over SATA daisy chain connectors. Once the primary board will be triggered, | 2.00-18 and up | | | Examples: | | | | the trigger will be forwarded to the secondary board over the SATA connector | | | | ``DAISY:SYNC:TRIG ON`` | | Python: ``rp_SetEnableDaisyChainTrigSync()`` | | where the trigger can be detected using EXT_NE selector. | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:SYNC:TRIG?`` > ```` | | C: ``rp_GetEnableDaisyChainTrigSync(bool *status)`` | | Returns the current state of the trigger synchronization using Daisy Chain. | 2.00-18 and up | +| | ``DAISY:SYNC:TRIG?`` > ```` | | C++: ``rp_GetEnableDaisyChainTrigSync(bool *status)`` | | Returns the current state of the trigger synchronization using Daisy Chain. | 2.00-18 and up | | | Examples: | | | | | | | ``DAISY:SYNC:TRIG?`` > ``ON`` | | Python: ``rp_GetEnableDaisyChainTrigSync()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:SYNC:CLK `` | | C: ``rp_SetEnableDiasyChainClockSync(bool enable)`` | | Enables clock sync over SATA daisy chain connectors. | 2.00-18 and up | +| | ``DAISY:SYNC:CLK `` | | C++: ``rp_SetEnableDiasyChainClockSync(bool enable)`` | | Enables clock sync over SATA daisy chain connectors. | 2.00-18 and up | | | Examples: | | | | The primary board will start generating a clock for the secondary unit and so on. | | | | ``DAISY:SYNC:CLK ON`` | | Python: ``rp_SetEnableDiasyChainClockSync()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:SYNC:CLK?`` > ```` | | C: ``rp_GetEnableDiasyChainClockSync(bool *state)`` | | Returns the current state of the SATA daisy chain mode. | 2.00-18 and up | +| | ``DAISY:SYNC:CLK?`` > ```` | | C++: ``rp_GetEnableDiasyChainClockSync(bool *state)`` | | Returns the current state of the SATA daisy chain mode. | 2.00-18 and up | | | Examples: | | | | | | | ``DAISY:SYNC:CLK?`` > ``ON`` | | Python: ``rp_GetEnableDiasyChainClockSync()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:TRIG_O:ENable `` | | C: ``rp_SetDpinEnableTrigOutput(bool enable)`` | | Turns DIO0_N into trigger output for selected source - acquisition or generation. | 2.00-15 - 2.00-30 | +| | ``DAISY:TRIG_O:ENable `` | | C++: ``rp_SetDpinEnableTrigOutput(bool enable)`` | | Turns DIO0_N into trigger output for selected source - acquisition or generation. | 2.00-15 - 2.00-30 | | | Examples: | | | | | | | ``DAISY:TRIG_O:ENable ON`` | | Python: ``rp_SetDpinEnableTrigOutput()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:TRig:Out:ENable `` | | C: ``rp_SetDpinEnableTrigOutput(bool enable)`` | | Turns DIO0_N into trigger output for selected source - acquisition or generation. | 2.04-35 and up | +| | ``DAISY:TRig:Out:ENable `` | | C++: ``rp_SetDpinEnableTrigOutput(bool enable)`` | | Turns DIO0_N into trigger output for selected source - acquisition or generation. | 2.04-35 and up | | | Examples: | | | | | | | ``DAISY:TRig:Out:ENable ON`` | | Python: ``rp_SetDpinEnableTrigOutput()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:TRIG_O:ENable?`` > ```` | | C: ``rp_GetDpinEnableTrigOutput(bool *state)`` | | Returns the current mode state for DIO0_N. If true, then the pin mode works as a source. | 2.00-15 - 2.00-30 | +| | ``DAISY:TRIG_O:ENable?`` > ```` | | C++: ``rp_GetDpinEnableTrigOutput(bool *state)`` | | Returns the current mode state for DIO0_N. If true, then the pin mode works as a source. | 2.00-15 - 2.00-30 | | | Examples: | | | | | | | ``DAISY:TRIG_O:ENable?`` > ``ON`` | | Python: ``rp_GetDpinEnableTrigOutput()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:TRig:Out:ENable?`` > ````| | C: ``rp_GetDpinEnableTrigOutput(bool *state)`` | | Returns the current mode state for DIO0_N. If true, then the pin mode works as a source. | 2.04-35 and up | +| | ``DAISY:TRig:Out:ENable?`` > ````| | C++: ``rp_GetDpinEnableTrigOutput(bool *state)`` | | Returns the current mode state for DIO0_N. If true, then the pin mode works as a source. | 2.04-35 and up | | | Examples: | | | | | | | ``DAISY:TRig:Out:ENable?`` > ``ON`` | | Python: ``rp_GetDpinEnableTrigOutput()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:TRIG_O:SOUR `` | | C: ``rp_SetSourceTrigOutput(rp_outTiggerMode_t mode)`` | | Sets the trigger source mode ADC/DAC. | 2.00-15 - 2.00-30 | +| | ``DAISY:TRIG_O:SOUR `` | | C++: ``rp_SetSourceTrigOutput(rp_outTiggerMode_t mode)`` | | Sets the trigger source mode ADC/DAC. | 2.00-15 - 2.00-30 | | | Examples: | | | | | | | ``DAISY:TRIG_O:SOUR DAC`` | | Python: ``rp_SetSourceTrigOutput()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:TRig:Out:SOUR `` | | C: ``rp_SetSourceTrigOutput(rp_outTiggerMode_t mode)`` | | Sets the trigger source mode ADC/DAC. | 2.04-35 and up | +| | ``DAISY:TRig:Out:SOUR `` | | C++: ``rp_SetSourceTrigOutput(rp_outTiggerMode_t mode)`` | | Sets the trigger source mode ADC/DAC. | 2.04-35 and up | | | Examples: | | | | | | | ``DAISY:TRig:Out:SOUR DAC`` | | Python: ``rp_SetSourceTrigOutput()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:TRIG_O:SOUR?`` > ```` | | C: ``rp_GetSourceTrigOutput(rp_outTiggerMode_t *mode)`` | | Returns the trigger source mode. | 2.00-15 - 2.00-30 | +| | ``DAISY:TRIG_O:SOUR?`` > ```` | | C++: ``rp_GetSourceTrigOutput(rp_outTiggerMode_t *mode)`` | | Returns the trigger source mode. | 2.00-15 - 2.00-30 | | | Examples: | | | | | | | ``DAISY:TRIG_O:SOUR?`` > ``DAC`` | | Python: ``rp_GetSourceTrigOutput()`` | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------+-------------------------------+ -| | ``DAISY:TRig:Out:SOUR?`` > ```` | | C: ``rp_GetSourceTrigOutput(rp_outTiggerMode_t *mode)`` | | Returns the trigger source mode. | 2.04-35 and up | +| | ``DAISY:TRig:Out:SOUR?`` > ```` | | C++: ``rp_GetSourceTrigOutput(rp_outTiggerMode_t *mode)`` | | Returns the trigger source mode. | 2.04-35 and up | | | Examples: | | | | | | | ``DAISY:TRig:Out:SOUR?`` > ``DAC`` | | Python: ``rp_GetSourceTrigOutput()`` | | | | | | | | | diff --git a/appsFeatures/remoteControl/command_list/commands-digital.rst b/appsFeatures/remoteControl/command_list/commands-digital.rst index 672771d7..d39b6377 100644 --- a/appsFeatures/remoteControl/command_list/commands-digital.rst +++ b/appsFeatures/remoteControl/command_list/commands-digital.rst @@ -56,58 +56,58 @@ Parameters and command table +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +=======================================+====================================================================================+===================================================================================+====================+ -| | ``DIG:RST`` | | C: ``rp_DpinReset()`` | | Sets digital pins to default values. Pins DIO1_P - DIO7_P, | 1.04-18 and up | +| | ``DIG:RST`` | | C++: ``rp_DpinReset()`` | | Sets digital pins to default values. Pins DIO1_P - DIO7_P, | 1.04-18 and up | | | Examples: | | | | RP_DIO0_N - RP_DIO7_N are set all INPUT and to LOW. LEDs are set to LOW/OFF. | | | | ``DIG:RST`` | | Python: ``rp_DpinReset()`` | | | | | | | | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | ``DIG:PIN:DIR ,`` | | C: ``rp_DpinSetDirection(rp_dpin_t pin, rp_pinDirection_t direction)`` | Set the direction of digital pins to output or input. | 1.04-18 and up | +| | ``DIG:PIN:DIR ,`` | | C++: ``rp_DpinSetDirection(rp_dpin_t pin, rp_pinDirection_t direction)`` | Set the direction of digital pins to output or input. | 1.04-18 and up | | | Examples: | | | | | | | ``DIG:PIN:DIR OUT,DIO0_N`` | | Python: ``rp_DpinSetDirection(, )`` | | | | | ``DIG:PIN:DIR IN,DIO1_P`` | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | ``DIG:PIN:DIR? `` | | C: ``rp_DpinGetDirection(rp_dpin_t pin, rp_pinDirection_t* direction)`` | Get digital input output pin direction. | 1.04-18 and up | +| | ``DIG:PIN:DIR? `` | | C++: ``rp_DpinGetDirection(rp_dpin_t pin, rp_pinDirection_t* direction)`` | Get digital input output pin direction. | 1.04-18 and up | | | Examples: | | | | | | | ``DIG:PIN:DIR? DIO0_N`` > ``OUT`` | | Python: ``rp_DpinGetDirection()`` | | | | | ``DIG:PIN:DIR? DIO1_P`` > ``IN`` | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | ``DIG:PIN ,`` | | C: ``rp_DpinSetState(rp_dpin_t pin, rp_pinState_t state)`` | | Set the state of digital outputs to 1 (HIGH) or 0 (LOW). | 1.04-18 and up | +| | ``DIG:PIN ,`` | | C++: ``rp_DpinSetState(rp_dpin_t pin, rp_pinState_t state)`` | | Set the state of digital outputs to 1 (HIGH) or 0 (LOW). | 1.04-18 and up | | | Examples: | | | | Returns a 1 (HIGH) if the pin is floating. | | | | ``DIG:PIN DIO0_N,1`` | | Python: ``rp_DpinSetState(, )`` | | | | | | ``DIG:PIN LED2,1`` | | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | ``DIG:PIN? `` > ```` | | C: ``rp_DpinGetState(rp_dpin_t pin, rp_pinState_t* state)`` | Get state of digital inputs and outputs. | 1.04-18 and up | +| | ``DIG:PIN? `` > ```` | | C++: ``rp_DpinGetState(rp_dpin_t pin, rp_pinState_t* state)`` | Get state of digital inputs and outputs. | 1.04-18 and up | | | Examples: | | | | | | | ``DIG:PIN? DIO0_N`` > ``1`` | | Python: ``rp_DpinGetState()`` | | | | | ``DIG:PIN? LED2`` > ``0`` | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_LEDSetState(uint32_t reg_state)`` | | Set the state of the 8-bit LED register. Each bit corresponds to the state | 1.04-18 and up | +| | - | | C++: ``rp_LEDSetState(uint32_t reg_state)`` | | Set the state of the 8-bit LED register. Each bit corresponds to the state | 1.04-18 and up | | | | | | | of one LED. | | | | | | Python: ``rp_LEDSetState()`` | | | | | | | | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_LEDGetState(uint32_t *reg_state)`` | | Get the state of the 8-bit LED register. Each bit corresponds to the state | 1.04-18 and up | +| | - | | C++: ``rp_LEDGetState(uint32_t *reg_state)`` | | Get the state of the 8-bit LED register. Each bit corresponds to the state | 1.04-18 and up | | | | | | | of one LED. | | | | | | Python: ``rp_LEDGetState()`` | | | | | | | | | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_GPIOnSetDirection(uint32_t reg_direction)`` | | Set the state of the DIO_N or DIO_P direction register. Each bit corresponds | 1.04-18 and up | -| | | | ``rp_GPIOnSetDirection(uint32_t reg_direction)`` | | to the direction of one DIO_N or DIO_P pin. | | +| | - | | C++: ``rp_GPIOnSetDirection(uint32_t reg_direction)`` | | Set the state of the DIO_N or DIO_P direction register. Each bit corresponds | 1.04-18 and up | +| | | | ``rp_GPIOnSetDirection(uint32_t reg_direction)`` | | to the direction of one DIO_N or DIO_P pin. | | | | | | Python: ``rp_GPIOnSetDirection()`` | | | | | | | | ``rp_GPIOpSetDirection()`` | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_GPIOnGetDirection(uint32_t *reg_direction)`` | | Get the state of the DIO_N or DIO_P direction register. Each bit corresponds | 1.04-18 and up | -| | | | ``rp_GPIOpGetDirection(uint32_t *reg_direction)`` | | to the direction of one DIO_N or DIO_P pin. | | +| | - | | C++: ``rp_GPIOnGetDirection(uint32_t *reg_direction)`` | | Get the state of the DIO_N or DIO_P direction register. Each bit corresponds | 1.04-18 and up | +| | | | ``rp_GPIOpGetDirection(uint32_t *reg_direction)`` | | to the direction of one DIO_N or DIO_P pin. | | | | | | Python: ``rp_GPIOnGetDirection()`` | | | | | | | | ``rp_GPIOpGetDirection()`` | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_GPIOnSetState(uint32_t reg_state)`` | | Set the state of the DIO_N or DIO_P state register. Each bit corresponds | 1.04-18 and up | -| | | | ``rp_GPIOpSetState(uint32_t reg_state)`` | | to the state of one DIO_N or DIO_P pin. | | +| | - | | C++: ``rp_GPIOnSetState(uint32_t reg_state)`` | | Set the state of the DIO_N or DIO_P state register. Each bit corresponds | 1.04-18 and up | +| | | | ``rp_GPIOpSetState(uint32_t reg_state)`` | | to the state of one DIO_N or DIO_P pin. | | | | | | Python: ``rp_GPIOnSetState()`` | | | | | | | | ``rp_GPIOpSetState()`` | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_GPIOnGetState(uint32_t *state)`` | | Get the state of the DIO_N or DIO_P state register. Each bit corresponds | 1.04-18 and up | -| | | | ``rp_GPIOpGetState(uint32_t *state)`` | | to the state of one DIO_N or DIO_P pin. | | +| | - | | C++: ``rp_GPIOnGetState(uint32_t *state)`` | | Get the state of the DIO_N or DIO_P state register. Each bit corresponds | 1.04-18 and up | +| | | | ``rp_GPIOpGetState(uint32_t *state)`` | | to the state of one DIO_N or DIO_P pin. | | | | | | Python: ``rp_GPIOnGetState()`` | | | | | | | | ``rp_GPIOpGetState()`` | | | | +---------------------------------------+------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+--------------------+ diff --git a/appsFeatures/remoteControl/command_list/commands-dmm.rst b/appsFeatures/remoteControl/command_list/commands-dmm.rst index f3ce2f76..c21c2b22 100644 --- a/appsFeatures/remoteControl/command_list/commands-dmm.rst +++ b/appsFeatures/remoteControl/command_list/commands-dmm.rst @@ -80,74 +80,74 @@ DMA settings +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +===========================================================+============================================================================================================================+=================================================================================+====================+ -| | ``ACQ:AXI:START?`` > ```` | | C: ``rp_AcqAxiGetMemoryRegion(uint32_t *_start, uint32_t *_size)`` | | Returns the start address of the Deep Memory region. | 2.00-18 and up | +| | ``ACQ:AXI:START?`` > ```` | | C++: ``rp_AcqAxiGetMemoryRegion(uint32_t *_start, uint32_t *_size)`` | | Returns the start address of the Deep Memory region. | 2.00-18 and up | | | Example: | | | | API: Also returns the size of the memory region. | | | | ``ACQ:AXI:START?`` > ``16777216`` | | Python: ``rp_AcqAxiGetMemoryRegion()`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:SIZE?`` > ```` | | C: ``rp_AcqAxiGetMemoryRegion(uint32_t *_start, uint32_t *_size)`` | | Get size of reserved memory for Deep Memory mode. | 2.00-18 and up | +| | ``ACQ:AXI:SIZE?`` > ```` | | C++: ``rp_AcqAxiGetMemoryRegion(uint32_t *_start, uint32_t *_size)`` | | Get size of reserved memory for Deep Memory mode. | 2.00-18 and up | | | Example: | | | | **API:** Also returns the start address of the memory region. | | | | ``ACQ:AXI:SIZE?`` > ``2097152`` | | Python: ``rp_AcqAxiGetMemoryRegion()`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:SOUR:ENable `` | | C: ``rp_AcqAxiEnable(rp_channel_t channel, bool enable)`` | Enables the specified acquisition channel in the Deep Memory Acquisition. | 2.00-18 and up | +| | ``ACQ:AXI:SOUR:ENable `` | | C++: ``rp_AcqAxiEnable(rp_channel_t channel, bool enable)`` | Enables the specified acquisition channel in the Deep Memory Acquisition. | 2.00-18 and up | | | Example: | | | | | | | ``ACQ:AXI:SOUR1:ENable ON`` | | Python: ``rp_AcqAxiEnable(, )`` | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:DEC `` | | C: ``rp_AcqAxiSetDecimationFactor(uint32_t decimation)`` | Sets the decimation used for acquiring signals in the Deep Memory Mode. | 2.00-18 and up | +| | ``ACQ:AXI:DEC `` | | C++: ``rp_AcqAxiSetDecimationFactor(uint32_t decimation)`` | Sets the decimation used for acquiring signals in the Deep Memory Mode. | 2.00-18 and up | | | Example: | | | | | | | ``ACQ:AXI:DEC 4`` | | Python: ``rp_AcqAxiSetDecimationFactor()`` | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:DEC?`` > ```` | | C: ``rp_AcqAxiGetDecimationFactor(uint32_t *decimation)`` | Returns the decimation used for acquiring signals in the Deep Memory Mode. | 2.00-18 and up | +| | ``ACQ:AXI:DEC?`` > ```` | | C++: ``rp_AcqAxiGetDecimationFactor(uint32_t *decimation)`` | Returns the decimation used for acquiring signals in the Deep Memory Mode. | 2.00-18 and up | | | Example: | | | | | | | ``ACQ:AXI:DEC?`` > ``1`` | | Python: ``rp_AcqAxiGetDecimationFactor()`` | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:DEC:CH `` | | C: ``rp_AcqAxiSetDecimationFactorCh(rp_channel_t channel, uint32_t decimation)`` | | Sets the decimation used for acquiring signals in the Deep Memory Mode. | 2.05-37 and up | +| | ``ACQ:AXI:DEC:CH `` | | C++: ``rp_AcqAxiSetDecimationFactorCh(rp_channel_t channel, uint32_t decimation)`` | | Sets the decimation used for acquiring signals in the Deep Memory Mode. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:AXI:DEC:CH1 4`` | | Python: ``rp_AcqAxiSetDecimationFactorCh(, )`` | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:DEC:CH?`` > ```` | | C: ``rp_AcqAxiGetDecimationFactorCh(rp_channel_t channel, uint32_t *decimation)`` | | Returns the decimation used for acquiring signals in the Deep Memory Mode. | 2.05-37 and up | +| | ``ACQ:AXI:DEC:CH?`` > ```` | | C++: ``rp_AcqAxiGetDecimationFactorCh(rp_channel_t channel, uint32_t *decimation)`` | | Returns the decimation used for acquiring signals in the Deep Memory Mode. | 2.05-37 and up | | | Example: | | | | Used only in split trigger mode | | | | ``ACQ:AXI:DEC:CH1?`` > ``1`` | | Python: ``rp_AcqAxiGetDecimationFactorCh()`` | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:SOUR:Trig:Dly `` | | C: ``rp_AcqAxiSetTriggerDelay(rp_channel_t channel, int32_t decimated_data_num)`` | | Sets the number of decimated data after the trigger is | 2.00-18 and up | +| | ``ACQ:AXI:SOUR:Trig:Dly `` | | C++: ``rp_AcqAxiSetTriggerDelay(rp_channel_t channel, int32_t decimated_data_num)`` | | Sets the number of decimated data after the trigger is | 2.00-18 and up | | | Example: | | | | written into memory. | | | | ``ACQ:AXI:SOUR1:Trig:Dly 2314`` | | Python: ``rp_AcqAxiSetTriggerDelay(, )`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:SOUR:Trig:Dly?`` > ````| | C: ``rp_AcqAxiGetTriggerDelay(rp_channel_t channel, int32_t *decimated_data_num)`` | | Returns the number of decimated data after the trigger is | 2.00-18 and up | +| | ``ACQ:AXI:SOUR:Trig:Dly?`` > ````| | C++: ``rp_AcqAxiGetTriggerDelay(rp_channel_t channel, int32_t *decimated_data_num)`` | | Returns the number of decimated data after the trigger is | 2.00-18 and up | | | Example: | | | | written into memory. | | | | ``ACQ:AXI:SOUR1:Trig:Dly?`` > ``2314`` | | Python: ``rp_AcqAxiGetTriggerDelay()`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:SOUR:SET:Buffer
,`` | | C: ``rp_AcqAxiSetBufferSamples(rp_channel_t channel, uint32_t address, uint32_t samples)`` | | Sets the Deep Memory buffer address and size in samples. | 2.00-18 and up | -| | Example: | | ``rp_AcqAxiSetBufferBytes(rp_channel_t channel, uint32_t address, uint32_t size)`` | | Buffer size must be a multiple of 2. | | +| | ``ACQ:AXI:SOUR:SET:Buffer
,`` | | C++: ``rp_AcqAxiSetBufferSamples(rp_channel_t channel, uint32_t address, uint32_t samples)`` | | Sets the Deep Memory buffer address and size in samples. | 2.00-18 and up | +| | Example: | | ``rp_AcqAxiSetBufferBytes(rp_channel_t channel, uint32_t address, uint32_t size)`` | | Buffer size must be a multiple of 2. | | | | ``ACQ:AXI:SOUR:SET:Buffer 16777216,512`` | | Python: ``rp_AcqAxiSetBufferSamples(,
, )`` | | | | | | | | ``rp_AcqAxiSetBufferBytes(,
, )`` | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:DATA:UNITS `` | | C: - (see ``rp_AcqAxiGetDataV`` and ``rp_AcqAxiGetDataRaw``) | | Select units in which the acquired data will be returned. | 2.00-18 and up | +| | ``ACQ:AXI:DATA:UNITS `` | | C++: - (see ``rp_AcqAxiGetDataV`` and ``rp_AcqAxiGetDataRaw``) | | Select units in which the acquired data will be returned. | 2.00-18 and up | | | Example: | | | | For API commands the units are selected with the get data function. | | | | ``ACQ:AXI:DATA:UNITS RAW`` | | Python: - (see ``rp_AcqAxiGetDataV`` and ``rp_AcqAxiGetDataRaw``) | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:DATA:UNITS?`` > ```` | | C: - (see ``rp_AcqAxiGetDataV`` and ``rp_AcqAxiGetDataRaw``) | | Get units in which the acquired data will be returned. | 2.00-18 and up | +| | ``ACQ:AXI:DATA:UNITS?`` > ```` | | C++: - (see ``rp_AcqAxiGetDataV`` and ``rp_AcqAxiGetDataRaw``) | | Get units in which the acquired data will be returned. | 2.00-18 and up | | | Example: | | | | For API commands the units are selected with the get data function. | | | | ``ACQ:AXI:DATA:UNITS?`` > ``RAW`` | | Python: - (see ``rp_AcqAxiGetDataV`` and ``rp_AcqAxiGetDataRaw``) | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | - (NA) | | C: - (look for *malloc* function online) | | Performs memory allocation and returns the requested buffer. | 2.00-18 - 2.04-35 | +| | - (NA) | | C++: - (look for *malloc* function online) | | Performs memory allocation and returns the requested buffer. | 2.00-18 - 2.04-35 | | | | | | | - ```` - how many channels will be acquired | | | | | | Python: ``rp_createBuffer(, , , , )`` | | - ```` - length of the buffer in samples (max 16384) | | | | | | | | - ``, , `` - buffer sample type, set one | | | | | | | | to ``true``, others are ``false``. | | | | | | | | For Python API specifically. Replaced by functions returning NumPy buffers. | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | - (NA) | | C: - (look for *free* function online) | | Free the allocated resources. | 2.00-18 - 2.04-35 | +| | - (NA) | | C++: - (look for *free* function online) | | Free the allocated resources. | 2.00-18 - 2.04-35 | | | | | | | - ```` - buffer to be released/freed | | | | | | Python: ``rp_deleteBuffer()`` | | For Python API specifically. | | | | | | | | Replaced by functions returning NumPy buffers. | | @@ -165,7 +165,7 @@ DMA data read - `` = {value in samples}`` Default: ``0`` - `` = {samples}`` Position inside circular buffer in samples - `` = {samples}`` Size of acquired data in samples -- ```` Array to store the data into. For Python API use ``rp_createBuffer`` and for C API use *malloc*. +- ```` Array to store the data into. For Python API use ``rp_createBuffer`` and for C++ API use *malloc*. *STEMlab 125-14 4-Input only (additional):* @@ -183,23 +183,23 @@ DMA data read +----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +====================================================+============================================================================================================================+=================================================================================+====================+ -| | ``ACQ:AXI:SOUR:TRIG:FILL?`` | | C: ``rp_AcqAxiGetBufferFillState(rp_channel_t channel, bool* state)`` | Indicates whether the Deep Memory Acquisition buffer is full of data. | 2.00-18 and up | +| | ``ACQ:AXI:SOUR:TRIG:FILL?`` | | C++: ``rp_AcqAxiGetBufferFillState(rp_channel_t channel, bool* state)`` | Indicates whether the Deep Memory Acquisition buffer is full of data. | 2.00-18 and up | | | Example: | | | | | | | ``ACQ:AXI:SOUR1:TRIG:FILL?`` > ``1`` | | Python: ``rp_AcqAxiGetBufferFillState()`` | | | | | | | | | | +----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:SOUR:Write:Pos?`` > ```` | | C: ``rp_AcqAxiGetWritePointer(rp_channel_t channel, uint32_t* pos)`` | | Returns current position of the Deep Memory Acquisition write pointer. | 2.00-18 and up | +| | ``ACQ:AXI:SOUR:Write:Pos?`` > ```` | | C++: ``rp_AcqAxiGetWritePointer(rp_channel_t channel, uint32_t* pos)`` | | Returns current position of the Deep Memory Acquisition write pointer. | 2.00-18 and up | | | Example: | | | | | | | | ``ACQ:AXI:SOUR1:Write:Pos?`` > ``1024`` | | Python: ``rp_AcqAxiGetWritePointer()`` | | | | | | | | | | | | +----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:SOUR:Trig:Pos?`` > ```` | | C: ``rp_AcqAxiGetWritePointerAtTrig(rp_channel_t channel, uint32_t* pos)`` | | Returns position of Deep Memory Acquisition write pointer at time when | 2.00-18 and up | +| | ``ACQ:AXI:SOUR:Trig:Pos?`` > ```` | | C++: ``rp_AcqAxiGetWritePointerAtTrig(rp_channel_t channel, uint32_t* pos)`` | | Returns position of Deep Memory Acquisition write pointer at time when | 2.00-18 and up | | | Example: | | | | the trigger arrived. | | | | ``ACQ:AXI:SOUR1:Trig:Pos?`` > ``512`` | | Python: ``rp_AcqAxiGetWritePointerAtTrig()`` | | | | | | | | | | | | +----------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``ACQ:AXI:SOUR:DATA:Start:N? ,`` | | C: ``rp_AcqAxiGetDataV(rp_channel_t channel, uint32_t pos, uint32_t* size, float* buffer)`` | | Read ``count`` samples from the ``pos`` position onwards. | 2.00-18 and up | -| | Example: | | ``rp_AcqAxiGetDataRaw(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)`` | | **SCPI:** Returns the value as a text array of values or a byte array. | | +| | ``ACQ:AXI:SOUR:DATA:Start:N? ,`` | | C++: ``rp_AcqAxiGetDataV(rp_channel_t channel, uint32_t pos, uint32_t* size, float* buffer)`` | | Read ``count`` samples from the ``pos`` position onwards. | 2.00-18 and up | +| | Example: | | ``rp_AcqAxiGetDataRaw(rp_channel_t channel, uint32_t pos, uint32_t* size, int16_t* buffer)`` | | **SCPI:** Returns the value as a text array of values or a byte array. | | | | ``ACQ:AXI:SOUR1:DATA:Start:N? 20,3`` > | | Python: ``rp_AcqAxiGetDataV(, , , )`` | | Depending on the ``ACQ:AXI:DATA:UNITS`` setting. | | | | ``{1.2,3.2,-1.2}`` | | ``rp_AcqAxiGetDataRaw(, , , )`` | | **API:** Returns the Deep Memory buffer in specified units from specified | | | | | | | | position and desired size. | | @@ -249,59 +249,59 @@ DMG settings +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +===========================================================+============================================================================================================================+=================================================================================+====================+ -| | ``GEN:AXI:START?`` > ```` | | C: ``rp_GenAxiGetMemoryRegion(uint32_t *_start, uint32_t *_size)`` | | Returns the start address of the Deep Memory region. | 2.07-48 and up | +| | ``GEN:AXI:START?`` > ```` | | C++: ``rp_GenAxiGetMemoryRegion(uint32_t *_start, uint32_t *_size)`` | | Returns the start address of the Deep Memory region. | 2.07-48 and up | | | Example: | | | | API: Also returns the size of the memory region. | | | | ``GEN:AXI:START?`` > ``16777216`` | | Python: ``rp_GenAxiGetMemoryRegion()`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``GEN:AXI:SIZE?`` > ```` | | C: ``rp_GenAxiGetMemoryRegion(uint32_t *_start, uint32_t *_size)`` | | Get size of reserved memory for Deep Memory mode. | 2.07-48 and up | +| | ``GEN:AXI:SIZE?`` > ```` | | C++: ``rp_GenAxiGetMemoryRegion(uint32_t *_start, uint32_t *_size)`` | | Get size of reserved memory for Deep Memory mode. | 2.07-48 and up | | | Example: | | | | **API:** Also returns the start address of the memory region. | | | | ``GEN:AXI:SIZE?`` > ``2097152`` | | Python: ``rp_GenAxiGetMemoryRegion()`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``SOUR#:AXI:RESERVE`` > ``,`` | | C: ``rp_GenAxiReserveMemory(rp_channel_t channel, uint32_t start, uint32_t end)`` | | Reserve an allocated area within the Deep Memory region for generation | 2.07-48 and up | +| | ``SOUR#:AXI:RESERVE`` > ``,`` | | C++: ``rp_GenAxiReserveMemory(rp_channel_t channel, uint32_t start, uint32_t end)`` | | Reserve an allocated area within the Deep Memory region for generation | 2.07-48 and up | | | Example: | | | | (number of Bytes). | | | | ``SOUR1:AXI:RESERVE 2097152,2197152`` | | Python: ``rp_GenAxiReserveMemory(, , )`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``SOUR#:AXI:RELEASE`` | | C: ``rp_GenAxiReleaseMemory(rp_channel_t channel)`` | | Release the reserved generation memory in the Deep Memory region. | 2.07-48 and up | +| | ``SOUR#:AXI:RELEASE`` | | C++: ``rp_GenAxiReleaseMemory(rp_channel_t channel)`` | | Release the reserved generation memory in the Deep Memory region. | 2.07-48 and up | | | Example: | | | | | | | | ``SOUR#:AXI:RELEASE`` | | Python: ``rp_GenAxiReleaseMemory()`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``SOUR#:AXI:ENable `` | | C: ``rp_GenAxiSetEnable(rp_channel_t channel, bool enable)`` | | Enables the Deep Memory Generation for the specified channel. | 2.07-48 and up | +| | ``SOUR#:AXI:ENable `` | | C++: ``rp_GenAxiSetEnable(rp_channel_t channel, bool enable)`` | | Enables the Deep Memory Generation for the specified channel. | 2.07-48 and up | | | Example: | | | | Memory region must be reserved beforehand. | | | | ``SOUR1:AXI:ENable ON`` | | Python: ``rp_GenAxiSetEnable(, )`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``SOUR#:AXI:ENable?`` > ```` | | C: ``rp_GenAxiGetEnable(rp_channel_t channel, bool* enable)`` | | Retrieves the enable state of the Deep Memory Generation for the specified | 2.07-48 and up | +| | ``SOUR#:AXI:ENable?`` > ```` | | C++: ``rp_GenAxiGetEnable(rp_channel_t channel, bool* enable)`` | | Retrieves the enable state of the Deep Memory Generation for the specified | 2.07-48 and up | | | Example: | | | | channel. | | | | ``SOUR1:AXI:ENable?`` > ``ON`` | | Python: ``rp_GenAxiGetEnable()`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``SOUR#:AXI:DEC `` | | C: ``rp_GenAxiSetDecimationFactor(rp_channel_t channel, uint32_t decimation)`` | | Sets the Data Delay Mode value (generation decimation) for Deep Memory | 2.07-48 and up | +| | ``SOUR#:AXI:DEC `` | | C++: ``rp_GenAxiSetDecimationFactor(rp_channel_t channel, uint32_t decimation)`` | | Sets the Data Delay Mode value (generation decimation) for Deep Memory | 2.07-48 and up | | | Example: | | | | Generation. Each sample remains on the DAC for ```` clock cycles, | | | | ``SOUR1:AXI:DEC 1`` | | Python: ``rp_GenAxiSetDecimationFactor(, )`` | | effectively reducing the output sample rate. | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``SOUR#:AXI:DEC?`` > ```` | | C: ``rp_GenAxiGetDecimationFactor(rp_channel_t channel, uint32_t* decimation)`` | | Retrieves the Data Delay Mode value (generation decimation) for Deep Memory | 2.07-48 and up | +| | ``SOUR#:AXI:DEC?`` > ```` | | C++: ``rp_GenAxiGetDecimationFactor(rp_channel_t channel, uint32_t* decimation)`` | | Retrieves the Data Delay Mode value (generation decimation) for Deep Memory | 2.07-48 and up | | | Example: | | | | Generation. | | | | ``SOUR1:AXI:DEC?`` > ``1`` | | Python: ``rp_GenAxiGetDecimationFactor()`` | | | | | | | | | | | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_GenAxiWriteWaveform(rp_channel_t channel, float* buffer, uint32_t length)`` | | Copies data from the NumPy buffer into the Deep Memory Generation region. The | 2.07-48 and up | +| | - | | C++: ``rp_GenAxiWriteWaveform(rp_channel_t channel, float* buffer, uint32_t length)`` | | Copies data from the NumPy buffer into the Deep Memory Generation region. The | 2.07-48 and up | | | | | | | data must be in float format and the length of the buffer must be half the | | | | | | Python: ``rp_GenAxiWriteWaveform(, )`` | | reserved DMG region (each float is converted into two int16). Values should | | | | | | | | be within full scale output range (±1 V). | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``SOUR#:AXI:OFFSET#:DATA# `` | | C: ``rp_GenAxiWriteWaveformOffset(rp_channel_t channel, uint32_t offset, float* buffer, uint32_t length)`` | | Copies data from the NumPy buffer into the Deep Memory Generation region. The | 2.07-48 and up | +| | ``SOUR#:AXI:OFFSET#:DATA# `` | | C++: ``rp_GenAxiWriteWaveformOffset(rp_channel_t channel, uint32_t offset, float* buffer, uint32_t length)`` | | Copies data from the NumPy buffer into the Deep Memory Generation region. The | 2.07-48 and up | | | Example: | | | | data must be in float format and the length of the buffer must be half the | | | | ``SOUR1:AXI:OFFSET0:DATA256 1,2,1,..`` | | Python: ``rp_GenAxiWriteWaveformOffset(, , )`` | | reserved DMG region (each float is converted into two int16). Values should | | | | | | | | be within full scale output range (±1 V). | | | | | | | | Unlike the previous function, this one adds an offset in the separators to | | | | | | | | allow writing data in portions. | | +-----------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------+--------------------+ -| | ``SOUR#:AXI:SET:CALIB`` | | C: ``rp_GenSetAmplitudeAndOffsetOrigin(rp_channel_t channel)`` | | Applies the DAC calibration values to the DMG waveform. | 2.07-48 and up | +| | ``SOUR#:AXI:SET:CALIB`` | | C++: ``rp_GenSetAmplitudeAndOffsetOrigin(rp_channel_t channel)`` | | Applies the DAC calibration values to the DMG waveform. | 2.07-48 and up | | | Example: | | | | | | | | ``SOUR1:AXI:SET:CALIB`` | | Python: ``rp_GenSetAmplitudeAndOffsetOrigin()`` | | | | | | | | | | | | diff --git a/appsFeatures/remoteControl/command_list/commands-gen.rst b/appsFeatures/remoteControl/command_list/commands-gen.rst index c6d1056a..d7fab941 100644 --- a/appsFeatures/remoteControl/command_list/commands-gen.rst +++ b/appsFeatures/remoteControl/command_list/commands-gen.rst @@ -64,27 +64,27 @@ Generator control +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +=====================================================+=========================================================================================+==============================================================================================+====================+ -| | ``GEN:RST`` | | C: ``rp_GenReset()`` | | Stops the generation and sets all generator parameters to default values. | 1.04-18 and up | +| | ``GEN:RST`` | | C++: ``rp_GenReset()`` | | Stops the generation and sets all generator parameters to default values. | 1.04-18 and up | | | | | | | | | | | | | Python: ``rp_GenReset()`` | | | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``PHAS:ALIGN`` | | C: ``rp_GenSynchronise()`` | | Synchronously triggers the generation of both fast analog outputs immediately. | 1.04-18 and up | +| | ``PHAS:ALIGN`` | | C++: ``rp_GenSynchronise()`` | | Synchronously triggers the generation of both fast analog outputs immediately. | 1.04-18 and up | | | | | | | The signal phase is aligned. | | | | | | Python: ``rp_GenSynchronise()`` | | (Same as SOUR:TRig:INT) | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``OUTPUT:STATE `` | | C: ``rp_GenOutEnable(rp_channel_t channel)`` | | Enable/disable supplying voltage to the specified fast analog output. When enabled, | 1.04-18 and up | -| | Examples: | | ``rp_GenOutDisable(rp_channel_t channel)`` | | the signal does not start generating, but the initial voltage value | | +| | ``OUTPUT:STATE `` | | C++: ``rp_GenOutEnable(rp_channel_t channel)`` | | Enable/disable supplying voltage to the specified fast analog output. When enabled, | 1.04-18 and up | +| | Examples: | | ``rp_GenOutDisable(rp_channel_t channel)`` | | the signal does not start generating, but the initial voltage value | | | | ``OUTPUT1:STATE ON`` | | Python: ``rp_GenOutEnable()`` | | (``SOUR:INITValue``, ``rp_GenSetInitGenValue``) appears on the fast analog output. | | | | | | ``rp_GenOutDisable()`` | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``OUTPUT:STATE?`` > ```` | | C: ``rp_GenOutIsEnabled(rp_channel_t channel, bool *value)`` | | Get the enable/disable supply voltage status of the specified fast analog output. | 1.04-18 and up | +| | ``OUTPUT:STATE?`` > ```` | | C++: ``rp_GenOutIsEnabled(rp_channel_t channel, bool *value)`` | | Get the enable/disable supply voltage status of the specified fast analog output. | 1.04-18 and up | | | Examples: | | | | | | | | ``OUTPUT1:STATE?`` > ``ON`` | | Python: ``rp_GenOutIsEnabled()`` | | | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``OUTPUT:STATE `` | | C: ``rp_GenOutEnableSync(bool enable)`` | | Enable/disable supplying voltage to both fast analog outputs. When enabled, the signal | 1.04-18 and up | +| | ``OUTPUT:STATE `` | | C++: ``rp_GenOutEnableSync(bool enable)`` | | Enable/disable supplying voltage to both fast analog outputs. When enabled, the signal | 1.04-18 and up | | | Examples: | | | | does not start generating, but the initial voltage value (``SOUR:INITValue``, | | | | ``OUTPUT:STATE ON`` | | Python: ``rp_GenOutEnableSync()`` | | ``rp_GenSetInitGenValue``) apperas on both fast analog outputs. | | | | | | | | | | @@ -120,57 +120,57 @@ Generator trigger +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ | SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | +=====================================================+=========================================================================================+==============================================================================================+====================+ -| | ``SOUR:TRig:SOUR `` | | C: ``rp_GenTriggerSource(rp_channel_t channel, rp_trig_src_t src)`` | | Set the trigger source for the selected signal (either internal or external). | 1.04-18 and up | +| | ``SOUR:TRig:SOUR `` | | C++: ``rp_GenTriggerSource(rp_channel_t channel, rp_trig_src_t src)`` | | Set the trigger source for the selected signal (either internal or external). | 1.04-18 and up | | | Examples: | | | | The external trigger must be a 3V3 CMOS signal. | | | | ``SOUR1:TRig:SOUR EXT_PE`` | | Python: ``rp_GenTriggerSource(, )`` | | | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRig:SOUR?`` > ```` | | C: ``rp_GenGetTriggerSource(rp_channel_t channel, rp_trig_src_t *src)`` | Get the trigger source setting. | 1.04-18 and up | +| | ``SOUR:TRig:SOUR?`` > ```` | | C++: ``rp_GenGetTriggerSource(rp_channel_t channel, rp_trig_src_t *src)`` | Get the trigger source setting. | 1.04-18 and up | | | Examples: | | | | | | | ``SOUR1:TRig:SOUR?`` > ``EXT_PE`` | | Python: ``rp_GenGetTriggerSource()`` | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_GenResetTrigger(rp_channel_t channel)`` | Reset generator settings for the specified fast analog output. | 1.04-18 and up | +| | - | | C++: ``rp_GenResetTrigger(rp_channel_t channel)`` | Reset generator settings for the specified fast analog output. | 1.04-18 and up | | | | | | | | | | | | Python: ``rp_GenResetTrigger()`` | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRig:INT`` | | C: ``rp_GenSynchronise()`` | | Synchronously triggers the generation of both fast analog outputs immediately. | 1.04-18 and up | +| | ``SOUR:TRig:INT`` | | C++: ``rp_GenSynchronise()`` | | Synchronously triggers the generation of both fast analog outputs immediately. | 1.04-18 and up | | | Examples: | | | | The signal phase is aligned. | | | | ``SOUR:TRig:INT`` | | Python: ``rp_GenSynchronise()`` | | The command resets the FPGA and the signal starts to be generated from the beginning. | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRig:INT`` | | C: ``rp_GenResetTrigger(rp_channel_t channel)`` | | Triggers the generation of the specified fast analog output immediately. | 1.04-18 and up | +| | ``SOUR:TRig:INT`` | | C++: ``rp_GenResetTrigger(rp_channel_t channel)`` | | Triggers the generation of the specified fast analog output immediately. | 1.04-18 and up | | | Examples: | | | | The command resets the FPGA and the signal starts to be generated from the beginning. | | | | ``SOUR1:TRig:INT`` | | Python: ``rp_GenResetTrigger()`` | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRig:INT:ONLY`` | | C: ``rp_GenTriggerOnlyBoth()`` | | Synchronously triggers the generation of both fast analog outputs immediately. | 2.07-43 and up | +| | ``SOUR:TRig:INT:ONLY`` | | C++: ``rp_GenTriggerOnlyBoth()`` | | Synchronously triggers the generation of both fast analog outputs immediately. | 2.07-43 and up | | | Examples: | | | | | | | | ``SOUR:TRig:INT:ONLY`` | | Python: ``rp_GenTriggerOnlyBoth()`` | | | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRig:INT:ONLY`` | | C: ``rp_GenTriggerOnly(rp_channel_t channel)`` | Triggers the generation of the specified fast analog output immediately. | 2.07-43 and up | +| | ``SOUR:TRig:INT:ONLY`` | | C++: ``rp_GenTriggerOnly(rp_channel_t channel)`` | Triggers the generation of the specified fast analog output immediately. | 2.07-43 and up | | | Examples: | | | | | | | ``SOUR1:TRig:INT:ONLY`` | | Python: ``rp_GenTriggerOnly()`` | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRig:EXT:DEBouncer[:US] `` | | C: ``rp_GenSetExtTriggerDebouncerUs(double utime)`` | Sets the external trigger generation debouncer in microseconds (value must be positive). | 2.00-15 and up | +| | ``SOUR:TRig:EXT:DEBouncer[:US] `` | | C++: ``rp_GenSetExtTriggerDebouncerUs(double utime)`` | Sets the external trigger generation debouncer in microseconds (value must be positive). | 2.00-15 and up | | | Example: | | | | | | | ``SOUR:TRig:EXT:DEBouncer:US 1`` | | Python: ``rp_GenSetExtTriggerDebouncerUs()`` | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRig:EXT:DEBouncer[:US]?`` > ```` | | C: ``rp_GenGetExtTriggerDebouncerUs(double *utime)`` | Get the external trigger generation debouncer setting in microseconds. | 2.00-15 and up | +| | ``SOUR:TRig:EXT:DEBouncer[:US]?`` > ```` | | C++: ``rp_GenGetExtTriggerDebouncerUs(double *utime)`` | Get the external trigger generation debouncer setting in microseconds. | 2.00-15 and up | | | Example: | | | | | | | ``SOUR:TRig:EXT:DEBouncer:US?`` > ``1`` | | Python: ``rp_GenSetExtTriggerDebouncerUs()`` | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``TRig:EXT:LEV `` | | C: ``rp_SetExternalTriggerLevel(float voltage)`` | Set the external trigger level in V. | 2.04-35 and up | +| | ``TRig:EXT:LEV `` | | C++: ``rp_SetExternalTriggerLevel(float voltage)`` | Set the external trigger level in V. | 2.04-35 and up | | | Example: | | | (Only SIGNALlab 250-12) | | | | ``TRig:EXT:LEV 1`` | | Python: ``rp_SetExternalTriggerLevel()`` | | | | | | | | | | +-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``TRig:EXT:LEV?`` > ```` | | C: ``rp_GetExternalTriggerLevel(float* voltage)`` | Get the external trigger level in V. | 2.04-35 and up | +| | ``TRig:EXT:LEV?`` > ```` | | C++: ``rp_GetExternalTriggerLevel(float* voltage)`` | Get the external trigger level in V. | 2.04-35 and up | | | Example: | | | (Only SIGNALlab 250-12) | | | | ``TRig:EXT:LEV?`` > ``1`` | | Python: ``rp_GetExternalTriggerLevel()`` | | | | | | | | | | @@ -211,124 +211,124 @@ Generator settings .. tabularcolumns:: |p{50mm}|p{50mm}|p{60mm}|p{30mm}| -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| SCPI | API, Jupyter | DESCRIPTION | ECOSYSTEM | -+=====================================================+=========================================================================================+==============================================================================================+====================+ -| | ``SOUR:FUNC `` | | C: ``rp_GenWaveform(rp_channel_t channel, rp_waveform_t type)`` | Set the waveform of a fast analog output. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR2:FUNC TRIANGLE`` | | Python: ``rp_GenWaveform(, )`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:FUNC?`` > ```` | | C: ``rp_GenGetWaveform(rp_channel_t channel, rp_waveform_t *type)`` | Get the waveform of a fast analog output. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR2:FUNC?`` > ``TRIANGLE`` | | Python: ``rp_GenGetWaveform()`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:FREQ:FIX `` | | C: ``rp_GenFreq(rp_channel_t channel, float frequency)`` | | Set the signal frequency of a fast analog output. | 1.04-18 and up | -| | Examples: | | | | For the ARBITRARY waveform, this is the frequency of one signal period (a buffer of | | -| | ``SOUR2:FREQ:FIX 100000`` | | Python: ``rp_GenFreq(, )`` | | 16384 samples). | | -| | | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:FREQ:FIX:Direct `` | | C: ``rp_GenFreqDirect(rp_channel_t channel, float frequency)`` | | Set the channel signal frequency in FPGA without reseting the generator and rebuilding | 2.04-35 and up | -| | Examples | | | | the signal. | | -| | ``SOUR2:FREQ:FIX:Direct 100000`` | | Python: ``rp_GenFreqDirect(, )`` | | | | -| | | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:FREQ:FIX?`` > ```` | | C: ``rp_GenGetFreq(rp_channel_t channel, float *frequency)`` | Get signal frequency of the specified channel. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR2:FREQ:FIX?`` > ``100000`` | | Python: ``rp_GenGetFreq()`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:VOLT `` | | C: ``rp_GenAmp(rp_channel_t channel, float amplitude)`` | | Set the one-way amplitude of a fast analog output in Volts. | 1.04-18 and up | -| | Examples: | | | | Amplitude + offset value must be less than the maximum output voltage range (±1 V) | | -| | ``SOUR2:VOLT 0.5`` | | Python: ``rp_GenAmp(, )`` | | (±2 V/ ±10 V (Hi-Z load) for SIGNALlab). | | -| | | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:VOLT?`` > ```` | | C: ``rp_GenGetAmp(rp_channel_t channel, float *amplitude)`` | Get the one-way amplitude of a fast analog output in Volts. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR2:VOLT?`` > ``0.5`` | | Python: ``rp_GenGetAmp()`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:VOLT:OFFS `` | | C: ``rp_GenOffset(rp_channel_t channel, float offset)`` | | Set the DC offset voltage of a fast analog output in Volts. | 1.04-18 and up | -| | Examples: | | | | Amplitude + offset value must be less than the maximum output voltage range (±1 V) | | -| | ``SOUR1:VOLT:OFFS 0.2`` | | Python: ``rp_GenOffset(, )`` | | (±2 V/ ±10 V (Hi-Z load) for SIGNALlab). | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:VOLT:OFFS?`` > ```` | | C: ``rp_GenGetOffset(rp_channel_t channel, float *offset)`` | Get the DC offset of a fast analog output in Volts. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR1:VOLT:OFFS?`` > ``0.2`` | | Python: ``rp_GenGetOffset()`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:PHAS `` | | C: ``rp_GenPhase(rp_channel_t channel, float phase)`` | | Set the phase of a fast analog output in degrees. The signal starts generating with the | 1.04-18 and up | -| | Examples: | | | | specified phase. For example, if the phase is set to 90 degrees, the signal starts | | -| | ``SOUR2:PHAS 30`` | | Python: ``rp_GenPhase(, )`` | | generating as cosine instead of sine. | | -| | | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:PHAS?`` > ```` | | C: ``rp_GenGetPhase(rp_channel_t channel, float *phase)`` | Get the phase of a fast analog output in degrees. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR2:PHAS?`` > ``30`` | | Python: ``rp_GenGetPhase()`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:DCYC `` | | C: ``rp_GenDutyCycle(rp_channel_t channel, float ratio)`` | Set the duty cycle of the PWM waveform. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR1:DCYC 0.2`` | | Python: ``rp_GenDutyCycle(, )`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:DCYC?`` > ```` | | C: ``rp_GenGetDutyCycle(rp_channel_t channel, float *ratio)`` | Get the duty cycle of the PWM waveform. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR1:DCYC`` > ``0.2`` | | Python: ``def rp_GenGetDutyCycle()`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRAC:DATA:DATA `` | | C: ``rp_GenArbWaveform(rp_channel_t channel, float *waveform, uint32_t length)`` | | Import data for one period of an arbitrary waveform (should be exactly 16384 samples). | 1.04-18 and up | -| | Examples: | | | | If fewer samples are provided, the output frequency will be higher. | | -| | ``SOUR1:TRAC:DATA:DATA 1,0.5,0.2`` | | Python: ``rp_GenArbWaveform(, , )`` | | | | -| | | | ``rp_GenArbWaveformNP(, )`` | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:TRAC:DATA:DATA?`` > ```` | | C: ``rp_GenGetArbWaveform(rp_channel_t channel, float *waveform, uint32_t *length)`` | Get the user-defined arbitrary waveform period. | 1.04-18 and up | -| | Examples: | | | | | -| | ``SOUR1:TRAC:DATA:DATA?`` > ``1,0.5,0.2`` | | Python: ``rp_GenGetArbWaveform(, )`` | | | -| | | | ``rp_GenGetArbWaveformNP(, )`` | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:LOAD `` | | C: ``rp_GenSetLoadMode(rp_channel_t channel, rp_gen_load_mode_t mode)`` | | Set the load mode for the output. When switching from INF to L50 also halves the set | 2.04-35 and up | -| | Examples: | | | | amplitude (``SOUR:VOLT``). When switching from L50 to INF the amplitude is doubled. | | -| | ``SOUR2:LOAD L50`` | | Python: ``rp_GenSetLoadMode(, )`` | | Frist set load, then set the amplitude. (SIGNALlab only) | | -| | | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:LOAD?`` > ```` | | C: ``rp_GenGetLoadMode(rp_channel_t channel, rp_gen_load_mode_t *mode)`` | Get the load mode for the output. (SIGNALlab only) | 2.04-35 and up | -| | Examples: | | | | | -| | ``SOUR2:LOAD?`` > ``L50`` | | Python: ``rp_GenGetLoadMode()`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_GenSetGainOut(rp_channel_t channel, rp_gen_gain_t gain_mode)`` | Set SIGNALlab output gain. (SIGNALlab only) | 1.04-18 and up | -| | | | | | | -| | | | Python: ``rp_GenSetGainOut(, )`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | - | | C: ``rp_GenGetGainOut(rp_channel_t channel, rp_gen_gain_t *gain_mode)`` | Get SIGNALlab output gain. (SIGNALlab only) | 1.04-18 and up | -| | | | | | | -| | | | Python: ``rp_GenGetGainOut()`` | | | -| | | | | | | -+-----------------------------------------------------+-----------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------+--------------------+ -| | ``SOUR:RISE:TIME