---

Timky.cxx

Go to the documentation of this file.

//File: Timky.cxx

/* ---------------------------------------------------------------------------
 * Execute TIM keywords read from a file or interactively
 *
 * Author : J.B.Lane UCL January 2001                                  timky.c
 * ---------------------------------------------------------------------------
 */

#include <iostream>
#include <string.h>  /* strstr (strchr) strcmp */
#include  <ctype.h> /* toupper */

using namespace std;  // needed here for VmeModule!

#include "../RodCrate/TimDefine.h"
#include "../RodCrate/TimSequin.h"
#include "../RodCrate/TimModule.h"
#include "../VmeInterface/RCCVmeInterface.h"
//#include "../CommonWithDsp/processor.h"

#include  "../Timlet/ask.h" // OK clashes with VmeInterface

/* Definitions */

enum name {NONE = -999} ;

#define MAXLINE 128

using namespace SctPixelRod; // L1A etc undeclared if before includes

/* Prototypes */

int  damon(const char *FileName, unsigned short *buffer);
int  winky(const char *FileName);
int  open_window(const int Addr, const int Mode);
FILE *open_file(const char *FileName, const char *FileMode);
int  close_file(FILE *fp, const char *FileName);
void test(void);
void timKeyword(const char *String);

const UINT32 baseAddr = 0x0D000000;  // VME base address for TIM slot 13
const UINT32  mapSize =    0x10000;  // VME window size

VmeInterface *vme = new RCCVmeInterface();  // Create VME interface
TimModule    *tim = new TimModule( baseAddr, mapSize, *vme );  // Create tim
TimSequin    *seq = new TimSequin();  // Create

int main (int argc, char *argv[])
{
  if (vme == 0 || tim == 0 || seq == 0) {
    cout << "No object " << vme << tim << seq << endl;
  }
  const char *FileName = argv[1];
  int r;

  if (argc > 1)
  {
    r = winky( FileName);
  }
  else
  {
    r = 0;
//***    memory_ptr = ask_vme () ;
//***  open_window(Addr, Mode) ;
    //    if (memory_ptr != NULL) test () ;
    //    else printf ("Error opening VME window\n") ;

    test () ;
  }

  delete seq;
  delete tim;
  delete vme;
  return r;
}

unsigned short* vme_get_window (const int dummy0,
                                const int dummy1, const int dummy2) {
  return 0;
}

int open_window(const int Addr, const int Mode)
{
  printf("addr: %x\n", Addr);
  //  memory_ptr = vme_get_window(Addr, Mode); /* open VME window */
  //  if (memory_ptr == NULL)
  {   printf("error mapping window\n");
      return 1;
  }
  tim->reset();
  tim->initialize();

  return 0;
}

FILE *open_file(const char *FileName, const char *FileMode)
{
  FILE *fp;

  fp = fopen(FileName, FileMode);
  if (fp == NULL)
  {   printf("can't open file %s\n", FileName);
      perror(FileName);
      return fp;
  }
  printf("\nreading file %s\n\n", FileName);

  return fp;
}

int close_file(FILE *fp, const char *FileName)
{
  if (ferror(fp))
  {   printf("error reading file %s\n", FileName);
      perror(FileName);
      return 1;
  }
  if (fclose(fp) == EOF) printf("error closing file\n"); /* fp is not const */
  return 0;
}

int winky(const char *FileName)
{
  char   line[MAXLINE];      /* input line  (includes final \0) */
  FILE *fp;                  /* file pointer */
  int  r;

/***
  printf("VME base address is first line in file,  then each line is:\n"
         "[addr[ data]][text]\n"
         " addr = D16 offset in hex           (blank means text only)\n"
         " data = D16 data   in hex for write (blank means  VME read)\n"
         " text : any ? character or wait string means prompt\n "
         "       any \" character or blank line  means comment"
         " (line not printed)\n\n"
        );
***/

  /* recursive use of timKeyword */
  timKeyword("REST"); /* clear buffer */

  fp = open_file(FileName, "r");
  if (fp == NULL) return 1;

  while (!feof(fp))
  { if (fgets(line, MAXLINE, fp) != NULL)    /* trap end of file or error */
    {
      printf("file: %s", line);

/***  else if (nval == EOF) ; */              /*     blank line = comment */

      timKeyword(line);

      if (strstr(line, "wait") != NULL)          /* wait present = prompt */
      {   printf("Press Return to continue :");
          (void) getchar();
          printf("\n");
      }
    }
  }
  printf("end of file\n");

  r = close_file(fp, FileName);

  return r;
}

int damon(const char *FileName, unsigned short *buffer)
{
  unsigned int word;
  int          byte, i, n, r;
  FILE *fp;                  /* file pointer */

  /* recursive use of timKeyword */
  timKeyword("REST"); /* clear buffer */

  fp = open_file(FileName, "rb"); /* binary */
  if (fp == NULL) return 1;

  i = 0;
  n = 0;
  while (!feof(fp))
  {
    byte = fgetc(fp); /* read a byte */
    word = 0;
    if (byte != EOF)    /* trap end of file or error */
    {
      if (byte != 0)
      {
        if (n%2 == 1)
            printf("ERROR odd byte: %5d %5o %4x %2X\n", n, n, n, byte);

        /* swap bit order */

        if (byte & 0x20) word |= TIM_L1A;
        if (byte & 0x10) word |= TIM_ECR;
        if (byte & 0x08) word |= TIM_BCR;
        if (byte & 0x04) word |= TIM_CAL;
        if (byte & 0x02) word |= TIM_SID;
        if (byte & 0x01) word |= TIM_STT;

        printf("%5d %4x %2X %2X\n", n/2, n, byte, word);
/*      printf("%2X%c", byte, (n%20==19) ? '\n' : ' '); */
        i ++;
        if (n/2 < TIM_SEQ_SIZE) buffer[n/2] = word; /* store byte */
        else printf("ERROR: buffer overflow");
      }
      n ++;
    }
  }
  printf("\nend of file after %d bytes %d non-zero\n\n", n, i);

  r = close_file(fp, FileName);

  return r;
}

void test (void)
{
  char line[MAXLINE] = "HELP";
  int r ;

  timKeyword("REST"); /* clear buffer */

  tim->reset();
  tim->initialize();

  for ( ; ; )
  {
    r = ask_line ("Enter keyword [value] (eg MENU)", line, line);
    timKeyword(line);
  }
}

void timKeyword(const char *String)
{
  static unsigned short buffer[TIM_SEQ_SIZE];
  /*
  enum keywords
   {
      HELP , MENU , A24  , A32  , FILE , MODE , L1Ac , ECRc , BCRc , CALc ,
      DUMP , FILL , LOAD , PEEK , POKE , READ , RUN  , SCAN , SIZE , DAMO ,
      REST
   };
  */
  typedef enum
   {
      HELP , MENU , A24  , A32  , FILE , MODE , L1Ac , ECRc , BCRc , CALc ,
      DUMP , FILL , LOAD , PEEK , POKE , READ , RUN  , SCAN , SIZE , DAMO ,
      REST
   } keywords;
  static const int Command[] =
   {
      HELP , MENU , A24  , A32  , FILE , MODE , L1Ac , ECRc , BCRc , CALc ,
      DUMP , FILL , LOAD , PEEK , POKE , READ , RUN  , SCAN , SIZE , DAMO ,
      REST
   };
  static const char * Name[] =
   {
     "HELP","MENU","A24" ,"A32" ,"FILE","MODE","L1A" ,"ECR" ,"BCR" ,"CAL" ,
     "DUMP","FILL","LOAD","PEEK","POKE","READ","RUN" ,"SCAN","SIZE","DAMO",
     "REST"
   };
  static const char * Help =
   {
     "To run TIM sequencer, prepare program's buffer, then LOAD and RUN.\n"
     "Numbers are hex by default.\n"
     "HELP: description of commands\n"
     "MENU: list of commands\n"
     "REST: reset buffer, L1ID, BCID, MODE, SIZE\n"
     "A24  [addr ]: open VME A24 base address\n"
     "A32  [addr ]: open VME A32 base address\n"
     "DAMO [name ]: read Damon's binary file into buffer\n"
     "FILE [name ]: execute file of these commands\n"
     "L1A  [index]: add L1A in buffer[index]\n"
     "ECR  [index]: add ECR in buffer[index]\n"
     "BCR  [index]: add BCR in buffer[index]\n"
     "CAL  [index]: add CAL in buffer[index] (without L1A)\n"
     "DUMP [byte ]: dump TIM info to screen (byte 0 = source, 1 = sink)\n"
     "FILL [value]: fill buffer with value\n"
     "LOAD        : load TIM sequencer with buffer\n"
     "MODE        : toggle mode stand-alone/TTC\n"
     "RUN         : run  TIM sequencer\n"
     "SCAN        : scan buffer (in program's memory)\n"
     "SIZE        : set  buffer and TIM sequencer size (16-bit words)\n"
     "PEEK [addr ]      : read  data at byte address\n"
     "POKE [addr ][data]: write data at byte address\n"
     "READ [addr ][size]: read  data at byte address for size (16-bit words)\n"
   };
/* warning: string length `1037' is greater than the minimum length `509'
 *  ISO C89 is required to support
 */
  static      char fileName[MAXLINE] = "../RodCrate/timky.dat"; /* default */
  static      char damoName[MAXLINE] = "../source/4SctEvts.timData";
  static const int SizeCmd = sizeof(Command) / sizeof(int);
  static       int   size     = TIM_SEQ_SIZE;
  static       int   runMode  = 0; /* default is VME mode */
  int nval, index, i, r;
  unsigned int addr;
  char token[MAXLINE] = "";
  int value = NONE;
  int extra = NONE;
  int key = NONE;

  nval = sscanf(String, "%s %i %i", token, &value, &extra);

  for (i = 0 ; (token[i] = toupper((int)token[i])) != '\0' ; i ++)
      ;

  if (nval < 2 && value != NONE) printf ("Oops\n");
  if (nval < 3 && extra != NONE) printf ("Oops\n");

  for (i = 0 ; i < SizeCmd ; i ++)
      if (strcmp(token,Name[i]) == 0) key = Command[i];

  keywords keyword = (keywords) key;

  switch (keyword)
  {
    case DAMO:
      nval = sscanf(String, "%s %s", token, damoName);
      if (nval != 2) r = ask_line("Enter file name", damoName, damoName);
      break;
    case FILE:
      nval = sscanf(String, "%s %s", token, fileName);
      if (nval != 2) r = ask_line("Enter file name", fileName, fileName);
      break;
    case A24 :
    case A32 :
      if (value == NONE) r = ask_int ("Enter addr ", 0, &value);
      break;
    case READ:
      if (extra == NONE) r = ask_int ("Enter words", 0, &extra);
    case POKE:
      if (extra == NONE) r = ask_int ("Enter value", 0, &extra);
    case PEEK:
      if (value == NONE) r = ask_int ("Enter addr ", 0, &value);
      if (value < (int)mapSize) /* cast ***/
          addr = value;
      else
      { printf("ERROR: addr %04x out of range\n", value);
        addr = 0;
      }
      break;
    case ECRc:
    case BCRc:
    case CALc:
    case L1Ac:
      if (value == NONE) r = ask_int ("Enter index", 0, &value);
      if (value < size)
          index = value;
      else
      { printf("ERROR: index %04x >= size %04x\n", value, size);
        index = size - 1;
      }
      break;
    case DUMP:
      if (value == NONE) r = ask_int ("Enter byte ", 1, &value);
      break;
    case FILL:
      if (value == NONE) r = ask_int ("Enter value", 0, &value);
      break;
    case SIZE:
      if (value == NONE) r = ask_int("Enter sequencer RAM size", size, &value);
      if (value <= TIM_SEQ_SIZE)
          size = value;
      else
      { printf("ERROR: size %04x out of range\n", value);
        size = TIM_SEQ_SIZE;
      }
      break;
    default :
      break;
  }
  /*
  printf(" cmd: token %s value %i %04x extra %i %04x key %i\n",
                token,   value, value, extra, extra, key);
  */
/* NB when should l1id be reset? ***/

  switch (keyword)
  {
    case REST:
      seq->reset();
      tim->reset();
      tim->initialize();

      runMode  = 0;
      size = TIM_SEQ_SIZE;
      for (i = 0 ; i < TIM_SEQ_SIZE ; i ++)
          buffer[i] = 0;
      break;
    case DAMO:
      r = damon(damoName, buffer);
      break;
    case FILE:
      r = winky(fileName);
      break;
    case A24 :
      /* what if r = 1 ? ***/
      r = open_window(value, DIPSY_A24);
      break;
    case A32 :
      r = open_window(value, DIPSY_A32);
      break;
    case MODE:
      if (runMode)
      {   runMode = 0;
          //***          timSetupVME();
          printf("Setup VME mode\n");
      }
      else
      {   runMode = 1;
          //***          timSetupRun();
          printf("Setup Run mode\n");
      }
      break;
    case READ:
      /* check for extra overflow ***/
      for (i = 0 ; i < extra ; i ++)
          printf("%04X%c",tim->vmeFetch( i*2+addr ), (i%16==15) ? '\n' : ' ');
      printf ("\n");
      break;
    case POKE:
      tim->vmeLoad( addr, extra );
      break;
    case PEEK:
      printf("addr %04x data %04X\n", addr, tim->vmeFetch( addr ));
      break;
    case ECRc:
      seq->addByIndex(TIM_ECR, index);
      break;
    case BCRc:
      seq->addByIndex(TIM_BCR, index);
      break;
    case CALc:
      seq->addByIndex(TIM_CAL, index);
      break;
    case L1Ac:
      seq->addByIndex(TIM_L1A, index);
      break;
    case DUMP:
      tim->status();
      tim->seqFetch( size, buffer );
      seq->scanRun();

//*** timDump(size, value); /* 0 = source, 1 = sink */
      break;
    case FILL:
      seq->fill( size, value );
      break;
    case LOAD:
      /* timWait_seqBusys(); think ***/

      seq->getBuffer( size, buffer );
      tim->seqLoad(   size, buffer );
      break;
    case RUN :
      tim->seqRun( size ); /* end = 0x4000 sees 0 */
      break;
    case SCAN:
      seq->scanRun();
      break;
    case SIZE:
      break;
    case MENU:
      for (i = 0 ; i < SizeCmd ; i ++)
          printf("%4s%c", Name[i], (i%16==15) ? '\n' : ' ');
      printf ("\n");
      break;
    case HELP:
      printf("\n%s\n", Help);
      break;
    case NONE:
      printf ("NONE\n");
      break;
    default :
      printf("\n Trouble at Mill \n");
      break;
  }
}

---