---

counter.c

/***************************************************************************
                          counter.c  -  description
*/

/***************************************************************************
                             -------------------
    begin                : Tue Dec 30 2003
    copyright            : (C) 2003 by NZG
    email                : ngustavson@emacinc.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/types.h>
#include <asm/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <sched.h>
#include <sys/resource.h>
#include <sys/io.h>
#include <E12user.h>
#include <packet.h>
#include <coprocessor.h>
#include <counter.h>
#include <curses.h>
#include <form.h>

//#define COLOR_FIELDS  uncomment this to display the fields in color
#define COLOR_FORE COLOR_BLACK
#define COLOR_BACK COLOR_GREEN


#define ARGCHECK(num){if(argc<=num){printf("invalid number of arguements\n");help();return -1;}}

#define OPENDEV(filed,dev){if((filed = open(dev, O_RDWR))<=0){printf("couldn't open %s\n",dev);return -1;}}

/*here are some graphics locations*/

#define YSTART 4

#define HEADER_Y YSTART-1

#define FIELDSEP 7

#define FIELDNUM 6

enum FIELDNUMBERS {COUNT,RELOAD,TRIG,FLAG,ZERO,FREQ};


/*field locations*/
#define NUM_X      3 + FIELDSEP
#define COUNT_X  NUM_X + FIELDSEP
#define RELOAD_X   COUNT_X + FIELDSEP
#define TRIG_X      RELOAD_X + FIELDSEP
#define FLAG_X     TRIG_X + FIELDSEP
#define ZERO_X    FLAG_X + FIELDSEP
#define FREQ_X    ZERO_X + FIELDSEP
#define FIRST_FIELD COUNT_X

#define ARRAYCALC (channel*FIELDNUM + fieldnum)  //array element number calculation

/*coordinates for extra messages*/
#define MESSAGE_Y  (YSTART+COUNTNUM + 2)
#define MESSAGE_X  0

/*global variables for saving the location of the cursor*/
int current_y,current_x;
#define CURSEMESSAGE(fmt, args...) {getsyx(current_y,current_x);mvprintw(MESSAGE_Y,MESSAGE_X,fmt, ## args);setsyx(current_y,current_x);}


volatile int modified;
FIELD *counter_field[COUNTNUM*FIELDNUM+1];//+1 required for null terminated list
FORM *counter_form;
int global_fd;
Cop_Data *Cop;

const char *trig_strings[] = {"       ","rise   ","fall   ","any    ",NULL};
const char *flag_strings[] = {"       ","__N    ","_R_    ","_RN    ","S__    ","S_N    ","SR_    ","SRN    ",NULL};



static int indexenum(const char *enumptr, const char **fieldptr)
{
int index;

for(index=0;index<10;index++)
{
if(!(strcmp(enumptr,fieldptr[index])))
  return index;
}
return 0;
}

/*Destroy the form
destroys the global forms created at initialization
*/
static void destroyform()
{
int channel,fieldnum;
FORM *form = counter_form;

unpost_form(form);
free_form(form);


for(channel=0;channel<COUNTNUM;channel++)
  for(fieldnum=0;fieldnum<FIELDNUM;fieldnum++)
    free_field(counter_field[ARRAYCALC]);

endwin();
}

static int help(void)
{
const char *help_table = "**********************************************
*e12count                                    *
*Nathan Z. Gustavson                         *
*Emac.inc                                    *
*"__DATE__"                                 *
*usage:                                      *
*e12count device                             *
*ex                                          *
*e12count /dev/37e12                         *
**********************************************\n";
printf("%s",help_table);
return 0;
}

static void field_commit_change(FORM *form)
{
FIELD *field =  current_field(form);
int index =  field_index(field);
int counter = index/FIELDNUM;
int fieldnum = index%FIELDNUM;
int fd = global_fd;
//void *dataptr = field_arg(field);
char *dataptr = field_buffer(field,0);
int count;
countconfig *oldconfig = &Cop->counter_config[counter];
int trigger,threshold,flags;

if(!modified)//no change to this field, just exit
  return;

switch(fieldnum)
  {
    case COUNT:
    count = atoi(dataptr);
    E12_CounterLoad(fd, counter,count, Cop);
    break;

    //change to the reload(threshold) value, call E12_Count config, pass other variables from the shadow
    case RELOAD:
    threshold = atoi(dataptr);
    E12_CountConfig(fd, counter, oldconfig->trigger, threshold,oldconfig->flags,Cop);
    break;

    //change the trigger value, this program starts and stops the counter based on whether the trigger is enabled
    case TRIG:
    trigger = indexenum(dataptr, trig_strings);
    E12_CountConfig(fd, counter, trigger, oldconfig->threshold,oldconfig->flags,Cop);
    if(trigger)
      E12_CountCommand(fd,counter, ICSTART);
    else
      E12_CountCommand(fd, counter,ICSTOP);
    CURSEMESSAGE("trigger changed to %u\n",trigger);
    break;

     //change to the flag value, call E12_Count config, pass other variables from the shadow
    case FLAG:
    flags  =  indexenum(dataptr, flag_strings);
    E12_CountConfig(fd, counter, oldconfig->trigger, oldconfig->threshold,flags,Cop);
    CURSEMESSAGE("flags changed to %u\n",flags);
    break;
  }

modified=0; //field has been updated

}

/*Initialize the Form
This function sets up the form that is used to control the counters
*/
static int InitForm()
{
int channel,fieldnum;
/* Initialize curses */
initscr();
start_color();
cbreak();
noecho();
keypad(stdscr, TRUE);
//halfdelay(1);
nodelay(stdscr, TRUE);

modified=0; //flag indicating a change has happened to a field, and a commit change is pending.
    /* Initialize the fields */

init_pair(1, COLOR_FORE, COLOR_BACK);
init_pair(2, COLOR_FORE, COLOR_BACK);

for(channel=0;channel<(COUNTNUM);channel++)
{
  for(fieldnum=0;fieldnum<(FIELDNUM);fieldnum++)
    {
    counter_field[ARRAYCALC] = new_field(1, FIELDSEP, YSTART+channel, FIRST_FIELD+(fieldnum*FIELDSEP), 0, 0);
     /* Set field options */

#ifdef COLOR_FIELDS
    set_field_fore(counter_field[ARRAYCALC], COLOR_PAIR(1));
    set_field_back(counter_field[ARRAYCALC], COLOR_PAIR(2));
#endif
    set_field_back(counter_field[ARRAYCALC], A_UNDERLINE);  /* Print a line for the option  */
    field_opts_off(counter_field[ARRAYCALC], O_AUTOSKIP);   /* Don't go to next field when this */

    switch(fieldnum)
    {
    case COUNT:
    set_field_type(counter_field[ARRAYCALC],          /* field to alter */
                   TYPE_INTEGER,          /* type to associate */
                   0,           /* # places to zero-pad to */
                   0, 65535);   /* valid range */
    break;

    case RELOAD:
    set_field_type(counter_field[ARRAYCALC],          /* field to alter */
                   TYPE_INTEGER,          /* type to associate */
                   0,           /* # places to zero-pad to */
                   0, 65535);   /* valid range */
    break;

    case TRIG:
    set_field_type(counter_field[ARRAYCALC],          /* field to alter */
                   TYPE_ENUM,          /* type to associate */
                   trig_strings,           /* # valid TRIG strings*/
                   0, 0);
    break;
    case FLAG:
    set_field_type(counter_field[ARRAYCALC],          /* field to alter */
                   TYPE_ENUM,          /* type to associate */
                   flag_strings,           /* # valid FLAG strings */
                   0, 0);
    break;

    }


    }

}
counter_field[COUNTNUM*FIELDNUM+1] = NULL;

/* Create the form and post it */
counter_form = new_form(counter_field);
set_field_term(counter_form, field_commit_change);
post_form(counter_form);
refresh();

mvprintw(HEADER_Y, NUM_X, "count");
mvprintw(HEADER_Y, COUNT_X, "value");
mvprintw(HEADER_Y, RELOAD_X, "load ");
mvprintw(HEADER_Y, TRIG_X, "trig ");
mvprintw(HEADER_Y, FLAG_X, "flags");
mvprintw(HEADER_Y, ZERO_X, "zeros");
mvprintw(HEADER_Y, FREQ_X, "freq ");

for(channel=0;channel<(COUNTNUM);channel++)
  mvprintw(YSTART+channel, NUM_X+2, "%u",channel);

refresh();

set_current_field(counter_form, counter_field[0]); /* Set focus to the colored field */

return 0;
}

static int handlecrossing(Cop_Data *Cop)
{
int channel;
int fieldnum;
int freq = 0;
char freqstring[FIELDSEP+1];
char zerostring[FIELDSEP+1];

for(channel=0;channel<COUNTNUM;channel++)
{
  if(Cop->parsemask.zero&(1<<channel))
    {
      CURSEMESSAGE("channel = %u\nlaststamp=%lu\ntimestamp=%lu\nlaststart =%lu\nstart = %u\n",channel,Cop->counter_data[channel].laststamp,Cop->counter_data[channel].timestamp,Cop->counter_data[channel].laststart,Cop->counter_data[channel].countstart);
      if(Cop->counter_data[channel].zerocross)//if this is a zerocrossing and not the initial timestamp
        freq = E12_CounterCalcFreq(channel, Cop);
      sprintf(freqstring,"%u",freq);
      fieldnum=FREQ;
      set_field_buffer(counter_field[ARRAYCALC],0,freqstring);
      sprintf(zerostring,"%u",Cop->counter_data[channel].zerocross);
      fieldnum=ZERO;
      set_field_buffer(counter_field[ARRAYCALC],0,zerostring);
    }

}
return 0;
}


/*Update the fields from the Cop data structure
@param Cop the data structure to update the fields from
*/
void UpdateFields(Cop_Data *Cop)
{
int channel;
int fieldnum;
char buffer[FIELDSEP+1];

for(channel=0;channel<COUNTNUM;channel++)
  {
    fieldnum = RELOAD;
    sprintf(buffer,"%u",Cop->counter_config[channel].threshold);
    set_field_buffer(counter_field[ARRAYCALC],0,buffer);
    fieldnum = TRIG;
    set_field_buffer(counter_field[ARRAYCALC],0,trig_strings[Cop->counter_config[channel].trigger]);
    fieldnum = FLAG;
    set_field_buffer(counter_field[ARRAYCALC],0,flag_strings[Cop->counter_config[channel].flags]);
  }

}

/*Display current counter readings.
The counters that are not "masked" are refreshed by reading from the 37e12 and updating the fields.
@param fd the device to address
@param form the form to update
@param Cop the cop data structure storing counter information
@param mask bitmask of the counters to refresh(in this program this is all but the currently selected field)
*/
static int DisplayCounters(int fd, FORM *form, Cop_Data *Cop, unsigned char mask)
{
int channel;
char buffer[1000];
int fieldnum=0;
char countstr[FIELDSEP+1];
__u32 typemask=0;
int rxnum=0;

for(channel=0;channel<COUNTNUM;channel++)
{

if(mask&(1<<channel))
  {
    E12_CounterReadRQ(fd, channel);//request data

        while(!(typemask&(COUNTRESPONSE)))  //wait for data
        {//disregard any other data
          rxnum =read(fd,buffer,sizeof(buffer));//read data
          typemask = E12_Packet_Route(Cop,buffer, rxnum);//dig for AtoD data

          if(typemask&(NOTIFYRESPONSE))//zero cross notification received
              handlecrossing(Cop);
        }

    sprintf(countstr,"%u",Cop->counter_data[channel].counter);

    set_field_buffer(counter_field[ARRAYCALC],0,countstr);
    typemask=0;
  }
}

return 0;
}

/*Display counters not currently being modified
This is a wrapper around Display counters that sets the mask.
The mask is used to prevent counters currently being modified(the cursor is on that field) from changing dynamically.
*/
static int DisplayUnusedCounters(int fd, FORM *form, Cop_Data *Cop)
{
FIELD *field =  current_field(form);
int index =  field_index(field);
int counter = index/FIELDNUM;
int fieldnum = index%FIELDNUM;
unsigned char mask = 0xff;

if(fieldnum==COUNT)
{
  mask&=~(1<<counter);
//CURSEMESSAGE("counter %u masked\n",counter);
}
DisplayCounters(fd,counter_form,Cop,mask);
return 0;
}


/*Insert a character into a field
This calls form_driver to write to a field and updates the modified flag if the current field is valid
*/
static int Insert_char(FORM *form,char ch)
{
FIELD *field =  current_field(form);
int index =  field_index(field);
int fieldnum = index%FIELDNUM;

if(fieldnum<ZERO)//if this is a writable field, zero and freq are not
  {
   modified=1; //field has been modified
  form_driver(counter_form, ch);
  }
return 0;
}


/*Display the form and counters, also handle any input from the keyboard
*/
static int Form_Display(int fd)
{
int ch;

Cop = CopDeviceCreate(0);

UpdatetHardwareCounterInfo(fd, Cop);
UpdateFields(Cop);

while((ch = getch()) != KEY_F(1))
    {   
      DisplayUnusedCounters(fd,counter_form,Cop);
      switch(ch)
        {   case KEY_DOWN:
                /* Go to next field */
                form_driver(counter_form, REQ_DOWN_FIELD);
                /* Go to the end of the present buffer */
                /* Leaves nicely at the last character */
                //form_driver(counter_form, REQ_END_LINE);
                break;
            case KEY_UP:
                /* Go to previous field */
                form_driver(counter_form, REQ_UP_FIELD);
                //form_driver(counter_form, REQ_END_LINE);
                break;
            case KEY_LEFT:
                /* Go to previous field */
                form_driver(counter_form, REQ_LEFT_FIELD);
                //form_driver(counter_form, REQ_END_LINE);
                break;
            case KEY_RIGHT:
                /* Go to previous field */
                form_driver(counter_form, REQ_RIGHT_FIELD);
                //form_driver(counter_form, REQ_END_LINE);
                break;
            case KEY_BACKSPACE:
                /* Go to previous field */
                form_driver(counter_form, REQ_DEL_PREV);
            modified=1;//field has been modified
//              form_driver(counter_form, REQ_PREV_CHAR);
                break;
            case 10:
            /*enter was pressed, commit the current field's value*/
            modified=1; //treat field as modified
            //toggle position to turn on autocomplete
            form_driver(counter_form, REQ_RIGHT_FIELD);
            form_driver(counter_form, REQ_LEFT_FIELD);
                break;
            case ERR:  //no key returned, just return to the top loop
          break;
            default:
                /* If this is a normal character modify the current field */
            Insert_char(counter_form, ch);
                break;
        }
    }

CopDeviceDestroy(Cop);
return 0;
}

int main(int argc, char **argv)
{
int fd;
ARGCHECK(1);
OPENDEV(fd,argv[1]);
global_fd = fd;
InitForm();
Form_Display(fd);
close(fd);
destroyform();
return 0;
}

---