scpi.cpp File Reference

SCPI implementation source file. More...

#include "scpi.h"
#include "config.h"
#include "scpi_config.h"
#include "scpi_helper.h"

Include dependency graph for scpi.cpp:

Go to the source code of this file.

Functions
static void	ScpiCoreIdnQ (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Implements the *IDN? (Identification Query) command.
static void	ScpiSystemErrorCountQ (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Implements the SYSTem:ERRor:COUNt? (System Error Count Query) command.
static void	ScpiSystemErrorNextQ (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Implements the SYSTem:ERRor? (System Error Next Query) command.
static void	GetMotorEnable (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Retrieves the current motor enable state.
static void	ConfigureMotorEnable (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Configures the motor's enable state.
static void	GetConfigureMotorDutyCycleSource (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Retrieves the configured motor's duty cycle source.
static void	ConfigureMotorDutyCycle (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Configures the motor's speed input by setting the duty cycle.
static void	ConfigureMotorFrequency (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Configures the motor's operating frequency.
static void	GetConfigureMotorFrequency (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Retrieves the configured motor frequency.
static void	ConfigureMotorDirection (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Sets the motor's direction based on the input parameter.
static void	GetConfigureMotorDirection (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Retrieves the configured direction of the motor.
static void	MeasureMotorSpeed (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Measures the motor speed.
static void	MeasureMotorCurrentVBus (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Measures and returns the motor's VBUS current.
static void	MeasureMotorCurrentPhaseU (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Measures and returns the motor's phase U current.
static void	MeasureMotorCurrentPhaseV (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Measures and returns the motor's phase V current.
static void	MeasureMotorCurrentPhaseW (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Measures and returns the motor's phase W current.
static void	MeasureMotorDirection (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Measures and reports the current direction of the motor.
static void	MeasureMotorVoltage (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Measures and returns the VBUS voltage of the motor.
static void	MeasureGateDutyCycle (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Measures and returns the gate PWM duty cycle as a percentage.
static void	ConfigureMotorDutyCycleSource (SCPI_C commands, SCPI_P parameters, Stream &interface)
	Configures the motor's speed input source.
void	ScpiInit (void)
	Initializes the SCPI command parser and registers all supported commands.
void	ScpiInput (Stream &interface)
	Processes incoming data from a serial interface for SCPI commands.

Variables
SCPI_Parser	scpiParser
	Speed input source options array.
const SCPI_choice_def_t	motorDirections [2]
	Array defining the possible motor directions for SCPI commands.
const SCPI_choice_def_t	inputSources [2]
	Array defining the possible input sources for speed/duty cycle control.

Detailed Description

SCPI implementation source file.

This file contains the command handlers for the SCPI parser to recognize and execute.

Most of this code was originally written by Diego González Chávez as part of the Vrekrer SCPI Parser project.

It has been merged into the main codebase for customization and linking limitations of the Arduino IDE.

Author

Nexperia: http://www.nexperia.com

Support Page

For additional support, visit: https://www.nexperia.com/support

Author

Aanas Sayed

Date

2025/04/21

Definition in file scpi.cpp.

Function Documentation

ConfigureMotorDirection()

static void ConfigureMotorDirection ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Sets the motor's direction based on the input parameter.

This function reads a direction parameter ('FORW' or 'REVE') and sets the motor's direction accordingly by manipulating the DIRECTION_COMMAND_PIN on PORTD.

In remote mode, the DIRECTION_COMMAND_PIN is configured as an output. Setting or clearing the pin triggers the relevant software interrupt as it would in normal operation.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters containing the direction choice.
interface	The serial interface (not used).

Definition at line 445 of file scpi.cpp.

{
    uint8_t param;
 
    // read first parameter if present
    if (!ScpiParamChoice(parameters, motorDirections, MOTOR_DIRECTION_OPTIONS, param))
    {
        scpiParser.last_error = ErrorCode::MissingOrInvalidParameter;
        return;
    }
 
    if (param)
    {
        // Set the direction pin if param is 1 (DIRECTION_REVERSE)
        PORTD |= (1 << DIRECTION_COMMAND_PIN);
    }
    else
    {
        // Clear the direction pin if param is 0 (DIRECTION_FORWARD)
        PORTD &= ~(1 << DIRECTION_COMMAND_PIN);
    }
    scpiParser.last_error = ErrorCode::NoError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigureMotorDutyCycle()

static void ConfigureMotorDutyCycle ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Configures the motor's speed input by setting the duty cycle.

This function reads a double parameter (0.0 to 100.0) from the SCPI command and sets the motor's duty cycle accordingly.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters containing the duty cycle value.
interface	The serial interface (not used).

Definition at line 338 of file scpi.cpp.

{
    double param;
    if (!ScpiParamDouble(parameters, param) || param < 0.0 || param > 100.0)
    {
        scpiParser.last_error = ErrorCode::MissingOrInvalidParameter;
        return;
    }
    speedInput = param;
    scpiParser.last_error = ErrorCode::NoError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigureMotorDutyCycleSource()

static void ConfigureMotorDutyCycleSource ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Configures the motor's speed input source.

This function reads a choice parameter ('LOCAL' or 'REMOTE') from the SCPI command and sets the motor's speed input source accordingly, corresponding to SPEED_INPUT_SOURCE_LOCAL and SPEED_INPUT_SOURCE_REMOTE.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters containing the input source choice.
interface	The serial interface (not used).

Definition at line 268 of file scpi.cpp.

{
    uint8_t param;
 
    // read first parameter if present
    if (!ScpiParamChoice(parameters, inputSources, INPUT_SOURCE_OPTIONS, param))
    {
        scpiParser.last_error = ErrorCode::MissingOrInvalidParameter;
        return;
    }
 
    if (param == SPEED_INPUT_SOURCE_LOCAL)
    {
        motorConfigs.speedInputSource = SPEED_INPUT_SOURCE_LOCAL;
        return;
    }
    else
    {
        motorConfigs.speedInputSource = SPEED_INPUT_SOURCE_REMOTE;
        speedInput = 0;
        return;
    }
    scpiParser.last_error = ErrorCode::NoError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigureMotorEnable()

static void ConfigureMotorEnable ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Configures the motor's enable state.

This function reads a boolean parameter (0 or 1) from the SCPI command and sets the motor's enable state accordingly.

In remote mode, the ENABLE_PIN is configured as an output. The motor is then enabled or disabled by setting or clearing the ENABLE_PIN on the PORTD register, which triggers the relevant software interrupt as it would in normal operation.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters containing the boolean enable value.
interface	The serial interface (not used).

Definition at line 234 of file scpi.cpp.

{
    bool param;
    if (!ScpiParamBool(parameters, param))
    {
        scpiParser.last_error = ErrorCode::MissingOrInvalidParameter;
        return;
    }
    if (param)
    {
        // Set the enable pin
        PORTD |= (1 << ENABLE_PIN);
    }
    else
    {
        // Clear the enable pin
        PORTD &= ~(1 << ENABLE_PIN);
    }
 
    scpiParser.last_error = ErrorCode::NoError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigureMotorFrequency()

static void ConfigureMotorFrequency ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Configures the motor's operating frequency.

This function sets the motor's operating frequency based on the input parameter. It validates the frequency range (7183 to 100000 Hz), updates the motor configuration, and reinitializes timers after ensuring the motor is stopped.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters containing the frequency value in Hz.
interface	The serial interface (not used).

Definition at line 386 of file scpi.cpp.

{
    // Clear the enable pin to stop the motor before changing frequency
    PORTD &= ~(1 << ENABLE_PIN);
 
    uint32_t param;
 
    // Read first parameter if present and within range
    if (!ScpiParamUInt32(parameters, param) || param < F_MOSFET_MIN || param > F_MOSFET_MAX)
    {
        scpiParser.last_error = ErrorCode::MissingOrInvalidParameter;
        return;
    }
 
    // Reload the configs
    motorConfigs.tim4Freq = param;
    motorConfigs.tim4Top = (uint16_t)TIM4_TOP(motorConfigs.tim4Freq);
 
    // Wait until motor is stopped
    while (faultFlags.motorStopped == FALSE)
    {
        ;
    }
 
    // Re-init timers with the new frequency
    TimersInit();
    scpiParser.last_error = ErrorCode::NoError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetConfigureMotorDirection()

static void GetConfigureMotorDirection ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Retrieves the configured direction of the motor.

This function queries the desired direction of the motor and returns a textual representation ('FORW' or 'REVE') based on the motorFlags.desiredDirection setting.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 480 of file scpi.cpp.

{
    String name;
    ScpiChoiceToName(motorDirections, MOTOR_DIRECTION_OPTIONS, motorFlags.desiredDirection, name);
    interface.println(name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetConfigureMotorDutyCycleSource()

static void GetConfigureMotorDutyCycleSource ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Retrieves the configured motor's duty cycle source.

This function queries the currently configured source for the motor's duty cycle (either 'LOCAL' or 'REMOTE') and returns it as a string.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 307 of file scpi.cpp.

{
    String name;
    ScpiChoiceToName(inputSources, INPUT_SOURCE_OPTIONS, motorConfigs.speedInputSource, name);
    interface.println(name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetConfigureMotorFrequency()

static void GetConfigureMotorFrequency ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Retrieves the configured motor frequency.

This function queries the current frequency configuration of the motor and returns it as a double value representing the frequency in Hertz.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 425 of file scpi.cpp.

{
    interface.println(motorConfigs.tim4Freq);
}

Here is the caller graph for this function:

GetMotorEnable()

static void GetMotorEnable ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Retrieves the current motor enable state.

This function queries the current enable state of the motor and returns it as a boolean value (1 for enabled, 0 for disabled).

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 214 of file scpi.cpp.

{
    interface.println(motorFlags.enable);
}

Here is the caller graph for this function:

MeasureGateDutyCycle()

static void MeasureGateDutyCycle ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Measures and returns the gate PWM duty cycle as a percentage.

This function reads the current PWM duty cycle from Timer4's compare register (OCR4A) and calculates the percentage relative to the timer's top value. Interrupts are briefly disabled to ensure atomic reading of the 16-bit duty cycle value.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 626 of file scpi.cpp.

{
    if (motorFlags.enable == TRUE)
    {
        // Reading 16 bit register so disabling interrupts for atomic operation
        cli();
        uint16_t duty = 0xff & OCR4A;
        duty |= (0x03 & TC4H) << 8;
        sei();
 
        interface.println((double)duty / (double)motorConfigs.tim4Top * 100.0);
    }
    else
    {
        interface.println(0.0);
    }
}

Here is the caller graph for this function:

MeasureMotorCurrentPhaseU()

static void MeasureMotorCurrentPhaseU ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Measures and returns the motor's phase U current.

This function reads the ADC value for the phase U current sense, converts it to Amperes using the known gain and sense resistor value. It accounts for the ADC offset (typically around 511 for a centered reading).

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 537 of file scpi.cpp.

{
    interface.println(((double)(iphaseU - 511) * 5.0 * 1000000.0) / ((double)1023.0 * IPHASE_GAIN * IPHASE_SENSE_RESISTOR));
}

Here is the caller graph for this function:

MeasureMotorCurrentPhaseV()

static void MeasureMotorCurrentPhaseV ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Measures and returns the motor's phase V current.

This function reads the ADC value for the phase V current sense, converts it to Amperes using the known gain and sense resistor value. It accounts for the ADC offset (typically around 511 for a centered reading).

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 553 of file scpi.cpp.

{
    interface.println(((double)(iphaseV - 511) * 5.0 * 1000000.0) / ((double)1023.0 * IPHASE_GAIN * IPHASE_SENSE_RESISTOR));
}

Here is the caller graph for this function:

MeasureMotorCurrentPhaseW()

static void MeasureMotorCurrentPhaseW ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Measures and returns the motor's phase W current.

This function reads the ADC value for the phase W current sense, converts it to Amperes using the known gain and sense resistor value. It accounts for the ADC offset (typically around 511 for a centered reading).

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 569 of file scpi.cpp.

{
    interface.println(((double)(iphaseW - 511) * 5.0 * 1000000.0) / ((double)1023.0 * IPHASE_GAIN * IPHASE_SENSE_RESISTOR));
}

Here is the caller graph for this function:

MeasureMotorCurrentVBus()

static void MeasureMotorCurrentVBus ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Measures and returns the motor's VBUS current.

This function reads the ADC value for the VBUS current sense, converts it to Amperes using the known gain and sense resistor value.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 521 of file scpi.cpp.

{
    interface.println(((double)ibus * 5.0 * 1000000.0) / ((double)1023.0 * IBUS_GAIN * IBUS_SENSE_RESISTOR));
}

Here is the caller graph for this function:

MeasureMotorDirection()

static void MeasureMotorDirection ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Measures and reports the current direction of the motor.

This function checks the motorFlags.actualDirection and returns a textual representation ('FORW', 'REVE', or 'UNKN') based on the motor's sensed direction.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 585 of file scpi.cpp.

{
    if (motorFlags.actualDirection == DIRECTION_UNKNOWN)
    {
        interface.println(F("UNKN"));
    }
    else
    {
        String name;
        ScpiChoiceToName(motorDirections, MOTOR_DIRECTION_OPTIONS, motorFlags.actualDirection, name);
        interface.println(name);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

MeasureMotorSpeed()

static void MeasureMotorSpeed ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Measures the motor speed.

This function calculates and returns the motor speed in revolutions per minute (RPM). It uses the time difference between the last two commutation events and the configured motor frequency and pole count for the calculation.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 498 of file scpi.cpp.

{
    if (lastCommutationTicks == 0xffff)
    {
        interface.println(0.0);
    }
    else
    {
        interface.println(
            (motorConfigs.tim4Freq * 20.0) / (lastCommutationTicks * MOTOR_POLES));
    }
}

Here is the caller graph for this function:

MeasureMotorVoltage()

static void MeasureMotorVoltage ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Measures and returns the VBUS voltage of the motor.

This function reads the ADC value for the VBUS voltage reference and converts it to Volts using the voltage divider resistor values.

Parameters

commands	The SCPI commands (not used).
parameters	The SCPI parameters (not used).
interface	The serial interface to write the response to.

Definition at line 609 of file scpi.cpp.

{
    interface.println(((double)vbusVref * 5.0 * (VBUS_RTOP + VBUS_RBOTTOM)) / ((double)1023.0 * VBUS_RBOTTOM));
}

Here is the caller graph for this function:

ScpiCoreIdnQ()

static void ScpiCoreIdnQ ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Implements the *IDN? (Identification Query) command.

This function responds to the *IDN? command by sending the manufacturer, model, serial number (if defined), and firmware revision of the device. The identification string is formatted as: <Manufacturer>,<Model>,<SerialNumber>,<FirmwareRevision>.

Parameters

commands	The parsed SCPI commands (not used).
parameters	The parsed SCPI parameters (not used).
interface	The serial stream interface to write the response to.

Definition at line 138 of file scpi.cpp.

{
    interface.print(F(SCPI_IDN_MANUFACTURER));
    interface.print(F(","));
    interface.print(F(SCPI_IDN_MODEL));
    interface.print(F(","));
    if (SCPI_IDN_DEFAULT_SERIAL != NULL && strlen(SCPI_IDN_DEFAULT_SERIAL) > 0)
    {
        interface.print(F(SCPI_IDN_DEFAULT_SERIAL));
    }
    interface.print(F(","));
    interface.println(F(SCPI_IDN_FIRMWARE_VERSION));
}

Here is the caller graph for this function:

ScpiInit()

void ScpiInit

(

void

)

Initializes the SCPI command parser and registers all supported commands.

This function sets up the SCPI parser instance and registers the core IEEE mandated commands, required SCPI commands, and the custom motor control and measurement commands.

Definition at line 71 of file scpi.cpp.

{
    /* IEEE Mandated Commands (SCPI std V1999.0 4.1.1) */
    // "*CLS" and "*RST" are not supported
    scpiParser.RegisterCommand(F("*IDN?"), &ScpiCoreIdnQ);
 
    /* Required SCPI commands (SCPI std V1999.0 4.2.1) */
    // "SYSTem:VERSion?" and "SYSTem:ERRor:NEXT?" are not supported
    scpiParser.SetCommandTreeBase(F("SYSTem"));
    scpiParser.RegisterCommand(F(":ERRor?"), &ScpiSystemErrorNextQ);
    scpiParser.RegisterCommand(F(":ERRor:COUNt?"), &ScpiSystemErrorCountQ);
 
    /* Motor Configuration Commands */
    scpiParser.SetCommandTreeBase(F("CONFigure"));
    scpiParser.RegisterCommand(F(":ENABle"), &ConfigureMotorEnable);
    scpiParser.RegisterCommand(F(":ENABle?"), &GetMotorEnable);
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_OPEN_LOOP)
    scpiParser.RegisterCommand(F(":DUTYcycle:SOURce"), &ConfigureMotorDutyCycleSource);
    scpiParser.RegisterCommand(F(":DUTYcycle:SOURce?"), &GetConfigureMotorDutyCycleSource);
    scpiParser.RegisterCommand(F(":DUTYcycle"), &ConfigureMotorDutyCycle);
#else
    scpiParser.RegisterCommand(F(":SPEED:SOURce"), &ConfigureMotorSpeedSource);
    scpiParser.RegisterCommand(F(":SPEED:SOURce?"), &GetMotorSpeedSource);
    scpiParser.RegisterCommand(F(":SPEED"), &ConfigureMotorSpeed);
#endif
    scpiParser.RegisterCommand(F(":FREQuency"), &ConfigureMotorFrequency);
    scpiParser.RegisterCommand(F(":FREQuency?"), &GetConfigureMotorFrequency);
    scpiParser.RegisterCommand(F(":DIREction"), &ConfigureMotorDirection);
    scpiParser.RegisterCommand(F(":DIREction?"), &GetConfigureMotorDirection);
 
    /* Motor Measurement Commands */
    scpiParser.SetCommandTreeBase(F("MEASure"));
    scpiParser.RegisterCommand(F(":SPEEd?"), &MeasureMotorSpeed);
    scpiParser.RegisterCommand(F(":CURRent:IBUS?"), &MeasureMotorCurrentVBus);
    scpiParser.RegisterCommand(F(":CURRent:IPHU?"), &MeasureMotorCurrentPhaseU);
    scpiParser.RegisterCommand(F(":CURRent:IPHV?"), &MeasureMotorCurrentPhaseV);
    scpiParser.RegisterCommand(F(":CURRent:IPHW?"), &MeasureMotorCurrentPhaseW);
    scpiParser.RegisterCommand(F(":VOLTage?"), &MeasureMotorVoltage);
    scpiParser.RegisterCommand(F(":DIREction?"), &MeasureMotorDirection);
    scpiParser.RegisterCommand(F(":DUTYcycle?"), &MeasureGateDutyCycle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ScpiInput()

void ScpiInput

(

Stream &

interface

)

Processes incoming data from a serial interface for SCPI commands.

This function takes a Stream object (like Serial) and processes any received data, looking for complete SCPI commands terminated by a newline character. It then passes the command to the SCPI parser for execution.

Parameters

interface

The serial stream interface to read commands from.

Definition at line 122 of file scpi.cpp.

{
    scpiParser.ProcessInput(interface, SCPI_CMD_TERM);
}

Here is the caller graph for this function:

ScpiSystemErrorCountQ()

static void ScpiSystemErrorCountQ ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Implements the SYSTem:ERRor:COUNt? (System Error Count Query) command.

This function returns the number of errors currently in the error queue. In this simplified implementation, it returns 1 if there was a last error, and 0 otherwise.

Parameters

commands	The parsed SCPI commands (not used).
parameters	The parsed SCPI parameters (not used).
interface	The serial stream interface to write the response to.

Definition at line 163 of file scpi.cpp.

{
    interface.println(scpiParser.last_error == ErrorCode::NoError ? 0 : 1);
}

Here is the caller graph for this function:

ScpiSystemErrorNextQ()

static void ScpiSystemErrorNextQ ( SCPI_C commands, SCPI_P parameters, Stream & interface )

static

Implements the SYSTem:ERRor? (System Error Next Query) command.

This function returns the oldest error from the error queue and clears it. In this implementation, it returns a textual description of the last recorded error and then clears the last_error flag.

Parameters

commands	The parsed SCPI commands (not used).
parameters	The parsed SCPI parameters (not used).
interface	The serial stream interface to write the response to.

Definition at line 179 of file scpi.cpp.

{
    switch (scpiParser.last_error)
    {
    case ErrorCode::BufferOverflow:
        interface.println(F("Buffer overflow error"));
        break;
    case ErrorCode::Timeout:
        interface.println(F("Communication timeout error"));
        break;
    case ErrorCode::UnknownCommand:
        interface.println(F("Unknown command received"));
        break;
    case ErrorCode::NoError:
        interface.println(F("No Error"));
        break;
    case ErrorCode::MissingOrInvalidParameter:
        interface.println(F("Missing or invalid parameter"));
        break;
    default:
        interface.println(F("Unknown error"));
    }
    scpiParser.last_error = ErrorCode::NoError;
}

Here is the caller graph for this function:

Variable Documentation

inputSources

const SCPI_choice_def_t inputSources[2]

Initial value:

= {
    {"LOCA", "l", 0 },
    {"REMO", "te", 1 },
}

Array defining the possible input sources for speed/duty cycle control.

Number of speed input source options.

This array is used by the SCPI parser to interpret and represent the source of the motor's speed or duty cycle control ('LOCA' for local, 'REMO' for remote). Each entry associates a textual representation with a numerical value (e.g., SPEED_INPUT_SOURCE_LOCAL, SPEED_INPUT_SOURCE_REMOTE).

Definition at line 665 of file scpi.cpp.

                                                             {
    {"LOCA", "l", SPEED_INPUT_SOURCE_LOCAL},
    {"REMO", "te", SPEED_INPUT_SOURCE_REMOTE},
};

motorDirections

const SCPI_choice_def_t motorDirections[2]

Initial value:

= {
    {"FORW", "ard", 0 },
    {"REVE", "rse", 1 },
}

Array defining the possible motor directions for SCPI commands.

Number of motor direction options.

This array is used by the SCPI parser to interpret and represent the motor's direction ('FORW' for forward, 'REVE' for reverse). Each entry in the array associates a textual representation with a numerical value defined elsewhere (e.g., DIRECTION_FORWARD, DIRECTION_REVERSE).

Definition at line 652 of file scpi.cpp.

                                                                   {
    {"FORW", "ard", DIRECTION_FORWARD},
    {"REVE", "rse", DIRECTION_REVERSE},
};

scpiParser

SCPI_Parser scpiParser

Speed input source options array.

Definition at line 62 of file scpi.cpp.