scpi_parser.h

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
 
#ifndef _SCPI_PARSER_H_
#define _SCPI_PARSER_H_
 
#include "scpi_config.h"
#include "scpi_types.h"

using SCPI_caller_t = void (*)(SCPI_Commands, SCPI_Parameters, Stream &);
using SCPI_special_caller_t = void (*)(SCPI_Commands, Stream &);

class SCPI_Parser
{
public:
  // Constructor
  SCPI_Parser();
  // Change the TreeBase for the next RegisterCommand calls
  void SetCommandTreeBase(char *tree_base);
  // SetCommandTreeBase version with RAM string support
  void SetCommandTreeBase(const char *tree_base);
  // SetCommandTreeBase version with Flash strings (F() macro) support
  void SetCommandTreeBase(const __FlashStringHelper *tree_base);
  // Registers a new valid command and associate a procedure to it
  void RegisterCommand(char *command, SCPI_caller_t caller);
  // RegisterCommand version with RAM string support.
  void RegisterCommand(const char *command, SCPI_caller_t caller);
  // RegisterCommand version with Flash strings (F() macro) support
  void RegisterCommand(const __FlashStringHelper *command,
                       SCPI_caller_t caller);
  // Set the function to be used by the error handler.
  void SetErrorHandler(SCPI_caller_t caller);
  ErrorCode last_error = ErrorCode::NoError;
  // Process a message and execute it a valid command is found
  void Execute(char *message, Stream &interface);
  // Gets a message from a Stream interface and execute it
  void ProcessInput(Stream &interface, const char *term_chars);
  // Gets a message from a Stream interface
  char *GetMessage(Stream &interface, const char *term_chars);
  // Prints registered tokens and command hashes to the serial interface
  void PrintDebugInfo(Stream &interface);
  scpi_hash_t hash_magic_number = 37;
  scpi_hash_t hash_magic_offset = 7;
  unsigned long timeout = 10;
 
#if SCPI_MAX_SPECIAL_COMMANDS
  // Registers a new valid special command and associate a procedure to it
  void RegisterSpecialCommand(char *command, SCPI_special_caller_t caller);
  // RegisterSpecialCommand version with RAM string support.
  void RegisterSpecialCommand(const char *command,
                              SCPI_special_caller_t caller);
  // RegisterSpecialCommand version with Flash strings (F() macro) support
  void RegisterSpecialCommand(const __FlashStringHelper *command,
                              SCPI_special_caller_t caller);
#endif
 
protected:
  const uint8_t buffer_length = SCPI_BUFFER_LENGTH;
  const uint8_t max_tokens = SCPI_MAX_TOKENS;
  const uint8_t max_commands = SCPI_MAX_COMMANDS;
  struct internal_errors
  {
    bool command_overflow = false;
    bool token_overflow = false;
    bool branch_overflow = false;
    bool special_command_overflow = false;
  } setup_errors;

  const scpi_hash_t unknown_hash = 0;
  const scpi_hash_t invalid_hash = 1;

  void AddToken_(char *token);
  scpi_hash_t GetCommandCode_(SCPI_Commands &commands);
  uint8_t tokens_size_ = 0;
  char *tokens_[SCPI_MAX_TOKENS];
  uint8_t codes_size_ = 0;
  scpi_hash_t valid_codes_[SCPI_MAX_COMMANDS];
  SCPI_caller_t callers_[SCPI_MAX_COMMANDS + 1];
  scpi_hash_t tree_code_ = 0;
  uint8_t tree_length_ = 0;
  char msg_buffer_[SCPI_BUFFER_LENGTH];
  uint8_t message_length_ = 0;
  unsigned long time_checker_;
 
#if SCPI_MAX_SPECIAL_COMMANDS
  const uint8_t max_special_commands = SCPI_MAX_SPECIAL_COMMANDS;
  uint8_t special_codes_size_ = 0;
  scpi_hash_t valid_special_codes_[SCPI_MAX_SPECIAL_COMMANDS];
  SCPI_special_caller_t special_callers_[SCPI_MAX_SPECIAL_COMMANDS];
#endif
};
 
#endif