/*$*********************************************************************\

Name:           : hv

Source File     : hv.c

Description     : Example program for a hv set and read task

Syntax:         : hv [host [port]]

Parameters      : host - name of host to connect
                  port - number of port to connect

Returncode      : 1 on error

Comments        : -
						
Error Messages  : -
  
Date            : ?

Updates         : 06.04.95 revised  //MAF

Author          : Klaus Ackerstaff (ack@hermes.desy.de)
                  Marc-Andre Funk  (maf@hermes.desy.de) 

Remarks         : -

\*************************************************************************/


/*==================================================================*\
    Includes
\*==================================================================*/
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <ctype.h>

#include <dad/config.h>
#include <adamo.h>
#include <dad.h>

#include "hvValue.h"
#include "scCommand.h"
#include "portdef.h"		/* edit this file! */

  
/*==================================================================*\
    Private defines
\*==================================================================*/
#define CHANNELS 5




/*==================================================================*\
    Local symbols
\*==================================================================*/
static void  HvFill( void );
static int   CommandEvaluate( int );
static int   HvRunning = 1;
static float base[10];
#if defined(sgi) || defined(__sgi__) || defined(__sgi)
  int f77argc, f77argv;
#endif


/*==================================================================*\
    The main function
\*==================================================================*/
int main( int argc, char* argv[] )
{
  int   port,
        HvId,
        CmId,
        tabid,
        rowid,
        err,
        i;
  char *eptr;
  
/*------------------------------------------------------------------*\
  Initialize ADAMO (init TAP library)
\*------------------------------------------------------------------*/
  INISMALL();

/*------------------------------------------------------------------*\
  Use default protocol
\*------------------------------------------------------------------*/
  if( argc==1 ) {
    dadHost( "localhost", "INET", MYPORT, "hvValues",
	   CAC_READ | CAC_WRITE | CAC_UPDATE | CAC_BOOK  );
    dadHost( "localhost", "INET", MYPORT, "scCmds",
	     CAC_READ | CAC_WRITE | CAC_BOOK  );
  }

/*------------------------------------------------------------------*\
  The user specified another host
\*------------------------------------------------------------------*/
  else if( argc==2 ) {		
    dadHost( argv[1], "INET", MYPORT, "hvValues",
	   CAC_READ | CAC_WRITE | CAC_UPDATE | CAC_BOOK  );
    dadHost( argv[1], "INET", MYPORT, "scCmds",
	     CAC_READ | CAC_WRITE | CAC_BOOK  );
  }

/*------------------------------------------------------------------*\
  The user specified another host and port
\*------------------------------------------------------------------*/
  else if( argc==3 ) {
    port = strtol( argv[2], &eptr, 10 );
    if( !isdigit(*argv[2]) || *eptr ) {
      fprintf( stderr, "%s: bad port number '%s'\n",
                       argv[0], argv[2] );
      exit ( 1 );
    }
    dadHost( argv[1], "INET", port, "hvValues",
	   CAC_READ | CAC_WRITE | CAC_UPDATE | CAC_BOOK  );
    dadHost( argv[1], "INET", port, "scCmds",
	     CAC_READ | CAC_WRITE | CAC_BOOK  );
  }

/*------------------------------------------------------------------*\
  Uuups....
\*------------------------------------------------------------------*/
  else {
    fprintf( stderr, "usage: %s [host [port]]\n", argv[0] );
    exit ( 1 );
  }

/*------------------------------------------------------------------*\
  Connect to the host
\*------------------------------------------------------------------*/
  dadConnect( "hvValues", &HvId, &err );
  if( err ) {
    fprintf( stderr, "dadConnect failed for hvValues %d\n", err );
    exit( 1 );
  }
  dadConnect( "scCmds",   &CmId, &err);
  if( err ) {
    fprintf( stderr, "dadConnect failed for scCmds %d\n", err );
    exit( 1 );
  }


/*------------------------------------------------------------------*\
  Init the channel values
\*------------------------------------------------------------------*/
  for( i=0; i<CHANNELS; i++){
    base[i] = 1000.;
  }

/*------------------------------------------------------------------*\
  Book the commands
\*------------------------------------------------------------------*/
  dadBookIf( CmId, scCommand.sccommand, "cReceiver = 'HVSET'", &err );
  if( !err )
    dadBookDoNow( CmId, &err);
  if( err ) {
    fprintf( stderr, "dadBook failed %d\n", err );
    exit( 1 );
  }

/*------------------------------------------------------------------*\
  This is the event loop
\*------------------------------------------------------------------*/
  for(;;) {

/*------------------------------------------------------------------*\
  Wait for next message
\*------------------------------------------------------------------*/
    dadMsg( CmId, 10000, &tabid, &rowid, &err);
    
/*------------------------------------------------------------------*\
  Error other then timeout?
\*------------------------------------------------------------------*/
    if( err && err!=-aETimeout ) {
      fprintf( stderr, "dadMsg failed %d\n", err );
      exit( 1 );
    }

/*------------------------------------------------------------------*\
  If there was an command, parse and execute it.
  We may leave the main loop on the exit command.
\*------------------------------------------------------------------*/
    if( !err ) {
      if( CommandEvaluate(CmId) )
	break;
    }
    
/*------------------------------------------------------------------*\
  Fill the HV table (simulate meassurement) and send it.
\*------------------------------------------------------------------*/
    HvFill();		
    dadWUpdate( HvId, hvValue.hvvalue, 0, &err);
    if( err ) {
      fprintf( stderr, "dadWUpdate failed %d\n", err );
      exit( 1 );
    }
  } /* end of:  for(;;) */
   
/*------------------------------------------------------------------*\
  Close down Dad and exit
\*------------------------------------------------------------------*/
  dadExit();
  return 0;
}
    
  
/*==================================================================*\
    Fill the table of current values.
\*==================================================================*/
void HvFill( void )
{
  int channel;

/*------------------------------------------------------------------*\
  First clear table
\*------------------------------------------------------------------*/
  CLETAB( hvValue );

/*------------------------------------------------------------------*\
  Loop over all channels
\*------------------------------------------------------------------*/
  for( channel=0; channel<CHANNELS; channel++ ) {
    hvValue.ID = channel+1;

/*------------------------------------------------------------------*\
  Set all values to zero, if we're not running (for security).
\*------------------------------------------------------------------*/
    if( !HvRunning ) 
      hvValue.Value = 0.0;

/*------------------------------------------------------------------*\
  Simulate one messurement. We may not get all values for every
  cycle.
\*------------------------------------------------------------------*/
    else {
      if( rand()%100 < 20 )
        continue;
      hvValue.Value = (float)( rand()%200-100 + base[channel] );
    }

/*------------------------------------------------------------------*\
  Insert this value with current time
\*------------------------------------------------------------------*/
    hvValue.iTimeStart = time(0);
    INSTAB( hvValue );
  }
  
/*------------------------------------------------------------------*\
  Thats all!
\*------------------------------------------------------------------*/
  return;
}


/*==================================================================*\
    Evaluate a received command
\*==================================================================*/
int CommandEvaluate( int CmId )
{
  char   buffer[65],
        *argv[65],
        *ptr;
  int    argc,
         channel,
         retcode,
         stopit = 0;
  double value;
  time_t now;
  
/*------------------------------------------------------------------*\
    We're expecting one command line
\*------------------------------------------------------------------*/
  if( COUTAB(scCommand)!=1 ) {
    sprintf( buffer, "Sorry, expecting one command, not %d!",
                     COUTAB(scCommand) );
  }

/*------------------------------------------------------------------*\
    Get the command into our buffer
\*------------------------------------------------------------------*/
  else {
    FETTAB( scCommand, ID, 1 );
    FCB2CSTR( scCommand.cCommand, buffer, 0);

/*------------------------------------------------------------------*\
    Parse the buffer and get arguments
\*------------------------------------------------------------------*/
    for( argc=0,ptr=strtok(buffer," \t\n");
        ptr ;
        argc++,ptr=strtok(NULL," \t\n") )
      argv[argc] = ptr;

/*------------------------------------------------------------------*\
    Set a channel value
\*------------------------------------------------------------------*/
    if( !strcasecmp(argv[0],"set") ) {
      if( argc!=3 )
        strcpy( buffer, "Usage: set <ch> <value>" );
      else {
        channel       = atoi( argv[1] );
        if( channel>=1 && channel<=CHANNELS ) {
          base[channel-1] = atof( argv[2] );
          sprintf( buffer, "%s: channel #%d to %.1f V.",
                   argv[0], channel, base[channel-1] );
        }
        else
          sprintf( buffer, "%s: No such channel #%d",
                            argv[0], channel );
      }
    }

/*------------------------------------------------------------------*\
    Start serving values
\*------------------------------------------------------------------*/
    else if( !strcasecmp(argv[0],"start") ) {
      if( argc!=1 )
        strcpy( buffer, "Usage: start" );
      else if( HvRunning )
        sprintf( buffer, "%s: Reading was already running.", argv[0] );
      else {
        HvRunning = 1;
        sprintf( buffer, "%s: Reading started.", argv[0] );
      }
    }

/*------------------------------------------------------------------*\
    Stop serving values
\*------------------------------------------------------------------*/
    else if( !strcasecmp(argv[0],"stop") ) {
      if( argc!=1 )
        strcpy( buffer, "Usage: stop" );
      else if( !HvRunning )
        sprintf( buffer, "%s: Reading was already stopped.", argv[0] );
      else {
        HvRunning = 0;
        sprintf( buffer, "%s: Reading stopped.", argv[0] );
      }
    }

/*------------------------------------------------------------------*\
    Terminate the client
\*------------------------------------------------------------------*/
    else if( !strcasecmp(buffer, "exit") ) {
      if( argc!=1 )
        strcpy( buffer, "Usage: exit" );
      else {
        sprintf( buffer, "%s: going down....", argv[0] );
        stopit = 1;
      }
    }

/*------------------------------------------------------------------*\
    Hmm, what's that ?
\*------------------------------------------------------------------*/
    else
      sprintf( buffer, "%s: Command not known.", argv[0] );
  }
  
/*------------------------------------------------------------------*\
    Ok, set the answer
\*------------------------------------------------------------------*/
  scCommand.ID = NEXT;
  C2FCBSTR( buffer    ,  scCommand.cCommand , 0); /* fill the adamo */
  C2FCBSTR( "HVSET"   ,  scCommand.cSender  , 0); /* structure */
  C2FCBSTR( "HVCNTRL" ,  scCommand.cReceiver, 0);
  
/*------------------------------------------------------------------*\
    And write it back to the sender.
\*------------------------------------------------------------------*/
  CLETAB( scCommand );
  INSTAB( scCommand );		
  dadWUpdate( CmId, scCommand.sccommand, 0, &retcode); 
  if( retcode ) {
    fprintf( stderr,"dadWUpdate failed %d\n", retcode );
    exit( 2 );
  }
  CLETAB( scCommand );

/*------------------------------------------------------------------*\
    For demonstration we also report this command to stdout
\*------------------------------------------------------------------*/
  now = time( NULL );
  printf( "%.24s - %s\n", ctime(&now), buffer );
  
/*------------------------------------------------------------------*\
    That's all!
\*------------------------------------------------------------------*/
  return stopit;
}

/*=========================== End Of File ==========================*/