Subversion Repositories gecko4

/******************************************************************************/
/*            _   _            __   ____                                      */
/*           / / | |          / _| |  __|                                     */
/*           | |_| |  _   _  / /   | |_                                       */
/*           |  _  | | | | | | |   |  _|                                      */
/*           | | | | | |_| | \ \_  | |__                                      */
/*           |_| |_| \_____|  \__| |____| microLab                            */
/*                                                                            */
/*           Bern University of Applied Sciences (BFH)                        */
/*           Quellgasse 21                                                    */
/*           Room HG 4.33                                                     */
/*           2501 Biel/Bienne                                                 */
/*           Switzerland                                                      */
/*                                                                            */
/*           http://www.microlab.ch                                           */
/******************************************************************************/
/*   GECKO4com
 
     2010/2011 Dr. Theo Kluter
 
     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 these sources.  If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/* IMPORTANT: The below table list the already implemented SCPI commands. You
   can add more yourself, but must refrain from:
   1) Editing the ID values of the present SCPI commands.
   2) Using duplicate ID values or duplicate commands!
   3) Using commands longer than 14 chars
*/
 
#define nr_of_known_scpi_commands 36
const char *scpi_table[nr_of_known_scpi_commands*2] = {
/* ID , command */
"2","*CLS",
"6","*ESE",
"7","*ESE?",
"8","*ESR?",
"9","*IDN?",
"10","*IST?",
"11","*OPC",
"12","*OPC?",
"13","*PUD",
"14","*PUD?",
"15","*RST",
"16","*SRE",
"17","*SRE?",
"18","*STB?",
"20","*TST?",
"21","*WAI",
"22","BITFLASH",
"23","BITFLASH?",
"24","BOARD?",
"25","CONFIG",
"26","ERASE",
"27","FIFO",
"28","FIFO?",
"29","FPGA",
"30","FPGA?",
"35","HEXSWITCH",
"36","HEXSWITCH?",
"37","IDENTIFY",
"51","TRANS",
"58","USERRESET",
"59","VGA:BGCOL",
"60","VGA:CLEAR",
"61","VGA:CURSOR",
"62","VGA:CURSOR?",
"63","VGA:FGCOL",
"64","VGA:PUTSTR"};
 
typedef struct comand_type {
   unsigned char ID;
   char *command;
} comand_type_t;
 
unsigned char get_dec( char *str ) {
   unsigned int result;
   int loop,sort;
 
   result = 0;
   for (loop = 0 ; loop < strlen(str) ; loop++) {
      if ((str[loop] >= '0')&&
          (str[loop] <= '9')) {
         result *= 10;
         result += (str[loop]-'0');
      } else {
         printf("ERROR: invalid ID found!\n" );
         return 255;
      }
   }
   if (result > 128) {
      printf( "ERROR: Too big ID found!\n" );
      return 255;
   } else {
      return result;
   }
}
 
int main() {
   comand_type_t *commands[128],*dummy;
   unsigned char rom[2048];
   int loop,sort,offset;
 
   if (nr_of_known_scpi_commands > 128) {
      printf( "ERROR: Too many SCPI commands defined!\n" );
      return -1;
   }
 
   for (loop = 0 ; loop < 128 ; loop++) {
      commands[loop] = NULL;
   }
 
   for (loop = 0 ; loop < nr_of_known_scpi_commands ; loop++) {
      commands[loop] = (comand_type_t *) malloc( sizeof( comand_type_t ) );
      if (commands[loop] == NULL) {
         printf( "ERROR: Unable to allocate memory!\n" );
         return -1;
      }
      commands[loop]->ID = get_dec(scpi_table[loop*2]);
      if ((strlen(scpi_table[(loop*2)+1]) < 15)&&
          (strlen(scpi_table[(loop*2)+1]) > 0)) {
         commands[loop]->command = (char*) malloc(
               (strlen(scpi_table[(loop*2)+1])+1)*sizeof(char));
         if (commands[loop]->command == NULL) {
            printf( "ERROR: Unable to allocate memory!\n" );
            return -1;
         }
         strcpy(commands[loop]->command , scpi_table[(loop*2)+1]);
         for (sort = 0 ; sort < strlen(commands[loop]->command) ; sort++) {
            if ((commands[loop]->command[sort] >= 'a')&&
                (commands[loop]->command[sort] <= 'z')) {
               commands[loop]->command[sort] -= ('a'-'A');
            }
         }
      } else {
         printf("ERROR: Too long SCPI command \"%s\" found!" ,
                 scpi_table[(loop*2)+1] );
         return -1;
      }
   }
 
   for (loop = 0 ; loop < nr_of_known_scpi_commands-1 ; loop++) {
      for (sort = loop+1 ; sort < nr_of_known_scpi_commands ; sort++) {
         if (commands[loop]->ID == commands[sort]->ID) {
            printf( "ERROR: Duplicate ID found!\n" );
            return -1;
         }
         if (strcmp(commands[loop]->command,commands[sort]->command) == 0) {
            printf( "ERROR: Duplicate SCPI command found!\n" );
            return -1;
         }
         if (strcmp(commands[loop]->command,commands[sort]->command) > 0) {
            dummy = commands[loop];
            commands[loop] = commands[sort];
            commands[sort] = dummy;
         }
      }
   }
   printf( "      -- Command ID <=> Command\n" );
   for (loop = 0 ; loop < nr_of_known_scpi_commands ; loop++) {
      printf( "      --     0x%02X   <=> \"%s\"\n" , commands[loop]->ID , commands[loop]->command );
      offset=loop*16;
      sort = 0;
      while (sort < strlen(commands[loop]->command)) {
         rom[offset+sort] = commands[loop]->command[sort];
         sort++;
      }
      rom[offset+sort] = 0;
      sort++;
      rom[offset+sort] = commands[loop]->ID;
      sort++;
      while (sort < 16) {
         rom[offset+sort] = 0xFF;
         sort++;
      }
   }
   for (loop = nr_of_known_scpi_commands ; loop < 128 ; loop++) {
      offset = loop*16;
      for (sort = 0 ; sort < 16 ; sort++)
         rom[offset+sort] = 0xFE;
   }
   for (loop = 0 ; loop < 64 ; loop++) {
      if (loop == 0) {
         printf( "      GENERIC MAP ( INIT_00 => X\"" );
      } else {
         printf( "                    INIT_%02X => X\"" , loop );
      }
      for (sort = 31 ; sort > -1 ; sort--) {
         printf("%02X",rom[loop*32+sort] );
      }
      if (loop != 63) {
         printf( "\",\n" );
      } else {
         printf( "\")\n" );
      }
   }
   return 0;
}