Subversion Repositories gecko3

/* GECKO3COM
 *
 * Copyright (C) 2009 by
 *   ___    ____  _   _
 *  (  _`\ (  __)( ) ( )   
 *  | (_) )| (_  | |_| |   Berne University of Applied Sciences
 *  |  _ <'|  _) |  _  |   School of Engineering and
 *  | (_) )| |   | | | |   Information Technology
 *  (____/'(_)   (_) (_)
 *
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details. 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
/*********************************************************************/
/** \file     scpi_parser.c
 *********************************************************************
 * \brief     Parser for the SCPI commands. 
 *
 *            The supported commands are defined here in the parser. 
 *            So if you would like to extend the known set of commands,
 *            you have to add them here. \n
 *            The parser excecutes the necessary Function(s) for the 
 *            detected command or it sets the "action" enum
 *            variable to signal wich command was parsed.
 *            In these way this parser handles most IEEE488.2 and SCPI 1999.0 
 *            mandatory commands and SCPI 1999.0 itself. 
 *
 * \note      when used with USB 1.1 systems, the maximum command length 
 *            you can define is limited to 52 characters because we only
 *            parse commands in the first packet.
 *
 *
 * \author    Christoph Zimmermann bfh.ch * \date      2009-02-04
 *
*/
 
#include <stdint.h>
#include <ctype.h>
#include <string.h>
 
#include "scpi_parser.h"
#include "usb_tmc.h"
#include "usb_descriptors.h"
#include "firmware_version.h"
#include "debugprint.h"
 
 
#define SCPI_VERSION "1999.0\n" /**< Version of the SCPI standard this device complies to */
 
#define MAXFILL       12 /**< Maximum length of the longest command, defines the buffer size of the parser */
 
 
/** helper function to convert a unsigned byte to an ascii string
 *
 *  \param[in]  byte unsigned byte to convert
 *  \param[out] ascii string with "\n" at the end
 *  \return     length of string
 */
static uint8_t byte2ascii(uint8_t byte, xdata unsigned char *ascii) {
  idata unsigned char first_digit, second_digit, third_digit;
 
  first_digit = byte % 10;
  byte -= first_digit;
  byte /= 10;
  second_digit = byte % 10;
  if(second_digit == 0) {
    ascii[0] = first_digit + '0';
    ascii[1] = '\n';
    return 2;
  }
  byte -= second_digit;
  byte /= 10;
  third_digit = byte % 10;
  if(third_digit == 0) {
    ascii[0] = second_digit + '0';
    ascii[1] = first_digit + '0';
    ascii[2] = '\n';
    return 3;
  }
  ascii[0] = third_digit + '0';
  ascii[1] = second_digit + '0';
  ascii[2] = first_digit + '0';
  ascii[3] = '\n';
  return 4;
}
 
/** helper function to convert an ascii string to a unsigned byte
 *
 *  \param[in]  ascii string with '\n' or '\0' at the end
 *  \return byte result unsigned byte, 0 if case of error
 */
static uint8_t ascii2byte(const xdata unsigned char *ascii) {
  idata uint8_t byte = 0, i = 0;
  idata unsigned char local_char;
 
  for(i; i<4;i++) {
    local_char = ascii[i];
    if(local_char >= '0' && local_char <= '9') {
      byte = byte*10 + (local_char - '0');
    }
    else if(local_char == '\n' || local_char == '\0') {
      return byte;
    }
    else {
      ieee488_status.EventStatusRegister |= bmEXECUTION_ERROR;
      return 0;
    }
  }
 
  ieee488_status.EventStatusRegister |= bmEXECUTION_ERROR;
  return 0;
}
 
 
/** helper function to copy unicode 16 chars from the usb descriptor to an 
 * ascii string to form the *idn? response 
 * 
 * \param[in] pointer to string to fill
 * \param[in] pointer to usb string descriptor to read from
 * \return pointer that points to the last character in the string (one before \0)
 */
static char* descr2string(char *target, const xdata char *descriptor) {
  uint8_t i, j, descriptor_length;
 
  /* the first byte in the descriptor is the length, second byte is the type */
  descriptor_length = (uint8_t)descriptor[0] - 2;
  descriptor_length >>= 1;
 
  for (i = 0; i < descriptor_length; i++){
    j = i << 1;
    j += 2;
    target[i] = descriptor[j];
  }
  target[i+1] = '\0';
 
  return &target[i];
}
 
 
/* -------------------------------------------------------------------- */
/** \brief SCPI command parser */
int8_t scpi_scan(idata uint16_t *offset, xdata Scanner *s, xdata TMC_Response_Queue *queue){
 
  xdata unsigned char buffer[MAXFILL];
  unsigned char *string_index;
  uint8_t i;
  char * xdata srcPtr = s->source;
  xdata unsigned char * xdata bufferPtr = buffer;
 
  xdata uint16_t * xdata localqueuelength = &queue->length;
  xdata uint8_t * xdata localqueue = queue->buf;
 
  srcPtr += *offset;
 
  for(i=0;i<MAXFILL;i++) {
    buffer[i] = tolower(*srcPtr);
    srcPtr++;
  }
 
  /* this set of commands the mandatory IEEE488 commands */
 
  if(*bufferPtr == '*') {
    bufferPtr++;
 
    if(!strncmp("cls", bufferPtr, 3)) {
      /** \li *cls, clear status command */
      ieee488_status.EventStatusRegister = 0;
      ieee488_status.StatusByteRegister = 0;
      usb_tmc_state = TMC_STATE_IDLE;
      return 1;
    }
 
    if(!strncmp("ese", bufferPtr, 3)) {
      bufferPtr += 3;
      if(*bufferPtr == ' ') {
	/** \li *ese, standard event status enable command */
	ieee488_status.EventStatusEnable = ascii2byte(bufferPtr+1);
	usb_tmc_state = TMC_STATE_IDLE;
	return 1;  
      }
      else if(*bufferPtr == '?') {
	/** \li *ese?, standard event status enable query */
	*localqueuelength = byte2ascii(ieee488_status.EventStatusEnable,localqueue);
	IEEE488_set_mav();
	usb_tmc_state = TMC_STATE_IDLE;
	return 1;  
      }
      else {
	return 0;
      }
    }
 
    if(!strncmp("esr?", bufferPtr, 4)) {
      /** \li *esr?, standard event status register query */
      queue->length = byte2ascii(ieee488_status.EventStatusRegister,queue->buf);
      IEEE488_set_mav();
      ieee488_status.EventStatusRegister = 0;
      usb_tmc_state = TMC_STATE_IDLE;
      return 1;  
    }
 
    if(!strncmp("idn?", bufferPtr, 4)) {
      /** \li *idn?, identification query */
      string_index = descr2string((char*)queue->buf, \
				  string_descriptors[(uint8_t)full_speed_device_descr[14]] \
				  );
      *string_index = ',';
      string_index++;
      string_index = descr2string(string_index, \
				  string_descriptors[(uint8_t)full_speed_device_descr[15]] \
				  );
      *string_index = ',';
      string_index++;
      string_index = descr2string(string_index, \
				  string_descriptors[(uint8_t)full_speed_device_descr[16]]\
				  );
 
      strcat((char*)queue->buf, ",");
      strcat((char*)queue->buf, FIRMWARE_VERSION);
 
      queue->length = strlen((char*)queue->buf);
 
      usb_tmc_state = TMC_STATE_IDLE;
      IEEE488_set_mav();
      return 1; 
    }
 
    if(!strncmp("opc", bufferPtr, 3)) {
      bufferPtr += 3;
      if(*bufferPtr == '?') {
	/** \li *opc?, operation complete query */
	queue->buf[0] = '1';
	queue->buf[1] = '\n';
	queue->length = 2;
	usb_tmc_state = TMC_STATE_IDLE;
	IEEE488_set_mav();
	return 1;  
      }
      else {
	/** \li *opc, operation complete command */
	ieee488_status.OPC_Received = 1;
	usb_tmc_state = TMC_STATE_IDLE;
	return 1;  
      }
    }
 
    if(!strncmp("rst", bufferPtr, 3)) {
      /** \li *rst, reset command. resets the FPGA and connected modules */
      s->action = SYSTEM_RESET;
      return 1;  
    }
 
    if(!strncmp("sre", bufferPtr, 3)) {
      bufferPtr += 3;
      if(*bufferPtr == ' ') {
	/** \li *sre, service request enable command */
	ieee488_status.ServiceRequestEnable = ascii2byte(bufferPtr+1);
	usb_tmc_state = TMC_STATE_IDLE;
	return 1;  
      }
      else if(*bufferPtr == '?') {
	/** \li *sre?, service request enable query */
	queue->length = byte2ascii(ieee488_status.ServiceRequestEnable,queue->buf);
	usb_tmc_state = TMC_STATE_IDLE;
	return 1;  
      }
      else {
	return 0;
      }
    }
 
    if(!strncmp("stb?", bufferPtr, 4)) {
      /** \li *stb?, read status byte query */
      queue->length = byte2ascii(IEEE488_status_query(&ieee488_status),queue->buf);
      usb_tmc_state = TMC_STATE_IDLE;
      IEEE488_set_mav();
      return 1;  
    }
 
    if(!strncmp("wai", bufferPtr, 3)) {
      /** \li *wai, wait-to-continue command */
      /* we excecute only sequential commands, so we are always finished */
      return 1;  
    }
 
    else {
      return 0;
    }
  }
 
  /* -------------------------------------------------------------------- */
  /* this set of regular expressions are for the mandatory SCPI 99 commands. 
   * many are missing because we have not enought memory 
   */
  if(!strncmp("syst:", bufferPtr, 5)) {
    bufferPtr += 5;
 
    if(!strncmp("err?", bufferPtr, 4)) {
      /** \li syst:err?, gets an error message if there is one */
      if(ieee488_status.EventStatusRegister & bmCOMMAND_ERROR){
	strcpy((char*)queue->buf, "-100, \"Command error\"\n");
	queue->length = 22;
	ieee488_status.EventStatusRegister &= ~bmCOMMAND_ERROR;
      }
      else if(ieee488_status.EventStatusRegister & bmEXECUTION_ERROR){
	strcpy((char*)queue->buf, "-200, \"Execution error\"\n");
	queue->length = 24;
	ieee488_status.EventStatusRegister &= ~bmEXECUTION_ERROR;
      }
      else {
	strcpy((char*)queue->buf, "0, \"No error\"\n");
	queue->length = 14;
      }
      usb_tmc_state = TMC_STATE_IDLE;
      IEEE488_set_mav();
      return 1;  
    }
 
    if(!strncmp("vers?", bufferPtr, 5)) {
      /** \li syst:vers?, returns the SCPI standard version number */
      strcpy((char*)queue->buf, SCPI_VERSION);
      queue->length = 7;
      usb_tmc_state = TMC_STATE_IDLE;
      IEEE488_set_mav();
      return 1;  
    }
 
    else {
      return 0;
    }
  }
 
  /* -------------------------------------------------------------------- */
  /* this set of regular expressions are for the device functions */
  if(!strncmp("fpga:", bufferPtr, 5)) {
    bufferPtr += 5;
 
    if(!strncmp("conf ", bufferPtr, 5)) {
      /** \li fpga:conf, configures the fpga with the following bitfile */
      s->action = FPGA_CONFIGURE;
      *offset += 10;
      return 1;
    }
 
    if(!strncmp("type?", bufferPtr, 5)) {
      /** \li fpga:type?, returns the fpga type as string */
      s->action = rqFPGA_TYPE; 
      *offset += 10;
      return 1;  
    }
 
    if(!strncmp("id?", bufferPtr, 3)) {
      /** \li fpga:id?, returns the jtag id code of the fpga as 32bit int */
      s->action = rqFPGA_IDCODE;
      *offset += 8;
      return 1; 
    }
 
    if(!strncmp("done?", bufferPtr, 5)) {
      /** \li fpga:done?, is true when the fpga is configured */ 
      s->action = rqFPGA_DONE;
      *offset += 10;
      return 1; 
    }
 
    if(!strncmp("data", bufferPtr, 4)) {
      /** \li fpga:data, context switch to fpga. After this command you 
       *      communicate directly with the fpga. The GECKO3COM firmware does 
       *      not interprete the SCPI commands anymore. */ 
      s->action = FPGA_COMMUNICATION;
      *offset += 9;
      return 1; 
    }
 
    else {
      return 0;
    }
  }
 
  if(!strncmp("mem:", bufferPtr, 4)) {
    bufferPtr += 4;
 
    if(!strncmp("data ", bufferPtr, 5)) {
      /** \li mem:data, receives a bitfile to store in SPI flash.
       * available memory slots are 0 and 1 */
      s->action = SPI_WRITE;
      *offset += 9;
 
      return 1;
    }
 
    if(!strncmp("del ", bufferPtr, 4)) {
      /** \li mem:del, DEPRICATED deletes the desired fpga configuration, 
       * available memory slots are 0 and 1 */
      s->action = SPI_DELETE;
      *offset += 8;
 
      return 1;  
    }
 
    else {
      return 0;
    }
  }
 
  /* matches all. when no command is parsed return an error */
 
  return 0;
}