//---------------------------------------------------------------------------
//
// iseg High Voltage Controlprogram for all Moduls with CAN
//
// written by Jens Römer
//
//---------------------------------------------------------------------------

#include "W47xK16R16.h"
#include "isegcanv.h"
#include "isegCANHV.h"
#include <stdio.h>
#include <string.h>
#include <math.h>

#include <SysUtils.hpp>

//----------------------------------------------------------------------------
// THVChannel
//------------

THVChannel::THVChannel(void)
{
   myIDC = NULL;
   myIDC = new uw16;

   myChannel = NULL;
   myChannel = new uw8;
   *myChannel=1;

   myError = NULL;
   myError = new int;

   myErrCnt = NULL;
   myErrCnt = new uw8;
   *myErrCnt = 0;

   myVset = NULL;
   myVset = new TChVal;

   myVmeas = NULL;
   myVmeas = new TChVal;

   myImeas = NULL;
   myImeas = new TChVal;

   myITrip = NULL;
   myITrip = new TChVal;

   myStat = NULL;
   myStat = new TChVal;

   for (uw8 ch=0; ch<16; ch++)
       ChnName[ch][0]=' ';
}

THVChannel::~THVChannel(void)
{
   if (myIDC) { delete myIDC; myIDC=NULL; }
   if (myChannel) { delete myChannel; myChannel=NULL; }
   if (myError) { delete myError; myError=NULL; }
   if (myErrCnt) { delete myErrCnt;  myErrCnt=NULL; }
   if (myVset) { delete myVset; myVset=NULL; }
   if (myVmeas) { delete myVmeas; myVmeas=NULL; }
   if (myImeas) { delete myImeas; myImeas=NULL; }
   if (myITrip) { delete myITrip; myITrip=NULL; }
   if (myStat) { delete myStat; myStat=NULL; }
}

uw8 THVChannel::GetChn(void)
{
   return *myChannel;
}

void THVChannel::SetChn(uw8 Channel)
{
   *myChannel=Channel;
}

void THVChannel::SetIDC(uw16 ID)
{
   *myIDC=ID;
}

uw16 THVChannel::GetIDC(void)
{
   if (myIDC!=0)
      //return (*myID|(CAN_HW_Dialog->CANx<<12))&0xfffe;  // without R/W-bit
	  return (*myIDC)&0xfffe;  // without R/W-bit
   else
      return 0;
}

void THVChannel::EvalMessageError(void)
{
   bool cfg=false;
   bool lim=false;
   bool spl=false;

   if (*myErrCnt>3) {
      /*switch (Application->MessageBox("Communication error!", "", TMessageButtons() << smbAbort, smbRetry, smbIgnore)){
        case IDABORT : *myError=IDABORT;
        break;
        case IDRETRY : *myError=IDRETRY;
                       *myErrCnt=0;
        break;
        case IDIGNORE: *myError=IDIGNORE;
                       *myErrCnt=0;
        break;
     }  */
   }
   else {
     //*myError=IDRETRY;
     *myErrCnt++;
     Sleep(10);
     SwitchToThread();
   }
}

void THVChannel::SetVset(struct TChVal DACV)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_SetVoltage|GetChn();
   CanBuff[2]=DACV.V>>8;
   CanBuff[3]=DACV.V;
   Write2Can(GetIDC(), CanBuff, DACV.TSt);
   *myVset=DACV;
   delete tstamp;
   delete CanBuff;
}

struct TChVal THVChannel::GetVset(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
     isegCANHVDlg->HVModule16Std->ScanCanBuff(ID,CanBuff);  //make a blank CAN buffer
     CanBuff[0]=1;
     CanBuff[1]=DataID_SetVoltage|GetChn();
     strcpy(tstamp, SendTime);
     if ( (WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) && ( (CanBuff[1]&0xf0)==DataID_SetVoltage ) ) {
        myVset->V=(CanBuff[2]<<8)+CanBuff[3];
        myVset->Q=QUALITY_GOOD;
        strcpy(myVset->TSt, tstamp);
        *myError=IDOK;
        *myErrCnt=0;
     }
     else {
        EvalMessageError();
        myVset->Q=QUALITY_BAD;
     }
   } while (*myError==IDRETRY);
   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myVset;
}

struct TChVal THVChannel::GetVmeas(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];
   uw16 tout;

   do
   {
     isegCANHVDlg->HVModule16Std->ScanCanBuff(ID,CanBuff);  //make a blank CAN buffer
     CanBuff[0]=1;
     CanBuff[1]=DataID_ActualVoltage|GetChn();
     strcpy(tstamp, SendTime);
     if ( (WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) && ((CanBuff[1]&0xf0)==DataID_ActualVoltage) ) {
        myVmeas->V=(CanBuff[2]<<8)+CanBuff[3];
        myVmeas->Q=QUALITY_GOOD;
        strcpy(myVmeas->TSt, tstamp);
        *myError=IDOK;
        *myErrCnt=0;
     }
     else {
        EvalMessageError();
        myVmeas->Q=QUALITY_BAD;
     }
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myVmeas;
}

struct TChVal THVChannel::GetImeas(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      isegCANHVDlg->HVModule16Std->ScanCanBuff(ID,CanBuff);  //make a blank CAN buffer
      CanBuff[0]=1;
      CanBuff[1]=DataID_ActualCurrent|GetChn();
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) && ( (CanBuff[1]&0xf0)==DataID_ActualCurrent ) ) {
         myImeas->V=(CanBuff[2]<<8)+CanBuff[3];
         myImeas->Q=QUALITY_GOOD;
         strcpy(myImeas->TSt, tstamp);
         *myError=IDOK;
         *myErrCnt=0;
      }
      else {
        EvalMessageError();
        myImeas->Q=QUALITY_BAD;
     }
   } while (*myError==IDRETRY);
   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myImeas;
}

struct TChVal THVChannel::GetStat(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      isegCANHVDlg->HVModule16Std->ScanCanBuff(ID,CanBuff);  //make a blank CAN buffer
      CanBuff[0]=1;
      CanBuff[1]=DataID_Status|GetChn();
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) && ( (CanBuff[1]&0xf0)==DataID_Status ) ) {
         myStat->V=(CanBuff[2]<<8)+CanBuff[3];
         myStat->Q=QUALITY_GOOD;
         strcpy(myStat->TSt, tstamp);
         *myError=IDOK;
         *myErrCnt=0;
      }
      else {
        EvalMessageError();
        myStat->Q=QUALITY_BAD;
     }
   } while (*myError==IDRETRY);
   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myStat;
}

void THVChannel::SetITrip(struct TChVal TRIP)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataExtID_CurrentTrip|GetChn();
   CanBuff[2]=TRIP.V>>8;
   CanBuff[3]=TRIP.V;
   Write2Can(GetIDC()|EXT_INSTR, CanBuff, TRIP.TSt);
   *myITrip=TRIP;

   delete tstamp;
   delete CanBuff;
}


struct TChVal THVChannel::GetITrip(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
     isegCANHVDlg->HVModule16Std->ScanCanBuff(ID,CanBuff);  //make a blank CAN buffer
     CanBuff[0]=1;
     CanBuff[1]=DataExtID_CurrentTrip|GetChn();
     strcpy(tstamp, SendTime);
     if ( (WriteReadfCan(GetIDC()|EXT_INSTR|DATA_DIR, CanBuff, tstamp)) && ( (CanBuff[1]&0xf0)==DataExtID_CurrentTrip ) ) {
         myITrip->V=(CanBuff[2]<<8)+CanBuff[3];
         myITrip->Q=QUALITY_GOOD;
         strcpy(myITrip->TSt, tstamp);
         *myError=IDOK;
         *myErrCnt=0;
      }
      else {
        EvalMessageError();
        myITrip->Q=QUALITY_BAD;
      }
   } while (*myError==IDRETRY);
   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myITrip;
}

//---------------------------------------------------------------------------
// THVModul
//------------

THVModule16Std::THVModule16Std(void)
{
   myIDM=NULL;
   myIDM = new uw16;                   // CAN-ID
   *myIDM=0;

   myType=NULL;
   myType = new uw8;                 // ModulTyp

   myDevIDR=NULL;
   myDevIDR = new TDevIDR;              // Device ID with software release

   myRamp=NULL;
   myRamp = new uw16;                 // Rampspeed

   myOnOff=NULL;
   myOnOff = new uw16;                // word with on off flag per channel

   myLogOn=NULL;
   myLogOn = new bool;
   *myLogOn = false;

   myKilEna=NULL;
   myKilEna = new uw16;

   myEMCY=NULL;
   myEMCY = new uw16;

   myVImax = NULL;
   myVImax = new TNominals;

   myHwVLim2Low=NULL;
   myHwVLim2Low = new bool;

   mySLoop=NULL;
   mySLoop = new bool;

   myAdjust=NULL;
   myAdjust = new bool;

   myEEPWrite=NULL;
   myEEPWrite= new bool;

   myGenStat=NULL;
   myGenStat = new uw8;

   myFilter=NULL;
   myFilter = new uw16;

   mySupplies=NULL;
   mySupplies = new TSplTmp;

   myStHwVLimits=NULL;
   myStHwVLimits = new uw16;

   myStHwILimits=NULL;
   myStHwILimits = new uw16;

   myStSwILimits=NULL;
   myStSwILimits = new uw16;

   myStFaErr=NULL;
   myStFaErr = new uw16;

   myBitr=NULL;
   myBitr      = new uw16;

   myHWCLimit=NULL;
   myHWCLimit = new uw16;

   myHWVLimit=NULL;
   myHWVLimit = new uw16;

   myThErrStat=NULL;
   myThErrStat = new uw16;

   myRelayMask=NULL;
   myRelayMask = new uw8;

   myCalPWM=NULL;
   myCalPWM = new bool;

   myScanCanBus=NULL;
   myScanCanBus = new bool;
   *myScanCanBus=false;
}

THVModule16Std::~THVModule16Std(void)
{
   if (myIDM) { delete myIDM; myIDM=NULL; }
   if (myType) { delete myType; myType=NULL; }
   if (myDevIDR) { delete myDevIDR; myDevIDR=NULL; }
   if (myRamp) { delete myRamp; myRamp=NULL; }
   if (myOnOff) { delete myOnOff; myOnOff=NULL; }
   if (myLogOn) { delete myLogOn; myLogOn=NULL; }
   if (myKilEna) { delete myKilEna; myKilEna=NULL; }
   if (myEMCY) { delete myEMCY; myEMCY=NULL; }
   if (myVImax) { delete myVImax; myVImax=NULL; }
   if (mySLoop) { delete mySLoop; mySLoop=NULL; }
   if (myHwVLim2Low) { delete myHwVLim2Low; myHwVLim2Low=NULL; }
   if (myAdjust) { delete myAdjust; myAdjust=NULL; }
   if (myEEPWrite) { delete myEEPWrite; myEEPWrite=NULL; }
   if (myGenStat) { delete myGenStat; myGenStat=NULL; }
   if (myFilter) { delete myFilter; myFilter=NULL; }
   if (mySupplies) { delete mySupplies; mySupplies=NULL; }
   if (myStHwVLimits) { delete myStHwVLimits; myStHwVLimits=NULL; }
   if (myStHwILimits) { delete myStHwILimits; myStHwILimits=NULL; }
   if (myStSwILimits) { delete myStSwILimits; myStSwILimits=NULL; }
   if (myStFaErr) { delete myStFaErr; myStFaErr=NULL; }
   if (myBitr) { delete myBitr; myBitr=NULL; }
   if (myHWCLimit) { delete myHWCLimit; myHWCLimit=NULL; }
   if (myHWVLimit) { delete myHWVLimit; myHWVLimit=NULL; }

   if (myScanCanBus) delete myScanCanBus; myScanCanBus=NULL;

   if (myThErrStat) delete myThErrStat; myThErrStat=NULL;
   if (myRelayMask) delete myRelayMask; myRelayMask=NULL;

   if (myCalPWM) delete myCalPWM; myCalPWM=NULL;
}

//----------------------------------------------------------------------------
// Subroutine scant the CAN-Buffer for
//                                    - Module logs on
//                                    - regulation error Messages
//-----------------------------------------------------------
void THVModule16Std::ScanCanBuff(uw16 *ID, uw8 *CanBuff)
{
   char* tstamp = new char[20];
   char str[128];
   char s[10];

   //*ID=CAN_HW_Dialog->CANx<<12;
   while (
            (ReadfBuff(ID, CanBuff, tstamp))
           ||
            (ReadfCan(ID, CanBuff, tstamp))                 //make a blank CAN buffer
         )
   {

      if (
            ((*ID&0x200)==0)          // active message
	   &&
	    (*(CanBuff+1)==0xc0)      // status message
         )
      {

         if  ( ( *(CanBuff+2)&1) == 0 )
         {
             strcpy(str, "Sumbit ErrI, ErrV, ErrT or ErrF is occured at CAN device ");
             strcat(str, itoa(((*ID>>3)&0x3f), s,10));
         }

         if  (( *(CanBuff+2)&4) == 0 )
         {
             strcpy(str, "Savetyloop is not closed at CAN device ");
             strcat(str, itoa(((*ID>>3)&0x3f), s,10));
         }

         if  (( *(CanBuff+2)&0x40) == 0 )
         {
             strcpy(str, "Hardware voltage limit to low at CAN device ");
             strcat(str, itoa(((*ID>>3)&0x3f), s,10));
         }


         if  ( ( *(CanBuff+3)&0x40) ) {
             strcpy(str, "Temperature greater than 55°C at CAN device ");
             strcat(str, itoa(((*ID>>3)&0x3f), s,10));
         }
         else
           if  ( ( *(CanBuff+2)&0x20) == 0 ) {
               strcpy(str, "Voltage supplies are out of bounds at CAN device ");
               strcat(str, itoa(((*ID>>3)&0x3f), s,10));
           }

      }
      *ID=0;
   }
   delete tstamp;
}

void THVModule16Std::SetID(uw16 ID)
{
   if (myIDM==NULL) myIDM = new uw16;
   *myIDM=ID;
   SetIDC(ID);
}

uw16 THVModule16Std::GetID(void)
{
   if (myIDM!=0)
   {
      return (*myIDM)&0xfffe;
                           // without R/W-bit
   }
   else
      return 0;
}

uw8 THVModule16Std::GetType(void)
{
   return *myType;
}

void THVModule16Std::SetType(uw8 type)
{
   *myType=type;
}

bool THVModule16Std::GetLogOn(void)
{
   uw8* Stat = new uw8;
   char*  tstamp = new char[20];

   strcpy(tstamp, SendTime);
   *myLogOn=CanLogOnOff(myIDM, Stat, myType, tstamp);
   if (*myLogOn) SetID(*myIDM);

   *myGenStat=*Stat;

   delete tstamp;
   delete Stat;

   if (*myLogOn) return *myLogOn;       //Module was conneted to Client
   else          return false;
}

void THVModule16Std::SetLogOn(bool LogStat)
{
   char* tstamp = new char[20];
   strcpy(tstamp, SendTime);
   *myLogOn=LogStat;
   LogOnOff(GetID(), LogStat, tstamp);
   delete tstamp;
}

void THVModule16Std::SetRamp(uw16 GRAD)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_RampSpeed;
   CanBuff[2]=GRAD>>8;
   CanBuff[3]=GRAD;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myRamp=GRAD;

   delete tstamp;
   delete CanBuff;
}

uw16 THVModule16Std::GetRamp(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
     ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

     CanBuff[0]=1;
     CanBuff[1]=DataID_RampSpeed;
     strcpy(tstamp, SendTime);
     if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_RampSpeed)) {
        *myRamp=(CanBuff[2]<<8)+CanBuff[3];
        *myError=IDOK;
        *myErrCnt=0;
     }
     else
        EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myRamp;
}

void THVModule16Std::SetOnOff(uw16 OnOff)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_OnOff;
   CanBuff[2]=OnOff>>8;
   CanBuff[3]=OnOff;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myOnOff=OnOff;

   delete tstamp;
   delete CanBuff;
}

uw16 THVModule16Std::GetOnOff(void)
{
   uw16*ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
     ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

     CanBuff[0]=1;
     CanBuff[1]=DataID_OnOff;
     strcpy(tstamp, SendTime);
     if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp) ) && (CanBuff[1]==DataID_OnOff) ) {
        *myOnOff=(CanBuff[2]<<8)+CanBuff[3];
        *myError=IDOK;
        *myErrCnt=0;
     }
     else
        EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myOnOff;
}

void THVModule16Std::SetKilEna(uw16 KilEna)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_KilEna;
   CanBuff[2]=KilEna>>8;
   CanBuff[3]=KilEna;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myKilEna=KilEna;

   delete tstamp;
   delete CanBuff;
}

uw16 THVModule16Std::GetKilEna(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_KilEna;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_KilEna) ) {
         *myKilEna=(CanBuff[2]<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
        EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;

   return *myKilEna;
}

void THVModule16Std::SetEMCY(uw16 EMCY)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_EmcyCutOut;
   CanBuff[2]=EMCY>>8;
   CanBuff[3]=EMCY;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myEMCY=EMCY;

   delete tstamp;
   delete CanBuff;
}

void THVModule16Std::SetHwVLimit2Low(bool HwVLim2Low)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x02;
   CanBuff[1]=DataID_GeneralStat;
   CanBuff[2]=*myGenStat;
   if (HwVLim2Low) CanBuff[2]|=hwVLimNoEx;
   else            CanBuff[2]&=~hwVLimNoEx;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myHwVLim2Low=HwVLim2Low;

   delete tstamp;
   delete CanBuff;
}

void THVModule16Std::SetSLoop(bool SLoop)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x02;
   CanBuff[1]=DataID_GeneralStat;
   CanBuff[2]=*myGenStat;
   if (SLoop) CanBuff[2]|=sloop;
   else       CanBuff[2]&=~sloop;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *mySLoop=SLoop;

   delete tstamp;
   delete CanBuff;
}

void THVModule16Std::SetAdjust(bool Adjust)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x02;
   CanBuff[1]=DataID_GeneralStat;
   CanBuff[2]=*myGenStat;
   if (Adjust) CanBuff[2]|=b_avad;
   else        CanBuff[2]&=~b_avad;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myAdjust=Adjust;

   delete tstamp;
   delete CanBuff;
}

bool THVModule16Std::GetAdjust(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff  = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_GeneralStat;
      *ID=GetID();
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(*ID+1, CanBuff, tstamp)) && ( (CanBuff[1]==DataID_GeneralStat) && (*ID==GetID()) ) ) {
         if (CanBuff[2]&b_avad) *myAdjust=true;
         else                  *myAdjust=false;
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
        EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myAdjust;
}

void THVModule16Std::SetEEP_WR(bool EEPWrite)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x02;
   CanBuff[1]=DataID_GeneralStat;
   CanBuff[2]=*myGenStat;
   if (EEPWrite) CanBuff[2]|=b_ew;
   else          CanBuff[2]&=~b_ew;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myEEPWrite=EEPWrite;

   delete tstamp;
   delete CanBuff;
}

bool THVModule16Std::GetEEP_WR(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff  = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_GeneralStat;
      *ID=GetID();
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(*ID+1, CanBuff, tstamp)) && ( (CanBuff[1]==DataID_GeneralStat) && (*ID==GetID()) ) ) {
         if (CanBuff[2]&b_ew) *myEEPWrite=true;
         else                *myEEPWrite=false;
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
        EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myEEPWrite;
}

uw8 THVModule16Std::GetGenStat(void)
{
   if (myGenStat!=NULL)
      return *myGenStat;
   else
      return 0;
}

void THVModule16Std::SetGenStat(uw8 Stat)
{
     *myGenStat=Stat;
}

uw8 THVModule16Std::GetGenStatfCAN(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
     ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

     CanBuff[0]=1;
     CanBuff[1]=DataID_GeneralStat;
     *ID=GetID();
     strcpy(tstamp, SendTime);
     if ( (WriteReadfCan(*ID+1, CanBuff, tstamp)) && ( (CanBuff[1]==DataID_GeneralStat) && (*ID==GetID()) ) )  {
         *myGenStat=*(CanBuff+2);
         *myError=IDOK;
         *myErrCnt=0;
     }
     else
        EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myGenStat;
}

void THVModule16Std::SetVsetAll(uw16 Vseta)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_VsetGroup;
   CanBuff[2]=Vseta>>8;
   CanBuff[3]=Vseta;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);

   delete tstamp;
   delete CanBuff;
}

void THVModule16Std::SetItripAll(uw16 Itripa)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataExtID_IsetGroup;
   CanBuff[2]=Itripa>>8;
   CanBuff[3]=Itripa;
   strcpy(tstamp, SendTime);
   Write2Can(GetID()|EXT_INSTR, CanBuff, tstamp);

   delete tstamp;
   delete CanBuff;
}

struct TNominals THVModule16Std::GetVInom(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];
   uw16 tout;

   do
   {
      ScanCanBuff(ID,CanBuff);         //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_NominalValues;
      strcpy(tstamp, SendTime);
      myVImax->Q=QUALITY_BAD;
      if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_NominalValues) ) {
         myVImax->V=(uw16)(CanBuff[2]*pow(10, CanBuff[3]));
         myVImax->I=(uw64)(CanBuff[4]*pow(10, 9-(0x100-CanBuff[5])));
         myVImax->Q=QUALITY_GOOD;
         strcpy(myVImax->TSt, tstamp);
         *myError=IDOK;
         *myErrCnt=0;
      }
      else {
         EvalMessageError();
         myVImax->Q=QUALITY_BAD;
      }
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myVImax;
}

void THVModule16Std::SetFilter(uw16 Filter)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_Filter;
   CanBuff[2]=Filter>>8;
   CanBuff[3]=Filter;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myFilter=Filter;

   delete tstamp;
   delete CanBuff;
}

uw16 THVModule16Std::GetFilter(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_Filter;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_Filter) ) {
         *myFilter=((CanBuff[2]&0x7f)<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myFilter;
}

struct TSplTmp THVModule16Std::GetSupply(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataExtID_Supply;
      strcpy(tstamp, SendTime);
      mySupplies->Q=QUALITY_BAD;
      if ( (WriteReadfCan(GetID()|DATA_DIR|EXT_INSTR, CanBuff, tstamp)) && (CanBuff[1]==DataExtID_Supply) ) {
         mySupplies->Vp24=CanBuff[2];  //V24
         mySupplies->Vp15=CanBuff[3];  //V15
         mySupplies->Vp5=CanBuff[4];   //V5
         mySupplies->Vn15=CanBuff[5];  //V-15
         mySupplies->Vn5=CanBuff[6];   //V-5
         mySupplies->Temp=(CanBuff[7]<<8)+CanBuff[8];
         mySupplies->Q=QUALITY_BAD;
         strcpy(mySupplies->TSt, tstamp);
         *myError=IDOK;
         *myErrCnt=0;
      }
      else {
         EvalMessageError();
         mySupplies->Q=QUALITY_BAD;
      }
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *mySupplies;
}

//---------------------------------------------------------------------------------------------------

void THVModule16Std::SetStHwVLimit(uw16 GrStHwVL)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_StHwVLimit;
   CanBuff[2]=GrStHwVL>>8;
   CanBuff[3]=GrStHwVL;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myStHwVLimits=GrStHwVL;

   delete tstamp;
   delete CanBuff;
}

uw16 THVModule16Std::GetStHwVLimit(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_StHwVLimit;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_StHwVLimit) ) {
         *myStHwVLimits=(CanBuff[2]<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myStHwVLimits;
}

//---------------------------------------------------------------------------------------------------

void THVModule16Std::SetStHwILimit(uw16 GrStHwIL)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_StHwILimit;
   CanBuff[2]=GrStHwIL>>8;
   CanBuff[3]=GrStHwIL;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myStHwILimits=GrStHwIL;

   delete tstamp;
   delete CanBuff;
}

uw16 THVModule16Std::GetStHwILimit(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_StHwILimit;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_StHwILimit) ) {
         *myStHwILimits=(CanBuff[2]<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myStHwILimits;
}

//--------------------------------------------------------------------------------------------------

void THVModule16Std::SetStSwILimit(uw16 GrStSwIL)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_StSwILimit;
   CanBuff[2]=GrStSwIL>>8;
   CanBuff[3]=GrStSwIL;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myStSwILimits=GrStSwIL;

   delete tstamp;
   delete CanBuff;
}

uw16 THVModule16Std::GetStSwILimit(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                     //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_StSwILimit;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_StSwILimit) ) {
         *myStSwILimits=(CanBuff[2]<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myStSwILimits;
}

//---------------------------------------------------------------------------------------------------

struct TDevIDR THVModule16Std::GetDevIDR(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];
   uw32 l;

   do
   {
     ScanCanBuff(ID,CanBuff);                     //make a blank CAN buffer

     CanBuff[0]=1;
     CanBuff[1]=DataID_GID;
     strcpy(tstamp, SendTime);
     myDevIDR->Q=QUALITY_BAD;
     if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp))  && (CanBuff[1]==DataID_GID) )  {
        l=(CanBuff[2]*0x10000)+(CanBuff[3]*0x100)+CanBuff[4];
        ltoa(l,myDevIDR->GID,16);

        if (CanBuff[5]&5) myDevIDR->Active=true;
        else              myDevIDR->Active=false;

        myDevIDR->SID[0]=(CanBuff[5]&0x0f)+0x30;
        myDevIDR->SID[1]='.';
        myDevIDR->SID[2]=( (CanBuff[6]>>4)&0x0f)+0x30;
        myDevIDR->SID[3]=(CanBuff[6]&0x0f)+0x30;
        myDevIDR->SID[4]=0x00;

        myDevIDR->ChCount=16;
        
        myDevIDR->Q=QUALITY_GOOD;
        strcpy(myDevIDR->TSt, tstamp);
        *myError=IDOK;
        *myErrCnt=0;
      }
      else {
        EvalMessageError();
        myDevIDR->Q=QUALITY_BAD;
      }
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myDevIDR;
}

void THVModule16Std::SetBitRate(uw16 Rate)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataID_BitRate;
   CanBuff[2]=Rate>>8;
   CanBuff[3]=Rate;
   strcpy(tstamp, SendTime);
   Write2Can(GetID(), CanBuff, tstamp);
   *myBitr=Rate;

   delete tstamp;
   delete CanBuff;
}

uw16 THVModule16Std::GetBitRate(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
     ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

     CanBuff[0]=1;
     CanBuff[1]=DataID_BitRate;
     strcpy(tstamp, SendTime);
     if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_BitRate) ) {
        *myBitr=(CanBuff[2]<<8)+CanBuff[3];
        *myError=IDOK;
        *myErrCnt=0;
     }
     else
        EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myBitr;
}

//================================================================================================================

void THVModule16Std::SetThErrStat(uw16 ThErrStat)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataExtID_ThErrStat;
   CanBuff[2]=ThErrStat>>8;
   CanBuff[3]=ThErrStat;
   strcpy(tstamp, SendTime);
   Write2Can(GetID()|EXT_INSTR, CanBuff, tstamp);
   *myThErrStat=ThErrStat;

   delete tstamp;
   delete CanBuff;
}

uw16  THVModule16Std::GetThErrStat(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataExtID_ThErrStat;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|EXT_INSTR|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataExtID_ThErrStat) ) {
         *myThErrStat=(CanBuff[2]<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myThErrStat;
}

//================================================================================================================

void THVModule16Std::SetRelayMask(uw8 RM)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x02;
   CanBuff[1]=DataExtID_RelayMask;
   CanBuff[2]=RM;
   strcpy(tstamp, SendTime);
   Write2Can(GetID()|EXT_INSTR, CanBuff, tstamp);
   *myRelayMask=RM;

   delete tstamp;
   delete CanBuff;
}

uw8 THVModule16Std::GetRelayMask(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataExtID_RelayMask;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|EXT_INSTR|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataExtID_RelayMask) ) {
         *myRelayMask=CanBuff[2];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myRelayMask;
}

//=============================================================================================================

uw16  THVModule16Std::GetHWCLimit(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataID_HWCLimit;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataID_HWCLimit) ) {
         *myHWCLimit=(CanBuff[2]<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myHWCLimit;
}

uw16  THVModule16Std::GetHWVLimit(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataExtID_HWVLimit;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|EXT_INSTR|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataExtID_HWVLimit) ) {
         *myHWVLimit=(CanBuff[2]<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myHWVLimit;
}

//------------------------------------------------------------------------------------------------------

void THVModule16Std::SetStFastErr(uw16 GrStFErr)
{
   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];

   CanBuff[0]=0x03;
   CanBuff[1]=DataExtID_StFaErr;
   CanBuff[2]=GrStFErr>>8;
   CanBuff[3]=GrStFErr;
   strcpy(tstamp, SendTime);
   Write2Can(GetID()|EXT_INSTR, CanBuff, tstamp);
   *myStSwILimits=GrStFErr;

   delete tstamp;
   delete CanBuff;
}
uw16  THVModule16Std::GetStFastErr(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataExtID_StFaErr;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|EXT_INSTR|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataExtID_StFaErr) ) {
         *myStFaErr=(CanBuff[2]<<8)+CanBuff[3];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myStFaErr;
}

//=============================================================================================================

void THVModule16Std::SetCalPWM(bool calpwm)
{

   uw8* CanBuff = new uw8[4];
   char* tstamp = new char[20];
        
   CanBuff[0]=0x02;
   CanBuff[1]=DataExtID_CalPWM;
   CanBuff[2]=calpwm;
   strcpy(tstamp, SendTime);
   Write2Can(GetID()|EXT_INSTR, CanBuff, tstamp);
   *myRelayMask=calpwm;

   delete tstamp;
   delete CanBuff;
}
bool THVModule16Std::GetCalPWM(void)
{
   uw16* ID = new uw16;
   uw8* CanBuff = new uw8[10];
   char* tstamp = new char[20];

   do
   {
      ScanCanBuff(ID,CanBuff);                      //make a blank CAN buffer

      CanBuff[0]=1;
      CanBuff[1]=DataExtID_CalPWM;
      strcpy(tstamp, SendTime);
      if ( (WriteReadfCan(GetID()|EXT_INSTR|DATA_DIR, CanBuff, tstamp)) && (CanBuff[1]==DataExtID_CalPWM) ) {
         *myCalPWM=CanBuff[2];
         *myError=IDOK;
         *myErrCnt=0;
      }
      else
         EvalMessageError();
   } while (*myError==IDRETRY);

   delete tstamp;
   delete CanBuff;
   delete ID;
   return *myCalPWM;
}

//---------------------------------------------------------------------------


bool THVModule16Std::GetScanCanBus(void)
{
   if (myScanCanBus!=NULL)
      return *myScanCanBus;
   else
      return 0;
}

void THVModule16Std::SetScanCanBus(bool Scan)
{
     *myScanCanBus=Scan;
}
//---------------------------------------------------------------------------