scpi.cpp

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#include "scpi.h"
 
const scpi_choice_def_t motorDirections[] = {
    {"FORWard", DIRECTION_FORWARD},
    {"REVErse", DIRECTION_REVERSE},
    SCPI_CHOICE_LIST_END /* termination of option list */
};
 
static scpi_result_t MeasureMotorSpeed(scpi_t *context)
{
  if (lastCommutationTicks == 0xffff)
  {
    SCPI_ResultDouble(context, 0);
  }
  else
  {
    SCPI_ResultDouble(context, ((motorConfigs.tim4Freq * 20) / (lastCommutationTicks * MOTOR_POLES)));
  }
 
  return SCPI_RES_OK;
}
 
static scpi_result_t MeasureMotorCurrent(scpi_t *context)
{
  SCPI_ResultDouble(context, ((double)current * 5 * 1000000) / ((double)1024 * CURRENT_GAIN * CURRENT_SENSE_RESISTOR));
 
  return SCPI_RES_OK;
}
 
static scpi_result_t MeasureMotorDirection(scpi_t *context)
{
  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;
}
 
static scpi_result_t MeasureGateVoltage(scpi_t *context)
{
  SCPI_ResultDouble(context, ((double)gateVref * 5 * (GATE_RTOP + GATE_RBOTTOM)) / ((double)1024 * GATE_RBOTTOM));
 
  return SCPI_RES_OK;
}
 
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_OPEN_LOOP)
static scpi_result_t ConfigureMotorDutyCycleSource(scpi_t *context)
#elif (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
static scpi_result_t ConfigureMotorSpeedSource(scpi_t *context)
#endif
{
  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;
}
 
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_OPEN_LOOP)
static scpi_result_t ConfigureMotorDutyCycle(scpi_t *context)
{
  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;
}
#elif (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
static scpi_result_t ConfigureMotorSpeed(scpi_t *context)
{
  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 > ((((uint32_t)SPEED_CONTROLLER_MAX_SPEED * 15) << 3) / MOTOR_POLES))
    {
      return SCPI_RES_ERR;
    }
 
    speedInput = ((param * SPEED_CONTROLLER_MAX_INPUT * MOTOR_POLES) >> 3) / ((uint32_t)SPEED_CONTROLLER_MAX_SPEED * 15);
  }
 
  return SCPI_RES_OK;
}
#endif
 
static scpi_result_t MeasureGateDutyCycle(scpi_t *context)
{
  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;
}
 
static scpi_result_t ConfigureMotorEnable(scpi_t *context)
{
  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;
}
 
static scpi_result_t GetConfigureMotorEnable(scpi_t *context)
{
  SCPI_ResultBool(context, (scpi_bool_t)motorFlags.enable);
 
  return SCPI_RES_OK;
}
 
static scpi_result_t ConfigureMotorDirection(scpi_t *context)
{
  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;
}
 
static scpi_result_t GetConfigureMotorDirection(scpi_t *context)
{
  const char *name;
 
  SCPI_ChoiceToName(motorDirections, motorFlags.desiredDirection, &name);
 
  SCPI_ResultText(context, name);
 
  return SCPI_RES_OK;
}
 
static scpi_result_t ConfigureMotorFrequency(scpi_t *context)
{
  // 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;
}
 
static scpi_result_t GetConfigureMotorFrequency(scpi_t *context)
{
  SCPI_ResultDouble(context, (double)motorConfigs.tim4Freq);
 
  return SCPI_RES_OK;
}
 
static scpi_result_t ConfigureMotorDeadTime(scpi_t *context)
{
  // 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;
}
 
static scpi_result_t GetConfigureMotorDeadTime(scpi_t *context)
{
  SCPI_ResultDouble(context, (double)motorConfigs.tim4DeadTime);
 
  return SCPI_RES_OK;
}
 
const scpi_command_t scpi_commands[] PROGMEM = {
    /* 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};
 
size_t SCPI_Write(scpi_t *context, const char *data, size_t len)
{
  (void)context;
  Serial.write(data, len);
  return len;
}
 
scpi_result_t SCPI_Flush(scpi_t *context)
{
  (void)context;
  Serial.flush();
  return SCPI_RES_OK;
}
 
int SCPI_Error(scpi_t *context, int_fast16_t err)
{
  (void)context;
#if (REMOTE_DEBUG_MODE == TRUE)
  Serial.print(err);
  Serial.print(", \"");
  Serial.print(SCPI_ErrorTranslate(err));
  Serial.println("\"");
#endif
  return 0;
}
 
scpi_result_t SCPI_Control(scpi_t *context, scpi_ctrl_name_t ctrl, scpi_reg_val_t val)
{
  (void)context;
 
  return SCPI_RES_OK;
}
 
scpi_result_t SCPI_Reset(scpi_t *context)
{
  (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;
}
 
scpi_interface_t scpi_interface = {
    /*.error = */ SCPI_Error,     
    /*.write = */ SCPI_Write,     
    /*.control = */ SCPI_Control, 
    /*.flush = */ SCPI_Flush,     
    /*.reset = */ SCPI_Reset,     
};
 
char scpi_input_buffer[SCPI_INPUT_BUFFER_LENGTH];
 
scpi_error_t scpi_error_queue_data[SCPI_ERROR_QUEUE_SIZE];
 
scpi_t scpi_context;