///////////////////////////////////////////////////////////////////////////////////////////////
// DasWin32CFunctions.c
//
// External "C" functions used by DataAcquisitionThread.cpp of DasWin32 project.
//
// Written by Daniel Gottas - NOAA/ETL Meteorological Applications and Assessment Division
///////////////////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#include <io.h>
#include <share.h>
#include <sys\stat.h>
#include "DasWin32Version.h"
#include "commlib.h"

int IsFieldANumber(char *);
void RemoveAlphaBetics(char *);
int IsFieldPrintable(char *);
int WriteToLog(char *,char *);
void wdt(unsigned short,int);
void kill_wdt(unsigned short);
int GetOphirString(PORT *,char *,int,char ,int,int);
void GetOphirConstants(PORT *,char *,int,char *,SYSTEMTIME *);

///////////////////////////////////////////////////////////////////////////           
// function IsFieldANumber: quality controls for alphnumeric characters 
//
int IsFieldANumber(char *Inline)
{
  int num_char=0,i=0,DecimalPoint=0,MinusSign=0,PlusSign=0;

  num_char=strlen(Inline);                 // get length of string
  for(i=0;i<num_char;i++)                  // loop through each character
    { if(Inline[i]=='.') DecimalPoint++;   // step decimal point counter if decimal point ecountered
      if(Inline[i]=='-') MinusSign++;      // step minus sign counter if minus sign ecountered
      if(Inline[i]=='+') PlusSign++;       // step plus sign counter if plus sign ecountered
      if(((!isdigit(Inline[i]))&&(Inline[i]!='.')&&(Inline[i]!=' ')&&
          (Inline[i]!='-')&&(Inline[i]!='+'))||
         (DecimalPoint>1 )||(MinusSign>1)||(PlusSign>1)) return(0); // return 0 if character is not alphanumeric or '.' or ' '
    }
  return(1);                             // return 1 if all characters are alphnumeric
}
///////////////////////////////////////////////////////////////////////////
           
///////////////////////////////////////////////////////////////////////////
// function RemoveAlphaBetics: locates and replaces all alpha-numeric characters with white space
void RemoveAlphaBetics(char *Inline)
{
  int num_char=0,i=0;

  num_char=strlen(Inline);                 // get length of string
  for(i=0;i<num_char;i++)                  // loop through each character
    { if(isalpha(Inline[i]))               // check for alphabetic character
        Inline[i]=' ';                     // replace alphabetic character with space
    }
}   
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////           
// function IsFieldPrintable: quality controls for alphnumeric characters 
//
int IsFieldPrintable(char *Inline)
{
  int num_char=0,i=0;

  num_char=strlen(Inline);             // get length of string
  for(i=0;i<num_char;i++)              // loop through each character
    if((!isprint(Inline[i]))&&
       (Inline[i]!='\n')&&
       (Inline[i]!='\r')) return(0);   // return 0 if character is not printable ASCII
  return(1);                           // return 1 if all characters are alphnumeric
}
///////////////////////////////////////////////////////////////////////////           

///////////////////////////////////////////////////////////////////////////           
// function WriteToLog: Writes a message to hourly log file
//
int WriteToLog(char *OutDriveAndPath,char *Message)
{
  char *OutputFileName;
  int exist=0;
  time_t now=0;
  struct tm *tp;
  FILE *f1;
  SYSTEMTIME LogTime;

  if((OutputFileName=(char *)calloc(500,sizeof(char)))==NULL)
     return(0);     // allocate temp memory for output filename

  time(&now);               // get system time used for filename
  GetSystemTime(&LogTime);  // get system time used for time stamp
  tp=gmtime(&now);          // convert filename time to structure tp

  sprintf(OutputFileName,"%s\\%02d%03d.LOG",
          OutDriveAndPath,tp->tm_year,tp->tm_yday+1);     // formulate log filename

  exist=_access(OutputFileName,0);                        // check for file existance
  if(!exist)                                              // if output file exists
    _chmod(OutputFileName,_S_IWRITE);                     // assign write permission
  if((f1=_fsopen(OutputFileName,"at+",_SH_DENYWR))==NULL) // open log file with file sharing for reading only
    { _chmod(OutputFileName,_S_IREAD);                    // assign read only permission
      if(OutputFileName!=NULL) free(OutputFileName);      // if NULL, free memory
      return(0);                                          // return error flag
    }
  if(exist==-1)
    { fprintf(f1,"DasWin32 Version %s LogFile %02d%03d.LOG\n\n",VERSION_NUMBER,tp->tm_year,tp->tm_yday+1);
      fprintf(f1,"MM/DD/YY HH:MM:SS:MMM CODE MESSAGE\n");
    }
  fprintf(f1,"%02d/%02d/%02d %02d:%02d:%02d:%03d  %s\n",
          LogTime.wMonth,LogTime.wDay,
          LogTime.wYear-(LogTime.wYear/100*100),
          LogTime.wHour,LogTime.wMinute,
          LogTime.wSecond,LogTime.wMilliseconds,
          Message);                                       // output time and message to file
		   
  fclose(f1);                                             // close log file
  _chmod(OutputFileName,_S_IREAD);                        // assign read only permission
  if(OutputFileName!=NULL) free(OutputFileName);          // free memory
  return(1);                                              // return success
}
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
// function wdt: resets the watchdog timer //
void wdt(unsigned short clkbase,int twenty_mils)
{
  _outp((unsigned short)(clkbase + 3),(0x36 | (2 << 6)));     // config ctr 2   
  _outp((unsigned short)(clkbase + 2),0x20);                  // load ctr 2 LSB 
  _outp((unsigned short)(clkbase + 2),0x4E);                  // load ctr 2 MSB 
  _outp((unsigned short)(clkbase + 3),(0x30 | (1 << 6)));     // config ctr 1   
  _outp((unsigned short)(clkbase + 1),twenty_mils);           // load ctr 1 LSB 
  _outp((unsigned short)(clkbase + 1),(twenty_mils >> 8));    // load ctr 1 MSB 
}

///////////////////////////////////////////////////////////////////////////
// function kill_wdt: deactivates the watchdog timer //
void kill_wdt(unsigned short clkbase)
{
  _outp((unsigned short)(clkbase + 3),(0x36 | (2 << 6)));     // config ctr 2
}

////////////////////////////////////////////////////////////////////////////////        
// function GetOphirString: query Ophir for a single line of information
int GetOphirString(PORT *OphPort,char *String,int StringLen,
                   char Query,int NumFields,int MaxTry)
{                
  char *WorkTok;
  int NumTry=0,FieldCount=0;  
  
  if((WorkTok=(char *)calloc(StringLen,sizeof(char)))==NULL) return(0); //allocate working memory
  while((FieldCount!=NumFields)&&(NumTry<MaxTry))  // give MaxTry chances to get NumFields
    { NumTry++;                                    // step NumTry counter
      FieldCount=0;                                // initialize field counter to zero
      String[0]=0;                                 // initialize storage string
      WriteChar(OphPort,Query);                    // query for humidity engineering units
      if(ReadStringTimed(OphPort,String,StringLen,'\r',5000)==ASSUCCESS)    // get string
        { if(!IsFieldPrintable(String))            // check for non-printable characters
	       { NumTry++;                             // step number of tries
	         continue;                             // go to end of while loop
	       }
	    }
      strcpy(WorkTok,String);                      // copy Ophir string to working string
      if(strtok(WorkTok," ")==NULL) continue;      // get first field
      else FieldCount++;                           // step field counter
      while(strtok(NULL," ")!=NULL) FieldCount++;  // get following fields
    }
  if(WorkTok!=NULL) free(WorkTok);                 // free working memory
  if(FieldCount==NumFields) return(1);             // return TRUE if NumFields are acquired
  else return(0);                                  // return FALSE if NumFields are not acquired
}
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////        
// function GetOphirConstants: get Ophir humidity and engineerring constants
void GetOphirConstants(PORT *OphPort,char *OutputDriveAndPath,int PortNumber,
                       char *OphirString,SYSTEMTIME *StartTime)
{
  char *buf,*Qpars,*Calib;
  int ArraySize=300;

  //allocate memory
  if((buf=(char *)calloc(ArraySize,sizeof(char)))==NULL)   
    { WriteToLog(OutputDriveAndPath,"25  Memory Allocation Error in GetOphirConstants.\n");
      return; 
    }
  if((Qpars=(char *)calloc(ArraySize,sizeof(char)))==NULL) 
    { WriteToLog(OutputDriveAndPath,"25  Memory Allocation Error in GetOphirConstants.\n");
       return;
    }
  if((Calib=(char *)calloc(ArraySize,sizeof(char)))==NULL) 
    { WriteToLog(OutputDriveAndPath,"25  Memory Allocation Error in GetOphirConstants.\n");
       return;
    }

  WriteChar(OphPort,'9');
  ClearRXBuffer(OphPort);
  WriteToLog(OutputDriveAndPath,"26  Acquiring Ophir humidity and engineering constants.");
  if(GetOphirString(OphPort,Qpars,ArraySize,'5',7,3)&&GetOphirString(OphPort,Calib,ArraySize,'0',18,3))
      sprintf(OphirString,"%s%s",Calib,Qpars);	
  else
    { sprintf(buf,"27  Error acquiring Ophir constants from COM%d.",PortNumber);
      WriteToLog(OutputDriveAndPath,buf);
    }

  // free memory
  if(buf!=NULL)   free(buf);
  if(Qpars!=NULL) free(Qpars);
  if(Calib!=NULL) free(Calib);

  WriteChar(OphPort,'a');
  GetSystemTime(StartTime);
}