SCPI_Parser Class Reference

SCPI Parser class. More...

#include <scpi_parser.h>

Collaboration diagram for SCPI_Parser:

Classes
struct	internal_errors
	Internal errors container. More...

Public Member Functions
	SCPI_Parser ()
	SCPI_Parser class constructor.
void	SetCommandTreeBase (char *tree_base)
	Changes the base of the command tree for subsequent RegisterCommand calls.
void	SetCommandTreeBase (const char *tree_base)
	SetCommandTreeBase version with RAM string support.
void	SetCommandTreeBase (const __FlashStringHelper *tree_base)
	SetCommandTreeBase version with Flash strings (F() macro) support.
void	RegisterCommand (char *command, SCPI_caller_t caller)
	Registers a new valid SCPI command and associates a callback function with it.
void	RegisterCommand (const char *command, SCPI_caller_t caller)
	RegisterCommand version with RAM string support.
void	RegisterCommand (const __FlashStringHelper *command, SCPI_caller_t caller)
	RegisterCommand version with Flash strings (F() macro) support.
void	SetErrorHandler (SCPI_caller_t caller)
	Sets the function to be used as the error handler.
void	Execute (char *message, Stream &interface)
	Processes an incoming SCPI message and executes the associated command if found.
void	ProcessInput (Stream &interface, const char *term_chars)
	Reads a message from a Stream interface and executes it.
char *	GetMessage (Stream &interface, const char *term_chars)
	Reads a message from a Stream interface until termination characters are found.
void	PrintDebugInfo (Stream &interface)
	Prints debug information about the SCPI parser configuration and status to a Stream interface.

Public Attributes
ErrorCode	last_error = ErrorCode::NoError
	Variable that holds the last error code.
scpi_hash_t	hash_magic_number = 37
	Magic number used for hashing the commands.
scpi_hash_t	hash_magic_offset = 7
	Magic offset used for hashing the commands.
unsigned long	timeout = 10
	Timeout, in miliseconds, for GetMessage and ProcessInput.

Protected Member Functions
void	AddToken_ (char *token)
	Add a token to the tokens' storage.
scpi_hash_t	GetCommandCode_ (SCPI_Commands &commands)
	Get a hash from a command.

Protected Attributes
const uint8_t	buffer_length = 64
	Length of the message buffer.
const uint8_t	max_tokens = 20
	Max number of valid tokens.
const uint8_t	max_commands = 20
	Max number of registered commands.
struct SCPI_Parser::internal_errors	setup_errors
const scpi_hash_t	unknown_hash = 0
	Hash result for unknown commands.
const scpi_hash_t	invalid_hash = 1
	Hash reserved for invalid commands.
uint8_t	tokens_size_ = 0
	Number of stored tokens.
char *	tokens_ [20]
	Storage for tokens.
uint8_t	codes_size_ = 0
	Number of registered commands.
scpi_hash_t	valid_codes_ [20]
	Registered commands' hash storage.
SCPI_caller_t	callers_ [20+1]
	Pointers to the functions to be called when a valid command is received.
scpi_hash_t	tree_code_ = 0
	TreeBase branch's hash used when calculating hashes (0 for root)
uint8_t	tree_length_ = 0
	TreeBase branch's length (0 for root)
char	msg_buffer_ [64]
	Message buffer.
uint8_t	message_length_ = 0
	Length of the readed message.
unsigned long	time_checker_
	Varible used for checking timeout errors.

Detailed Description

SCPI Parser class.

This class provides the functionality to parse and execute commands based on the Standard Commands for Programmable Instruments (SCPI) syntax. It allows registering commands with associated callback functions and handles the processing of incoming messages from a serial stream.

Definition at line 54 of file scpi_parser.h.

Constructor & Destructor Documentation

SCPI_Parser()

SCPI_Parser::SCPI_Parser

(

)

SCPI_Parser class constructor.

Initializes the SCPI_Parser object. It sets the default error handler to a no-operation function.

SCPI_Parser my_instrument;

Definition at line 56 of file scpi_parser.cpp.

{
  callers_[max_commands] = &DefaultErrorHandler;
}

Here is the call graph for this function:

Member Function Documentation

AddToken_()

void SCPI_Parser::AddToken_ ( char * token )

protected

Add a token to the tokens' storage.

Adds a token to the internal tokens' storage.

This private method adds a given token (keyword) to the internal storage used for command parsing. It prevents adding duplicate tokens and checks for potential overflow of the token storage. Query symbols ('?') at the end of the token are removed before storing.

Parameters

token

A pointer to a null-terminated character array representing the token to add.

Definition at line 72 of file scpi_parser.cpp.

{
  if (tokens_size_ >= max_tokens)
  {
    setup_errors.token_overflow = true;
    return;
  }
  size_t token_size = strlen(token);
  // Remove query symbols
  if (token[token_size - 1] == '?')
    token_size--;
  for (uint8_t i = 0; i < tokens_size_; i++)
    // Check if the token is already added
    if ((strncmp(token, tokens_[i], token_size) == 0) and (token_size == strlen(tokens_[i])))
      return;
  char *stored_token = new char[token_size + 1];
  strncpy(stored_token, token, token_size);
  stored_token[token_size] = '\0';
  tokens_[tokens_size_] = stored_token;
  tokens_size_++;
}

Here is the caller graph for this function:

Execute()

void SCPI_Parser::Execute	(	char *	message,
		Stream &	interface )

Processes an incoming SCPI message and executes the associated command if found.

This method takes a SCPI message as input, parses it into commands and parameters, and then attempts to find a registered command that matches. If a match is found, the associated callback function is executed, with the parsed commands, parameters, and the communication interface passed as arguments. The message can contain multiple commands separated by semicolons (';').

Parameters

message	A pointer to a null-terminated character array containing the SCPI message to process. Example: "*IDN?; MEASure:VOLTage?".
interface	A reference to a Stream object (e.g., Serial) used for communication.

See also

GetMessage

Definition at line 376 of file scpi_parser.cpp.

{
  while (message != NULL)
  {
    // Save multicomands for later
    char *multicomands = strpbrk(message, ";");
    if (multicomands != NULL)
    {
      multicomands[0] = '\0';
      multicomands++;
    }
 
    tree_code_ = 0;
    SCPI_Commands commands(message);
    message = multicomands;
    SCPI_Parameters parameters(commands.not_processed_message);
    scpi_hash_t code = this->GetCommandCode_(commands);
    if (code == unknown_hash)
    {
      // Call ErrorHandler UnknownCommand
      last_error = ErrorCode::UnknownCommand;
      (*callers_[max_commands])(commands, parameters, interface);
      continue;
    }
    for (uint8_t i = 0; i < codes_size_; i++)
      if (valid_codes_[i] == code)
      {
        (*callers_[i])(commands, parameters, interface);
        break;
      }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCommandCode_()

scpi_hash_t SCPI_Parser::GetCommandCode_ ( SCPI_Commands & commands )

protected

Get a hash from a command.

Gets a hash code for a valid SCPI command.

This private method calculates a hash code for a given SCPI command represented by a SCPI_Commands object. The hash is computed based on the sequence of keywords in the command and the currently set command tree base. If any of the keywords in the command are not registered as known tokens, the function returns unknown_hash.

Parameters

commands

A reference to the SCPI_Commands object representing the command keywords.

Returns

The calculated hash code for the command, or unknown_hash if unregistered tokens are found.

See also

SetCommandTreeBase

Definition at line 109 of file scpi_parser.cpp.

{
  if (tree_code_ == invalid_hash)
    return invalid_hash;
  scpi_hash_t code;
  code = (tree_code_ == 0) ? hash_magic_offset : tree_code_;
  if (commands.Size() == 0)
    return unknown_hash;
  // Loop all keywords in the command
  for (uint8_t i = 0; i < commands.Size(); i++)
  {
    // Get keywords's length
    size_t header_length = strlen(commands[i]);
    // For the last keyword remove the query symbol if needed
    bool is_query = false;
    if (i == commands.Size() - 1)
    {
      is_query = (commands[i][header_length - 1] == '?');
      if (is_query)
        header_length--;
    }
 
    // Loop over all the known tokens
    for (uint8_t j = 0; j < tokens_size_; j++)
    {
      // Get the token's short and long lengths
      size_t short_length = 0;
      while (isupper(tokens_[j][short_length]))
        short_length++;
      size_t long_length = strlen(tokens_[j]);
 
      // If the token allows numeric suffixes
      // remove the trailing digits from the keyword
      if ((tokens_[j][long_length - 1] == '#') and (commands[i][header_length - 1] != '#'))
      {
        long_length--;
        while (isdigit(commands[i][header_length - 1]))
          header_length--;
      }
 
      // Test if the keyword match with the token
      // otherwise test next token
      if (header_length == short_length)
      {
        for (uint8_t k = 0; k < short_length; k++)
          if (not(toupper(commands[i][k]) == tokens_[j][k]))
            goto no_header_token_match;
      }
      else if (header_length == long_length)
      {
        for (uint8_t k = 0; k < long_length; k++)
          if (not(toupper(commands[i][k]) == toupper(tokens_[j][k])))
            goto no_header_token_match;
      }
      else
      {
        goto no_header_token_match;
      }
 
      // Apply the hashing step using token number j
      // hash(i) = hash(i - 1) * hash_magic_number + j
      code *= hash_magic_number;
      code += j;
      break;
 
    no_header_token_match:;
      // If the keyword does not match any token return unknown_hash
      if (j == (tokens_size_ - 1))
        return unknown_hash;
    }
    // If last keyword is a query, add a hashing step
    if (is_query)
    {
      code *= hash_magic_number;
      code -= 1;
    }
  }
  return code;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMessage()

char * SCPI_Parser::GetMessage	(	Stream &	interface,
		const char *	term_chars )

Reads a message from a Stream interface until termination characters are found.

This method reads characters from the provided Stream interface and stores them in an internalinternal buffer until one of the specified termination character sequences is encountered. It also handles communication timeouts and buffer overflows, calling the error handler if either occurs.

Parameters

interface	A reference to a Stream object (e.g., Serial) to read the message from.
term_chars	A constant pointer to a null-terminated character array containing the termination characters for a message (e.g., "\r\n").

Returns

A pointer to the internal message buffer containing the received message (without the termination characters), or NULL if no complete message is received due to timeout or no incoming data.

Definition at line 444 of file scpi_parser.cpp.

{
  while (interface.available())
  {
    // Read the new char
    msg_buffer_[message_length_] = interface.read();
    ++message_length_;
    time_checker_ = millis();
 
    if (message_length_ >= buffer_length)
    {
      // Call ErrorHandler due BufferOverflow
      last_error = ErrorCode::BufferOverflow;
      (*callers_[max_commands])(SCPI_C(), SCPI_P(), interface);
      message_length_ = 0;
      return NULL;
    }
 
#if SCPI_MAX_SPECIAL_COMMANDS
    // For the first space only.
    if (strcspn(msg_buffer_, " ") == message_length_ - 1)
    {
      msg_buffer_[message_length_ - 1] = '\0';
      tree_code_ = 0;
      SCPI_Commands commands(msg_buffer_);
      scpi_hash_t code = this->GetCommandCode_(commands);
      for (uint8_t i = 0; i < special_codes_size_; i++)
        if (valid_special_codes_[i] == code)
        {
          (*special_callers_[i])(commands, interface);
          message_length_ = 0;
          return msg_buffer_;
        }
      // restore original message.
      msg_buffer_[message_length_ - 1] = ' ';
      for (uint8_t i = 0; i < commands.Size() - 1; i++)
        commands[i][strlen(commands[i])] = ':';
      commands.not_processed_message--;
      commands.not_processed_message[0] = ' ';
    }
#endif
 
    // Test for termination chars (end of the message)
    msg_buffer_[message_length_] = '\0';
    if (strstr(msg_buffer_, term_chars) != NULL)
    {
      // Return the received message
      msg_buffer_[message_length_ - strlen(term_chars)] = '\0';
      message_length_ = 0;
      return msg_buffer_;
    }
  }
  // No more chars available yet
 
  // Return NULL if no message is incoming
  if (message_length_ == 0)
    return NULL;
 
  // Check for communication timeout
  if ((millis() - time_checker_) > timeout)
  {
    // Call ErrorHandler due Timeout
    last_error = ErrorCode::Timeout;
    (*callers_[max_commands])(SCPI_C(), SCPI_P(), interface);
    message_length_ = 0;
    return NULL;
  }
 
  // No errors, be sure to return NULL
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintDebugInfo()

void SCPI_Parser::PrintDebugInfo

(

Stream &

interface

)

Prints debug information about the SCPI parser configuration and status to a Stream interface.

This method prints various internal details of the SCPI parser, including the maximum sizes of internal buffers and arrays, the currently registered tokens and commands with their hash codes and associated handler function addresses, and any setup errors that might have occurred (e.g., buffer overflows). This information is useful for debugging and understanding the parser's internal state.

Parameters

interface

A reference to a Stream object (e.g., Serial) to print the debug information to.

Definition at line 529 of file scpi_parser.cpp.

{
  interface.println(F("*** DEBUG INFO ***\n"));
  interface.print(F("Max command tree branches: "));
  interface.print(SCPI_ARRAY_SYZE);
  interface.println(F(" (SCPI_ARRAY_SYZE)"));
  if (setup_errors.branch_overflow)
    interface.println(F(" **ERROR** Max branch size exceeded."));
  interface.print(F("Max number of parameters: "));
  interface.print(SCPI_ARRAY_SYZE);
  interface.println(F(" (SCPI_ARRAY_SYZE)"));
  interface.print(F("Message buffer size: "));
  interface.print(buffer_length);
  interface.println(F(" (SCPI_BUFFER_LENGTH)\n"));
 
  interface.print(F("TOKENS : "));
  interface.print(tokens_size_);
  interface.print(F(" / "));
  interface.print(max_tokens);
  interface.println(F(" (SCPI_MAX_TOKENS)"));
  if (setup_errors.token_overflow)
    interface.println(F(" **ERROR** Max tokens exceeded."));
  for (uint8_t i = 0; i < tokens_size_; i++)
  {
    interface.print(F("  "));
    interface.print(i + 1);
    interface.print(F(":\t"));
    interface.println(String(tokens_[i]));
    interface.flush();
  }
  interface.println();
 
  bool hash_crash = false;
  bool unknown_error = false;
  bool invalid_error = false;
  interface.print(F("VALID CODES : "));
  interface.print(codes_size_);
  interface.print(F(" / "));
  interface.print(max_commands);
  interface.println(F(" (SCPI_MAX_COMMANDS)"));
  if (setup_errors.command_overflow)
    interface.println(F(" **ERROR** Max commands exceeded."));
  interface.println(F("  #\tHash\t\tHandler"));
  for (uint8_t i = 0; i < codes_size_; i++)
  {
    interface.print(F("  "));
    interface.print(i + 1);
    interface.print(F(":\t"));
    interface.print(valid_codes_[i], HEX);
    if (valid_codes_[i] == unknown_hash)
    {
      interface.print(F("!*"));
      unknown_error = true;
    }
    else if (valid_codes_[i] == invalid_hash)
    {
      interface.print(F("!%"));
      invalid_error = true;
    }
    else
      for (uint8_t j = 0; j < i; j++)
        if (valid_codes_[i] == valid_codes_[j])
        {
          interface.print("!!");
          hash_crash = true;
          break;
        }
    interface.print(F("\t\t0x"));
    interface.print(long(callers_[i]), HEX);
    interface.println();
    interface.flush();
  }
  if (unknown_error)
    interface.println(F(" **ERROR** Tried to register ukwnonk tokens. (!*)"));
  if (invalid_error)
    interface.println(F(" **ERROR** Tried to register invalid commands. (!%)"));
  if (hash_crash)
    interface.println(F(" **ERROR** Hash crashes found. (!!)"));
 
#if SCPI_MAX_SPECIAL_COMMANDS
  hash_crash = false;
  unknown_error = false;
  invalid_error = false;
  interface.println();
  interface.print(F("VALID SPECIAL CODES : "));
  interface.print(special_codes_size_);
  interface.print(F(" / "));
  interface.print(max_special_commands);
  interface.println(F(" (SCPI_MAX_SPECIAL_COMMANDS)"));
  if (setup_errors.special_command_overflow)
    interface.println(F(" **ERROR** Max special commands exceeded."));
  interface.println(F("  #\tHash\t\tHandler"));
  for (uint8_t i = 0; i < special_codes_size_; i++)
  {
    interface.print(F("  "));
    interface.print(i + 1);
    interface.print(F(":\t"));
    interface.print(valid_special_codes_[i], HEX);
    if (valid_special_codes_[i] == unknown_hash)
    {
      interface.print(F("!*"));
      unknown_error = true;
    }
    else if (valid_special_codes_[i] == invalid_hash)
    {
      interface.print(F("!%"));
      invalid_error = true;
    }
    else
      for (uint8_t j = 0; j < i; j++)
        if (valid_special_codes_[i] == valid_special_codes_[j])
        {
          interface.print("!!");
          hash_crash = true;
          break;
        }
    interface.print(F("\t\t0x"));
    interface.print(long(special_callers_[i]), HEX);
    interface.println();
    interface.flush();
  }
  if (unknown_error)
    interface.println(F(" **ERROR** Tried to register ukwnonk tokens. (!*)"));
  if (invalid_error)
    interface.println(F(" **ERROR** Tried to register invalid commands. (!%)"));
  if (hash_crash)
    interface.println(F(" **ERROR** Hash crashes found. (!!)"));
#endif
 
  interface.println(F("\nHASH Configuration:"));
  interface.print(F("  Hash size: "));
  interface.print((uint8_t)(sizeof(scpi_hash_t) * 8));
  interface.println(F("bits (SCPI_HASH_TYPE)"));
  interface.print(F("  Hash magic number: "));
  interface.println(hash_magic_number);
  interface.print(F("  Hash magic offset: "));
  interface.println(hash_magic_offset);
  interface.println(F("\n*******************\n"));
}

ProcessInput()

void SCPI_Parser::ProcessInput	(	Stream &	interface,
		const char *	term_chars )

Reads a message from a Stream interface and executes it.

This method continuously reads data from the provided Stream interface until a termination character (or sequence of characters) is detected. Once a complete message is received, it is passed to the Execute method for parsing and execution.

Parameters

interface	A reference to a Stream object (e.g., Serial) to read the message from.
term_chars	A constant pointer to a null-terminated character array containing the termination characters for a message (e.g., "\n", "\r\n").

See also

GetMessage

Execute

Definition at line 424 of file scpi_parser.cpp.

{
  char *message = this->GetMessage(interface, term_chars);
  if (message != NULL)
  {
    this->Execute(message, interface);
  }
}

Here is the call graph for this function:

RegisterCommand() [1/3]

void SCPI_Parser::RegisterCommand	(	char *	command,
		SCPI_caller_t	caller )

Registers a new valid SCPI command and associates a callback function with it.

This method registers a new SCPI command that the parser will recognize. When a matching command is received and parsed, the provided callback function will be executed. The command string can include a query symbol ('?') for query commands. The command is tokenized, and each token is added to the internal token storage if it's not already present. The command's hash is calculated based on the current tree base.

Parameters

command	A pointer to a null-terminated character array (RAM string) representing the command. Example: "*IDN?", "MEASure:VOLTage?", "CONFigure:VOLTage 10.5".
caller	A function pointer to the callback function (SCPI_caller_t) to be executed when the command is received.

Definition at line 277 of file scpi_parser.cpp.

{
  if (codes_size_ >= max_commands)
  {
    setup_errors.command_overflow = true;
    return;
  }
  SCPI_Commands command_tokens(command);
  for (uint8_t i = 0; i < command_tokens.Size(); i++)
    this->AddToken_(command_tokens[i]);
  scpi_hash_t code = this->GetCommandCode_(command_tokens);
 
  // Check for errors
  if (code == unknown_hash)
    code = invalid_hash;
  bool overflow_error = command_tokens.overflow_error;
  overflow_error |= (tree_length_ + command_tokens.Size()) > command_tokens.storage_size;
  setup_errors.command_overflow |= overflow_error;
  if (overflow_error)
    code = invalid_hash;
 
  valid_codes_[codes_size_] = code;
  callers_[codes_size_] = caller;
  codes_size_++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterCommand() [2/3]

void SCPI_Parser::RegisterCommand	(	const __FlashStringHelper *	command,
		SCPI_caller_t	caller )

RegisterCommand version with Flash strings (F() macro) support.

This overload of RegisterCommand accepts a Flash string helper object, allowing the command string to reside in program memory (Flash), saving RAM.

Parameters

command	A Flash string helper object (created using the F() macro) representing the command. Example: F("*IDN?").
caller	A function pointer to the callback function (SCPI_caller_t).

See also

RegisterCommand(char *command, SCPI_caller_t caller)

Definition at line 335 of file scpi_parser.cpp.

{
  strcpy_P(msg_buffer_, (const char *)command);
  this->RegisterCommand(msg_buffer_, caller);
}

Here is the call graph for this function:

RegisterCommand() [3/3]

void SCPI_Parser::RegisterCommand	(	const char *	command,
		SCPI_caller_t	caller )

RegisterCommand version with RAM string support.

This overload of RegisterCommand accepts a constant character pointer for the command string, which resides in RAM.

Parameters

command	A constant pointer to a null-terminated character array (RAM string) representing the command. Example: "*IDN?".
caller	A function pointer to the callback function (SCPI_caller_t).

See also

RegisterCommand(char *command, SCPI_caller_t caller)

Definition at line 316 of file scpi_parser.cpp.

{
  strcpy(msg_buffer_, command);
  this->RegisterCommand(msg_buffer_, caller);
}

Here is the call graph for this function:

SetCommandTreeBase() [1/3]

void SCPI_Parser::SetCommandTreeBase

(

char *

tree_base

)

Changes the base of the command tree for subsequent RegisterCommand calls.

This method sets a new tree base for organizing SCPI commands hierarchically. The tree base is a sequence of command keywords separated by colons (':'). Subsequent calls to RegisterCommand will have their command hashes calculated relative to this tree base. An empty string "" resets the tree base to the root.

Parameters

tree_base

A pointer to a null-terminated character array (RAM string) representing the new tree base. Example: "SYSTem:COMMunication".

See also

RegisterCommand

Definition at line 204 of file scpi_parser.cpp.

{
  SCPI_Commands tree_tokens(tree_base);
  if (tree_tokens.Size() == 0)
  {
    tree_code_ = 0;
    tree_length_ = 0;
    return;
  }
  for (uint8_t i = 0; i < tree_tokens.Size(); i++)
    AddToken_(tree_tokens[i]);
  tree_code_ = 0;
  tree_code_ = this->GetCommandCode_(tree_tokens);
  tree_length_ = tree_tokens.Size();
  if (tree_tokens.overflow_error)
  {
    setup_errors.branch_overflow = true;
    tree_code_ = invalid_hash;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetCommandTreeBase() [2/3]

void SCPI_Parser::SetCommandTreeBase

(

const __FlashStringHelper *

tree_base

)

SetCommandTreeBase version with Flash strings (F() macro) support.

This overload of SetCommandTreeBase accepts a Flash string helper object, allowing the tree base string to reside in program memory (Flash), saving RAM.

Parameters

tree_base

A Flash string helper object (created using the F() macro) representing the new tree base. Example: F("SYSTem:LED").

See also

SetCommandTreeBase(char *tree_base)

Definition at line 255 of file scpi_parser.cpp.

{
  strcpy_P(msg_buffer_, (const char *)tree_base);
  this->SetCommandTreeBase(msg_buffer_);
}

Here is the call graph for this function:

SetCommandTreeBase() [3/3]

void SCPI_Parser::SetCommandTreeBase

(

const char *

tree_base

)

SetCommandTreeBase version with RAM string support.

This overload of SetCommandTreeBase accepts a constant character pointer for the tree base string, which resides in RAM.

Parameters

tree_base

A constant pointer to a null-terminated character array (RAM string) representing the new tree base. Example: "SYSTem:LED".

See also

SetCommandTreeBase(char *tree_base)

Definition at line 237 of file scpi_parser.cpp.

{
  strcpy(msg_buffer_, tree_base);
  this->SetCommandTreeBase(msg_buffer_);
}

Here is the call graph for this function:

SetErrorHandler()

void SCPI_Parser::SetErrorHandler

(

SCPI_caller_t

caller

)

Sets the function to be used as the error handler.

This method allows the user to specify a custom error handling function that will be called when the parser encounters an error, such as an unknown command or a buffer overflow. The error handler function receives the parsed commands, parameters (if available), and the communication interface as arguments.

Parameters

caller

A function pointer to the error handler callback function (SCPI_caller_t). Example: &myErrorHandler.

Definition at line 355 of file scpi_parser.cpp.

{
  callers_[max_commands] = caller;
}

Member Data Documentation

buffer_length

const uint8_t SCPI_Parser::buffer_length = 64

protected

Length of the message buffer.

Definition at line 104 of file scpi_parser.h.

callers_

SCPI_caller_t SCPI_Parser::callers_[20+1]

protected

Pointers to the functions to be called when a valid command is received.

Definition at line 144 of file scpi_parser.h.

codes_size_

uint8_t SCPI_Parser::codes_size_ = 0

protected

Number of registered commands.

Definition at line 140 of file scpi_parser.h.

hash_magic_number

scpi_hash_t SCPI_Parser::hash_magic_number = 37

Magic number used for hashing the commands.

Definition at line 85 of file scpi_parser.h.

hash_magic_offset

scpi_hash_t SCPI_Parser::hash_magic_offset = 7

Magic offset used for hashing the commands.

Definition at line 87 of file scpi_parser.h.

invalid_hash

const scpi_hash_t SCPI_Parser::invalid_hash = 1

protected

Hash reserved for invalid commands.

Definition at line 129 of file scpi_parser.h.

last_error

ErrorCode SCPI_Parser::last_error = ErrorCode::NoError

Variable that holds the last error code.

Definition at line 75 of file scpi_parser.h.

max_commands

const uint8_t SCPI_Parser::max_commands = 20

protected

Max number of registered commands.

Definition at line 108 of file scpi_parser.h.

max_tokens

const uint8_t SCPI_Parser::max_tokens = 20

protected

Max number of valid tokens.

Definition at line 106 of file scpi_parser.h.

message_length_

uint8_t SCPI_Parser::message_length_ = 0

protected

Length of the readed message.

Definition at line 152 of file scpi_parser.h.

msg_buffer_

char SCPI_Parser::msg_buffer_[64]

protected

Message buffer.

Definition at line 150 of file scpi_parser.h.

time_checker_

unsigned long SCPI_Parser::time_checker_

protected

Varible used for checking timeout errors.

Definition at line 154 of file scpi_parser.h.

timeout

unsigned long SCPI_Parser::timeout = 10

Timeout, in miliseconds, for GetMessage and ProcessInput.

Definition at line 89 of file scpi_parser.h.

tokens_

char* SCPI_Parser::tokens_[20]

protected

Storage for tokens.

Definition at line 138 of file scpi_parser.h.

tokens_size_

uint8_t SCPI_Parser::tokens_size_ = 0

protected

Number of stored tokens.

Definition at line 136 of file scpi_parser.h.

tree_code_

scpi_hash_t SCPI_Parser::tree_code_ = 0

protected

TreeBase branch's hash used when calculating hashes (0 for root)

Definition at line 146 of file scpi_parser.h.

tree_length_

uint8_t SCPI_Parser::tree_length_ = 0

protected

TreeBase branch's length (0 for root)

Definition at line 148 of file scpi_parser.h.

unknown_hash

const scpi_hash_t SCPI_Parser::unknown_hash = 0

protected

Hash result for unknown commands.

Definition at line 127 of file scpi_parser.h.

valid_codes_

scpi_hash_t SCPI_Parser::valid_codes_[20]

protected

Registered commands' hash storage.

Definition at line 142 of file scpi_parser.h.

---

The documentation for this class was generated from the following files:

• scpi_parser.h
• scpi_parser.cpp