SCPI implementation source file. More...

#include "scpi.h"

Include dependency graph for scpi.cpp:

Functions
static scpi_result_t	MeasureMotorSpeed (scpi_t *context)
	Measures the motor speed.

static scpi_result_t	MeasureMotorCurrent (scpi_t *context)
	Measures and returns the motor's current.

static scpi_result_t	MeasureMotorDirection (scpi_t *context)
	Measures and reports the current direction of the motor.

static scpi_result_t	MeasureGateVoltage (scpi_t *context)
	Measures and returns the gate voltage of the motor.

static scpi_result_t	ConfigureMotorDutyCycleSource (scpi_t *context)
	Configures the motor's speed input source.

static scpi_result_t	ConfigureMotorDutyCycle (scpi_t *context)
	Configures the motor's speed input by changing the duty cycle.

static scpi_result_t	MeasureGateDutyCycle (scpi_t *context)
	Measures and returns the gate PWM duty cycle.

static scpi_result_t	ConfigureMotorEnable (scpi_t *context)
	Configures the motor's enable state.

static scpi_result_t	GetConfigureMotorEnable (scpi_t *context)
	Retrieves the current motor enable state.

static scpi_result_t	ConfigureMotorDirection (scpi_t *context)
	Sets the motor's direction based on the input parameter.

static scpi_result_t	GetConfigureMotorDirection (scpi_t *context)
	Retrieves the configured direction of the motor.

static scpi_result_t	ConfigureMotorFrequency (scpi_t *context)
	Configures the motor's operating frequency.

static scpi_result_t	GetConfigureMotorFrequency (scpi_t *context)
	Retrieves the configured motor frequency.

static scpi_result_t	ConfigureMotorDeadTime (scpi_t *context)
	Configures the motor's dead time.

static scpi_result_t	GetConfigureMotorDeadTime (scpi_t *context)
	Retrieves the configured motor dead time.

size_t	SCPI_Write (scpi_t context, const char data, size_t len)
	Writes data to the SCPI interface.

scpi_result_t	SCPI_Flush (scpi_t *context)
	Flushes the Serial interface buffer.

int	SCPI_Error (scpi_t *context, int_fast16_t err)
	Handles SCPI errors and outputs them to the Serial interface.

scpi_result_t	SCPI_Control (scpi_t *context, scpi_ctrl_name_t ctrl, scpi_reg_val_t val)
	Handles control messages for the SCPI interface (dummy)

scpi_result_t	SCPI_Reset (scpi_t *context)
	Resets the SCPI context.

Variables
const scpi_choice_def_t	motorDirections []
	Array or enumeration of possible motor directions.

const scpi_command_t	scpi_commands []
	Array of SCPI commands.

scpi_interface_t	scpi_interface
	SCPI interface structure.

char	scpi_input_buffer [64]
	SCPI input buffer.

scpi_error_t	scpi_error_queue_data [4]
	SCPI error queue data array.

scpi_t	scpi_context
	SCPI context structure.

Detailed Description

SCPI implementation source file.

This file contains all function callbacks and type definitions necessary for SCPI implementation.

This file depends on the base SCPI parser library v2 (commit #4e87990) by Jan Breuer which was then ported by Scott Feister to the Arduino IDE, SCPI Parser Arduino Library.

Further modifications were made to the base library to allow for memory optimisation and support for the avr-gcc compiler.

Author: Nexperia: http://www.nexperia.com

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

Author: Aanas Sayed

Date: 2024/03/08

Definition in file scpi.cpp.

Function Documentation

◆ ConfigureMotorDeadTime()

static scpi_result_t ConfigureMotorDeadTime ( scpi_t * context )

static

Configures the motor's dead time.

This function sets the motor's dead time based on the input parameter. It validates the dead time range, updates the motor configuration, and reinitializes timers after ensuring the motor is stopped.

Parameters

context The SCPI context

Returns: SCPI result code indicating success (SCPI_RES_OK) or error (SCPI_RES_ERR)

Definition at line 444 of file scpi.cpp.

{
  // Clear the enable pin
  PORTD &= ~(1 << ENABLE_PIN);
 
  uint32_t param;
 
  // Read first parameter if present
  if (!SCPI_ParamUInt32(context, &param, TRUE))
  {
    return SCPI_RES_ERR;
  }
  else
  {
    // Check if within range
    if ((param < 350) | (param > 1875))
    {
      return SCPI_RES_ERR;
    }
 
    // Reload the config
    motorConfigs.tim4DeadTime = param;
 
    // Wait until motor is stopped
    while (faultFlags.motorStopped == FALSE)
    {
      ;
    }
 
    // Re-init timers
    TimersInit();
  }
 
  return SCPI_RES_OK;
}

Here is the call graph for this function:

◆ ConfigureMotorDirection()

static scpi_result_t ConfigureMotorDirection ( scpi_t * context )

static

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

This function reads a direction parameter ('FORWard' or 'REVErse') 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 as opposed to an input. Setting or clearing the pin triggers the relevant software interrupt as it would in normal operation.

Parameters

context The SCPI context

Returns: SCPI result code indicating success (SCPI_RES_OK) or error (SCPI_RES_ERR)

Definition at line 324 of file scpi.cpp.

{
  int32_t param;
 
  /* read first parameter if present */
  if (!SCPI_ParamChoice(context, motorDirections, &param, TRUE))
  {
    return SCPI_RES_ERR;
  }
  else
  {
    if (param)
    {
      // Set the direction pin if param is 1
      PORTD |= (1 << DIRECTION_COMMAND_PIN);
    }
    else
    {
      // Clear the direction pin if param is 0
      PORTD &= ~(1 << DIRECTION_COMMAND_PIN);
    }
  }
 
  return SCPI_RES_OK;
}

◆ ConfigureMotorDutyCycle()

static scpi_result_t ConfigureMotorDutyCycle ( scpi_t * context )

static

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

Parameters

context The SCPI context

Returns: SCPI result code indicating success (SCPI_RES_OK) or error (SCPI_RES_ERR)

Definition at line 175 of file scpi.cpp.

{
  double param;
 
  // Read first parameter if present
  if (!SCPI_ParamDouble(context, &param, TRUE))
  {
    return SCPI_RES_ERR;
  }
  else
  {
    // Check if within range
    if ((param < 0.0) | (param > 100.0))
    {
      return SCPI_RES_ERR;
    }
 
    speedInput = (param * SPEED_CONTROLLER_MAX_INPUT) / 100;
  }
 
  return SCPI_RES_OK;
}

◆ ConfigureMotorDutyCycleSource()

static scpi_result_t ConfigureMotorDutyCycleSource ( scpi_t * context )

static

Configures the motor's speed input source.

This function reads a boolean parameter from the SCPI command and sets the motor's source corresponding to SPEED_INPUT_SOURCE_LOCAL and SPEED_INPUT_SOURCE_REMOTE.

Parameters

context The SCPI context

Returns: SCPI result code indicating success (SCPI_RES_OK) or error (SCPI_RES_ERR)

Definition at line 140 of file scpi.cpp.

{
  scpi_bool_t param;
 
  /* read first parameter if present */
  if (!SCPI_ParamBool(context, &param, TRUE))
  {
    return SCPI_RES_ERR;
  }
  else
  {
    if (param == SPEED_INPUT_SOURCE_LOCAL)
    {
      motorConfigs.speedInputSource = SPEED_INPUT_SOURCE_LOCAL;
    }
    else
    {
      motorConfigs.speedInputSource = SPEED_INPUT_SOURCE_REMOTE;
      speedInput = 0;
    }
  }
 
  return SCPI_RES_OK;
}

◆ ConfigureMotorEnable()

static scpi_result_t ConfigureMotorEnable ( scpi_t * context )

static

Configures the motor's enable state.

This function reads a boolean parameter from the SCPI command and sets the motor's enable state accordingly.

In remote mode, the ENABLE_PIN is configured as an output as opposed to an input. 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

context The SCPI context

Returns: SCPI result code indicating success (SCPI_RES_OK) or error (SCPI_RES_ERR)

Definition at line 268 of file scpi.cpp.

{
  scpi_bool_t param;
 
  /* read first parameter if present */
  if (!SCPI_ParamBool(context, &param, TRUE))
  {
    return SCPI_RES_ERR;
  }
  else
  {
    if (param)
    {
      // Set the enable pin
      PORTD |= (1 << ENABLE_PIN);
    }
    else
    {
      // Clear the enable pin
      PORTD &= ~(1 << ENABLE_PIN);
    }
  }
 
  return SCPI_RES_OK;
}

◆ ConfigureMotorFrequency()

static scpi_result_t ConfigureMotorFrequency ( scpi_t * context )

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, updates the motor configuration, and reinitializes timers after ensuring the motor is stopped.

Parameters

context The SCPI context

Returns: SCPI result code indicating success (SCPI_RES_OK) or error (SCPI_RES_ERR)

Definition at line 381 of file scpi.cpp.

{
  // Clear the enable pin
  PORTD &= ~(1 << ENABLE_PIN);
 
  uint32_t param;
 
  // Read first parameter if present
  if (!SCPI_ParamUInt32(context, &param, TRUE))
  {
    return SCPI_RES_ERR;
  }
  else
  {
    // Check if within range
    if ((param < 7183) | (param > 100000))
    {
      return SCPI_RES_ERR;
    }
 
    // 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
    TimersInit();
  }
 
  return SCPI_RES_OK;
}

Here is the call graph for this function:

◆ GetConfigureMotorDeadTime()

static scpi_result_t GetConfigureMotorDeadTime ( scpi_t * context )

static

Retrieves the configured motor dead time.

This function queries the current dead time configuration of the motor and returns it as a double value.

Parameters

context The SCPI context

Returns: SCPI result code indicating success or failure

Definition at line 489 of file scpi.cpp.

{
  SCPI_ResultDouble(context, (double)motorConfigs.tim4DeadTime);
 
  return SCPI_RES_OK;
}

◆ GetConfigureMotorDirection()

static scpi_result_t GetConfigureMotorDirection ( scpi_t * context )

static

Retrieves the configured direction of the motor.

This function queries the desired direction of the motor and returns a textual representation ('FORWard' or 'REVErse') based on the motor's desired direction setting.

Parameters

context The SCPI context

Returns: SCPI result code indicating success or failure

Definition at line 360 of file scpi.cpp.

{
  const char *name;
 
  SCPI_ChoiceToName(motorDirections, motorFlags.desiredDirection, &name);
 
  SCPI_ResultText(context, name);
 
  return SCPI_RES_OK;
}

◆ GetConfigureMotorEnable()

static scpi_result_t GetConfigureMotorEnable ( scpi_t * context )

static

Retrieves the current motor enable state.

This function queries the current enable state of the motor and returns it as a boolean value.

Parameters

context The SCPI context

Returns: SCPI result code indicating success or failure

Definition at line 303 of file scpi.cpp.

{
  SCPI_ResultBool(context, (scpi_bool_t)motorFlags.enable);
 
  return SCPI_RES_OK;
}

◆ GetConfigureMotorFrequency()

static scpi_result_t GetConfigureMotorFrequency ( scpi_t * context )

static

Retrieves the configured motor frequency.

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

Parameters

context The SCPI context

Returns: SCPI result code indicating success or failure

Definition at line 427 of file scpi.cpp.

{
  SCPI_ResultDouble(context, (double)motorConfigs.tim4Freq);
 
  return SCPI_RES_OK;
}

◆ MeasureGateDutyCycle()

static scpi_result_t MeasureGateDutyCycle ( scpi_t * context )

static

Measures and returns the gate PWM duty cycle.

Parameters

context The SCPI context

Returns: SCPI result code indicating success or failure

Definition at line 234 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();
 
    SCPI_ResultDouble(context, ((double)duty / (double)motorConfigs.tim4Top * 100));
  }
  else
  {
    SCPI_ResultDouble(context, 0);
  }
 
  return SCPI_RES_OK;
}

◆ MeasureGateVoltage()

static scpi_result_t MeasureGateVoltage ( scpi_t * context )

static

Measures and returns the gate voltage of the motor.

This function calculates the gate voltage of the motor using the gate voltage reference value and returns it in Volts.

Parameters

context The SCPI context

Returns: SCPI result code indicating success or failure

Definition at line 122 of file scpi.cpp.

{
  SCPI_ResultDouble(context, ((double)gateVref * 5 * (GATE_RTOP + GATE_RBOTTOM)) / ((double)1024 * GATE_RBOTTOM));
 
  return SCPI_RES_OK;
}

◆ MeasureMotorCurrent()

static scpi_result_t MeasureMotorCurrent ( scpi_t * context )

static

Measures and returns the motor's current.

This function calculates the current being used by the motor and returns it in Amperes.

Parameters

context The SCPI context

Returns: SCPI result code indicating success or failure

Definition at line 78 of file scpi.cpp.

{
  SCPI_ResultDouble(context, ((double)current * 5 * 1000000) / ((double)1024 * CURRENT_GAIN * CURRENT_SENSE_RESISTOR));
 
  return SCPI_RES_OK;
}

◆ MeasureMotorDirection()

static scpi_result_t MeasureMotorDirection ( scpi_t * context )

static

Measures and reports the current direction of the motor.

This function checks the current direction of the motor and returns a textual representation ('FORWard', 'REVErse', or 'UNKNown') based on the motor's actual direction.

Parameters

context The SCPI context

Returns: SCPI result code indicating success or failure

Definition at line 95 of file scpi.cpp.

{
  if (motorFlags.actualDirection == DIRECTION_UNKNOWN)
  {
    SCPI_ResultText(context, "UNKNown");
  }
  else
  {
    const char *name;
 
    SCPI_ChoiceToName(motorDirections, motorFlags.actualDirection, &name);
 
    SCPI_ResultText(context, name);
  }
 
  return SCPI_RES_OK;
}

◆ MeasureMotorSpeed()

static scpi_result_t MeasureMotorSpeed ( scpi_t * context )

static

Measures the motor speed.

This function calculates and returns the motor speed in revolutions per minute (RPM).

Parameters

context The SCPI context

Returns: SCPI result code indicating successful operation

Definition at line 55 of file scpi.cpp.

{
  if (lastCommutationTicks == 0xffff)
  {
    SCPI_ResultDouble(context, 0);
  }
  else
  {
    SCPI_ResultDouble(context, ((motorConfigs.tim4Freq * 20) / (lastCommutationTicks * MOTOR_POLES)));
  }
 
  return SCPI_RES_OK;
}

◆ SCPI_Control()

scpi_result_t SCPI_Control	(	scpi_t *	context,
		scpi_ctrl_name_t	ctrl,
		scpi_reg_val_t	val )

Handles control messages for the SCPI interface (dummy)

This function processes control messages such as SRQ (Service Request) or other control signals. It outputs relevant information to the Serial interface. Used as a callback in the SCPI interface structure.

Note: Dummy function implemented here.

Parameters

context	The SCPI context
ctrl	The control name/type
val	The control value

Returns: SCPI result code indicating successful operation

Definition at line 605 of file scpi.cpp.

{
  (void)context;
 
  return SCPI_RES_OK;
}

◆ SCPI_Error()

int SCPI_Error	(	scpi_t *	context,
		int_fast16_t	err )

Handles SCPI errors and outputs them to the Serial interface.

This function processes and displays SCPI error messages. It is used as a callback in the SCPI interface structure for error handling.

Parameters

context	The SCPI context
err	The error code

Returns: Always returns 0

Definition at line 581 of file scpi.cpp.

{
  (void)context;
#if (REMOTE_DEBUG_MODE == TRUE)
  Serial.print(err);
  Serial.print(", \"");
  Serial.print(SCPI_ErrorTranslate(err));
  Serial.println("\"");
#endif
  return 0;
}

◆ SCPI_Flush()

scpi_result_t SCPI_Flush ( scpi_t * context )

Flushes the Serial interface buffer.

This function ensures that all pending Serial data is transmitted. It acts as a callback for the SCPI interface structure.

Parameters

context The SCPI context

Returns: SCPI result code indicating successful operation

Definition at line 565 of file scpi.cpp.

{
  (void)context;
  Serial.flush();
  return SCPI_RES_OK;
}

◆ SCPI_Reset()

scpi_result_t SCPI_Reset ( scpi_t * context )

Resets the SCPI context.

This function is called to reset the SCPI environment. It outputs a reset message to the Serial interface and is used as a callback in the SCPI interface structure.

Parameters

context The SCPI context

Returns: SCPI result code indicating successful operation

Definition at line 622 of file scpi.cpp.

{
  (void)context;
 
  // Clear the enable pin
  PORTD &= ~(1 << ENABLE_PIN);
 
  // Wait until motor is stopped
  while (faultFlags.motorStopped == FALSE)
  {
    ;
  }
 
  // Reset configurations
  ConfigsInit();
 
  // Re-init timers
  TimersInit();
 
  return SCPI_RES_OK;
}

Here is the call graph for this function:

◆ SCPI_Write()

size_t SCPI_Write	(	scpi_t *	context,
		const char *	data,
		size_t	len )

Writes data to the SCPI interface.

This function is responsible for writing data to the Serial interface. It is used as a callback in the SCPI interface structure.

Parameters

context	The SCPI context
data	Pointer to the data to be written
len	Length of the data to be written

Returns: The number of bytes written

Definition at line 549 of file scpi.cpp.

{
  (void)context;
  Serial.write(data, len);
  return len;
}

Variable Documentation

◆ motorDirections

const scpi_choice_def_t motorDirections[]

Initial value:

= {
    {"FORWard",  0 },
    {"REVErse",  1 },
     {NULL, -1}  
}

Array or enumeration of possible motor directions.

This defines the possible directions in which the motor can move, i.e. forward, reverse. It is used in SCPI commands to set or query the motor's current direction. Each direction is typically associated with a specific command or numeric value.

Definition at line 40 of file scpi.cpp.

                                            {
    {"FORWard", DIRECTION_FORWARD},
    {"REVErse", DIRECTION_REVERSE},
    SCPI_CHOICE_LIST_END /* termination of option list */
};

◆ scpi_commands

const scpi_command_t scpi_commands[]

Array of SCPI commands.

This array contains the definitions of all SCPI commands that the system recognizes. Each command is defined with its pattern, callback function, and associated context. The array is stored in program memory (PROGMEM) to optimize memory usage.

Definition at line 504 of file scpi.cpp.

                                               {
    /* IEEE Mandated Commands (SCPI std V1999.0 4.1.1) */
    {"*CLS", SCPI_CoreCls, 0},
    {"*IDN?", SCPI_CoreIdnQ, 0},
    {"*RST", SCPI_CoreRst, 0},
 
    /* Required SCPI commands (SCPI std V1999.0 4.2.1) */
    {"SYSTem:ERRor[:NEXT]?", SCPI_SystemErrorNextQ, 0},
    {"SYSTem:ERRor:COUNt?", SCPI_SystemErrorCountQ, 0},
    {"SYSTem:VERSion?", SCPI_SystemVersionQ, 0},
 
    /* Motor */
    {"CONFigure:MOTOr:ENABle", ConfigureMotorEnable, 0},
    {"CONFigure:MOTOr:ENABle?", GetConfigureMotorEnable, 0},
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_OPEN_LOOP)
    {"CONFigure:MOTOr:GATE:DUTYcycle:SOURce", ConfigureMotorDutyCycleSource, 0},
    {"CONFigure:MOTOr:GATE:DUTYcycle", ConfigureMotorDutyCycle, 0},
#else
    {"CONFigure:MOTOr:SPEED:SOURce", ConfigureMotorSpeedSource, 0},
    {"CONFigure:MOTOr:SPEED", ConfigureMotorSpeed, 0},
#endif
    {"CONFigure:MOTOr:GATE:FREQuency", ConfigureMotorFrequency, 0},
    {"CONFigure:MOTOr:GATE:FREQuency?", GetConfigureMotorFrequency, 0},
    {"CONFigure:MOTOr:GATE:DEADtime", ConfigureMotorDeadTime, 0},
    {"CONFigure:MOTOr:GATE:DEADtime?", GetConfigureMotorDeadTime, 0},
    {"CONFigure:MOTOr:DIREction", ConfigureMotorDirection, 0},
    {"CONFigure:MOTOr:DIREction?", GetConfigureMotorDirection, 0},
    {"MEASure:MOTOr:SPEEd?", MeasureMotorSpeed, 0},
    {"MEASure:MOTOr:CURRent?", MeasureMotorCurrent, 0},
    {"MEASure:MOTOr:DIREction?", MeasureMotorDirection, 0},
    {"MEASure:MOTOr:GATE:VOLTage?", MeasureGateVoltage, 0},
    {"MEASure:MOTOr:GATE:DUTYcycle?", MeasureGateDutyCycle, 0},
 
    SCPI_CMD_LIST_END};

◆ scpi_context

scpi_t scpi_context

SCPI context structure.

This structure holds the context for SCPI operations, encapsulating state and configuration information.

Definition at line 681 of file scpi.cpp.

◆ scpi_error_queue_data

scpi_error_t scpi_error_queue_data[4]

SCPI error queue data array.

Array for storing SCPI errors. Its size is defined by SCPI_ERROR_QUEUE_SIZE.

Definition at line 673 of file scpi.cpp.

◆ scpi_input_buffer

char scpi_input_buffer[64]

SCPI input buffer.

Array for storing incoming SCPI commands. Its size is defined by SCPI_INPUT_BUFFER_LENGTH.

Definition at line 665 of file scpi.cpp.

◆ scpi_interface

scpi_interface_t scpi_interface

Initial value:

= {
     SCPI_Error,     
     SCPI_Write,     
     SCPI_Control, 
     SCPI_Flush,     
     SCPI_Reset,     
}

SCPI interface structure.

This structure defines the callbacks for various SCPI interface operations like error handling, writing to an output, control functions, flushing the output, and resetting the interface.

Definition at line 651 of file scpi.cpp.

                                  {
    /*.error = */ SCPI_Error,     
    /*.write = */ SCPI_Write,     
    /*.control = */ SCPI_Control, 
    /*.flush = */ SCPI_Flush,     
    /*.reset = */ SCPI_Reset,     
};

Functions

Variables

Detailed Description

Function Documentation

◆ ConfigureMotorDeadTime()

◆ ConfigureMotorDirection()

◆ ConfigureMotorDutyCycle()

◆ ConfigureMotorDutyCycleSource()

◆ ConfigureMotorEnable()

◆ ConfigureMotorFrequency()

◆ GetConfigureMotorDeadTime()

◆ GetConfigureMotorDirection()

◆ GetConfigureMotorEnable()

◆ GetConfigureMotorFrequency()

◆ MeasureGateDutyCycle()

◆ MeasureGateVoltage()

◆ MeasureMotorCurrent()

◆ MeasureMotorDirection()

◆ MeasureMotorSpeed()

◆ SCPI_Control()

◆ SCPI_Error()

◆ SCPI_Flush()

◆ SCPI_Reset()

◆ SCPI_Write()

Variable Documentation

◆ motorDirections

◆ scpi_commands

◆ scpi_context

◆ scpi_error_queue_data

◆ scpi_input_buffer

◆ scpi_interface