/******************************************************************************
 * W71to8K24R24.cpp: CAN communication to iseg Multi-Channel HV modules:
 *		E16D0
 *		E08C0
 *		E08F0
 *		E08F2
 *		E08C2
 *		E08B0
 *
 * written by Jens Roemer
 */

#include "stdafx.h"
#include "dcan.h"

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

//THVChannel HVChannel
CHVChn24f::CHVChn24f()
{

}

CHVChn24f::CHVChn24f(uw16 id, uw8 chn)
{
	char str[128];

	ID = NULL;
	ID = new uw16;
	*ID = id;

	Channel = NULL;
	Channel = new uw8;
	*Channel=chn;

	Error = NULL;
	Error = new int;

	ErrCnt = NULL;
	ErrCnt = new uw8;
	*ErrCnt = 0;

	Vset = NULL;
	Vset = new TChFloatVal;

	Iset = NULL;
	Iset = new TChFloatVal;

	Vmeas = NULL;
	Vmeas = new TChFloatVal;

	Imeas = NULL;
	Imeas = new TChFloatVal;

	ImeasR = NULL;
	ImeasR = new TChFloatVal;

	Vbound = NULL;
	Vbound = new TChFloatVal;

	Ibound = NULL;
	Ibound = new TChFloatVal;

	Status = NULL;
	Status = new TChStatusVal;

	EventStatus = NULL;
	EventStatus = new TChEventStatusVal;

	EventMask = NULL;
	EventMask = new TChEventMaskVal;

	Control = NULL;
	Control = new TChControlVal;

	NominalP = NULL;
	NominalP = new TChFloatNominals;

	NominalN = NULL;
	NominalN = new TChFloatNominals;
}

CHVChn24f::~CHVChn24f(void)
{
	if (ID) { delete ID; ID=NULL; }
	if (Channel) { delete Channel; Channel=NULL; }
	if (Error) { delete Error; Error=NULL; }
	if (ErrCnt) { delete ErrCnt; ErrCnt=NULL; }
	if (Vset) { delete Vset; Vset=NULL; }
	if (Iset) { delete Iset; Iset=NULL; }
	if (Vmeas) { delete Vmeas; Vmeas=NULL; }
	if (Imeas) { delete Imeas; Imeas=NULL; }
	if (ImeasR) { delete ImeasR; ImeasR=NULL; }
	if (Vbound) { delete Vbound; Vbound=NULL; }
	if (Ibound) { delete Ibound; Ibound=NULL; }
	if (Status) { delete Status; Status=NULL; }
	if (EventStatus) { delete EventStatus; EventStatus=NULL; }
	if (EventMask) { delete EventMask; EventMask=NULL; }
	if (Control) { delete Control; Control=NULL; }
	if (NominalP) { delete NominalP, NominalP=NULL; }
	if (NominalN) { delete NominalN, NominalN=NULL; }
}

uw8 CHVChn24f::GetChn(void)
{
	return *Channel;
}

void CHVChn24f::SetChn(uw8 chn)
{
	*Channel=chn;
}

void CHVChn24f::SetIDC(uw16 id)
{
   *ID=id;
}

uw16 CHVChn24f::GetIDC(void)
{
	if (ID!=0)
		return *ID;  // without R/W-bit
	else
		return 0;
}

void CHVChn24f::SetEdcpVset(TChFloatVal DACV)
{
	uw8  CanBuff[10];

	CanBuff[0]=0x07;
	CanBuff[1]=(uw8)(EDCP_DATAID_CHN_VOLTAGE_SET>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_CHN_VOLTAGE_SET;
	CanBuff[3]=GetChn();
	memrcpy(CanBuff+4, (uw8 *)&DACV.V , 4);
	Write2Can(GetIDC(), CanBuff, DACV.TSt);
	*Vset=DACV;
}

TChFloatVal CHVChn24f::GetEdcpVset(void)
{
	uw8 CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_VOLTAGE_SET>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_VOLTAGE_SET;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&Vset->V, CanBuff+4, 4);
			Vset->Q=QUALITY_GOOD;
			strcpy(Vset->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			Vset->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *Vset;
}

void CHVChn24f::SetEdcpIset(struct TChFloatVal DACI)
{
	uw8 CanBuff[10];

	CanBuff[0]=0x07;
	CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CURRENT_SET>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_CHN_CURRENT_SET;
	CanBuff[3]=GetChn();
	memrcpy(CanBuff+4, (uw8 *)&DACI.V , 4);
	Write2Can(GetIDC(), CanBuff, DACI.TSt);
	*Iset=DACI;
}


struct TChFloatVal CHVChn24f::GetEdcpIset(void)
{
	uw8 CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CURRENT_SET>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_CURRENT_SET;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
				(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
				(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&Iset->V, CanBuff+4, 4);
			Iset->Q=QUALITY_GOOD;
			strcpy(Iset->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			////EvalMessageError();
			Iset->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *Iset;
}

struct TChFloatVal CHVChn24f::GetEdcpVmeas(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_VOLTAGE_MEASURE>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_VOLTAGE_MEASURE;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
				(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
				(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&Vmeas->V, CanBuff+4, 4);
			Vmeas->Q=QUALITY_GOOD;
			strcpy(Vmeas->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			////EvalMessageError();
			Vmeas->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *Vmeas;
}

struct TChFloatVal CHVChn24f::GetEdcpImeas(void)
{
	uw8 CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CURRENT_MEASURE>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_CURRENT_MEASURE;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&Imeas->V, CanBuff+4, 4);
			Imeas->Q=QUALITY_GOOD;
			strcpy(Imeas->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			////EvalMessageError();
			Imeas->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);
	return *Imeas;
}

struct TChFloatVal CHVChn24f::GetEdcpImeasRange(uw8 chn, uw8 &range)
{
	uw8 CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CURRENT_MEASURE_RANGE>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_CURRENT_MEASURE_RANGE;
		CanBuff[3]=chn;
		strcpy(tstamp, SendTime);
		if (
				(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
				(CanBuff[3]==chn)
		) {
			memrcpy((uw8*)&ImeasR->V, CanBuff+4, 4);
			if (CanBuff[8]==1) {
				range=1;
				ImeasR->V*=1000000;
			}
			else
				range=0;

			ImeasR->Q=QUALITY_GOOD;
			strcpy(ImeasR->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			////EvalMessageError();
			ImeasR->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);
	return *ImeasR;
}

void CHVChn24f::SetEdcpVbound(TChFloatVal vbnd)
{
	uw8 CanBuff[10];

	CanBuff[0]=0x07;
	CanBuff[1]=(uw8)(EDCP_DATAID_CHN_VOLTAGE_BOUNDS>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_CHN_VOLTAGE_BOUNDS;
	CanBuff[3]=GetChn();
	memrcpy(CanBuff+4, (uw8 *)&vbnd.V , 4);
	Write2Can(GetIDC(), CanBuff, vbnd.TSt);
	*Vbound=vbnd;
}

TChFloatVal CHVChn24f::GetEdcpVbound(void)
{
	uw8 CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_VOLTAGE_BOUNDS>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_VOLTAGE_BOUNDS;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&Vbound->V, CanBuff+4, 4);
			Vbound->Q=QUALITY_GOOD;
			strcpy(Vbound->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			////EvalMessageError();
			Vbound->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *Vbound;
}

void CHVChn24f::SetEdcpIbound(struct TChFloatVal ibnd)
{
	uw8 CanBuff[10];

	CanBuff[0]=0x07;
	CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CURRENT_BOUNDS>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_CHN_CURRENT_BOUNDS;
	CanBuff[3]=GetChn();
	memrcpy(CanBuff+4, (uw8 *)&ibnd.V , 4);
	Write2Can(GetIDC(), CanBuff, ibnd.TSt);
	*Ibound=ibnd;
}


struct TChFloatVal CHVChn24f::GetEdcpIbound(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CURRENT_BOUNDS>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_CURRENT_BOUNDS;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&Ibound->V, CanBuff+4, 4);
			Ibound->Q=QUALITY_GOOD;
			strcpy(Ibound->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			////EvalMessageError();
			Ibound->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *Ibound;
}

struct TChStatusVal CHVChn24f::GetEdcpStat(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_STATUS>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_STATUS;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&Status->Stat, CanBuff+4, 2);
			Status->Q=QUALITY_GOOD;
			strcpy(Status->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			Status->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *Status;
}

void CHVChn24f::SetEdcpEvntStat (struct TChEventStatusVal evntstat)
{
	uw8 CanBuff[10];

	CanBuff[0]=0x05;
	CanBuff[1]=(uw8)(EDCP_DATAID_CHN_EVENT_STATUS>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_CHN_EVENT_STATUS;
	CanBuff[3]=GetChn();
	memrcpy(CanBuff+4, (uw8 *)&evntstat.Stat.Word , 2);
	Write2Can(GetIDC(), CanBuff, evntstat.TSt);
	*EventStatus=evntstat;
}


struct TChEventStatusVal CHVChn24f::GetEdcpEvntStat(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_EVENT_STATUS>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_EVENT_STATUS;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&EventStatus->Stat, CanBuff+4, 2);
			EventStatus->Q=QUALITY_GOOD;
			strcpy(EventStatus->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			EventStatus->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *EventStatus;
}

void CHVChn24f::SetEdcpEvntMask (struct TChEventMaskVal evntmask)
{
	uw8 CanBuff[10];

	CanBuff[0]=0x05;
	CanBuff[1]=(uw8)(EDCP_DATAID_CHN_EVENT_MASK>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_CHN_EVENT_MASK;
	CanBuff[3]=GetChn();
	memrcpy(CanBuff+4, (uw8 *)&evntmask.Stat.Word , 2);
	Write2Can(GetIDC(), CanBuff, evntmask.TSt);
	*EventMask=evntmask;
}

struct TChEventMaskVal CHVChn24f::GetEdcpEvntMask(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_EVENT_MASK>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_EVENT_MASK;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&EventMask->Stat, CanBuff+4, 2);
			EventMask->Q=QUALITY_GOOD;
			strcpy(EventMask->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			EventMask->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *EventMask;
}

void CHVChn24f::SetEdcpCtrl (struct TChControlVal CTRL)
{
	uw8 CanBuff[10];

	CanBuff[0]=0x05;
	CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CONTROL>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_CHN_CONTROL;
	CanBuff[3]=GetChn();
	memrcpy(CanBuff+4, (uw8 *)&CTRL.Ctrl.Word , 2);
	Write2Can(GetIDC(), CanBuff, CTRL.TSt);
	*Control=CTRL;
}

struct TChControlVal CHVChn24f::GetEdcpCtrl(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CONTROL>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_CONTROL;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&Control->Ctrl, CanBuff+4, 2);
			Control->Q=QUALITY_GOOD;
			strcpy(Control->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			Control->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *Control;
}

struct TChFloatNominals CHVChn24f::GetEdcpVNominalP(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_VOLTAGE_NOMINAL>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_VOLTAGE_NOMINAL;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&NominalP->V, CanBuff+4, 4);
			NominalP->Q=QUALITY_GOOD;
			strcpy(NominalP->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			NominalP->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *NominalP;
}

struct TChFloatNominals CHVChn24f::GetEdcpINominalP(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CURRENT_NOMINAL>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_CURRENT_NOMINAL;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&NominalP->I, CanBuff+4, 4);
			NominalP->Q=QUALITY_GOOD;
			strcpy(NominalP->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			NominalP->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *NominalP;
}

struct TChFloatNominals CHVChn24f::GetEdcpVNominalN(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_VOLTAGE_NOMINAL_NPOL>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_VOLTAGE_NOMINAL_NPOL;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&NominalN->V, CanBuff+4, 4);
			NominalN->Q=QUALITY_GOOD;
			strcpy(NominalN->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			NominalN->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *NominalN;
}

struct TChFloatNominals CHVChn24f::GetEdcpINominalN(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

	do
	{
		ScanCanBuff();  //make a blank CAN buffer
		
		CanBuff[0]=3;
		CanBuff[1]=(uw8)(EDCP_DATAID_CHN_CURRENT_NOMINAL_NPOL>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_CHN_CURRENT_NOMINAL_NPOL;
		CanBuff[3]=GetChn();
		strcpy(tstamp, SendTime);
		if (
			(WriteReadfCan(GetIDC()|DATA_DIR, CanBuff, tstamp)) &&
			(CanBuff[3]==GetChn())
		) {
			memrcpy((uw8*)&NominalN->I, CanBuff+4, 4);
			NominalN->Q=QUALITY_GOOD;
			strcpy(NominalN->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			NominalN->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *NominalN;
}


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

CHVMod24f::CHVMod24f(uw16 id, uw8 maxchn, uw8 dc)
{
	for (uw8 chn=0; chn<maxchn; chn++)
		Chn[chn] = new CHVChn24f(id, chn);

	IDM=NULL;
	IDM = new uw16;                     // CAN-ID
	*IDM=id;

	DevClass=NULL;
	DevClass = new uw8;              // ModulTyp
	*DevClass = dc;

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

	RampV=NULL;
	RampV = new TFloatVal;               // Rampspeed

	RampI=NULL;
	RampI = new TFloatVal;               // Rampspeed

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

	BitLogOn=NULL;
	BitLogOn = new bool;
	*BitLogOn = false;

	/*BitKilEna=NULL;
	BitKilEna = new bool;*/

	EMCY=NULL;
	EMCY = new uw16;

	Status = NULL;
	Status = new TEdcpMdStatus;

	Control = NULL;
	Control = new TEdcpMdControl;

	EventStatus = NULL;
	EventStatus = new TEdcpMdEventStatus;
	EventMask = NULL;
	EventMask = new TEdcpMdEventStatus;

	EventChannelStatus = NULL;
	EventChannelStatus = new uw16;
	EventChannelMask = NULL;
	EventChannelMask = new uw16;

	EventGroupStatus = NULL;
	EventGroupStatus = new uw32;
	EventGroupMask = NULL;
	EventGroupMask = new uw32;

	AdcFilterSps = NULL;
	AdcFilterSps = new uw16;

	FilterSteps = NULL;
	FilterSteps = new Tuw16Val;

	StHwVLimits = NULL;
	StHwVLimits = new uw16;

	StHwILimits = NULL;
	StHwILimits = new uw16;

	StSwILimits = NULL;
	StSwILimits = new uw16;

	StFaErr = NULL;
	StFaErr = new uw16;

	StHwExtInhibit = NULL;
	StHwExtInhibit = new uw16;

	Bitr = NULL;
	Bitr = new uw16;

	HWCLimit = NULL;
	HWCLimit = new TFloatVal;

	HWVLimit = NULL;
	HWVLimit = new TFloatVal;

	ThErrStat = NULL;
	ThErrStat = new float;

	RelMask=NULL;
	RelMask = new uw8;

	CalPwm = NULL;
	CalPwm = new bool;

	ScanCanBus = NULL;
	ScanCanBus = new bool;
	*ScanCanBus=false;

	VImax = NULL;
	VImax = new TNominals;

	GenStat = NULL;
	GenStat = new uw8;

	ReInitADC =NULL;
	ReInitADC = new uw16;

	curr_low_rng=NULL;
	curr_low_rng = new bool;
	*curr_low_rng=0;

	Error = NULL;
	Error = new int;

	ErrCnt = NULL;
	ErrCnt = new uw8;
	*ErrCnt = 0;

	Accuracy=1.0;
}

CHVMod24f::~CHVMod24f(void)
{
	if (IDM) { delete IDM; IDM=NULL; }
	if (DevClass) { delete DevClass; DevClass=NULL; }
	if (DevIDR) { delete DevIDR; DevIDR=NULL; }
	if (RampV) { delete RampV; RampV=NULL; }
	if (RampI) { delete RampI; RampI=NULL; }
	if (OnOff) { delete OnOff; OnOff=NULL; }
	if (BitLogOn) { delete BitLogOn; BitLogOn=NULL; }
	if (EMCY) { delete EMCY; EMCY=NULL; }
	if (Status) { delete Status; Status=NULL; }
	if (Control) { delete Control; Control=NULL; }
	if (EventStatus) { delete EventStatus; EventStatus=NULL; }
	if (EventMask) { delete EventMask; EventMask=NULL; }
	if (EventChannelStatus) { delete EventChannelStatus; EventChannelStatus=NULL; }
	if (EventChannelMask) { delete EventChannelMask; EventChannelMask=NULL; }
	if (AdcFilterSps) { delete AdcFilterSps; AdcFilterSps=NULL; }
	if (FilterSteps) { delete FilterSteps; FilterSteps=NULL; }
	if (StHwVLimits) { delete StHwVLimits; StHwVLimits=NULL; }
	if (StHwILimits) { delete StHwILimits; StHwILimits=NULL; }
	if (StSwILimits) { delete StSwILimits; StSwILimits=NULL; }
	if (StHwExtInhibit) { delete StHwExtInhibit; StHwExtInhibit=NULL; }
	if (StFaErr) { delete StFaErr; StFaErr=NULL; }
	if (Bitr) { delete Bitr; Bitr=NULL; }
	if (HWCLimit) { delete HWCLimit; HWCLimit=NULL; }
	if (HWVLimit) { delete HWVLimit; HWVLimit=NULL; }
	if (VImax) { delete VImax; VImax=NULL; }

	if (ScanCanBus) { delete ScanCanBus; ScanCanBus=NULL; }

	if (ThErrStat) { delete ThErrStat; ThErrStat=NULL; }
	if (RelMask) delete RelMask; RelMask=NULL;
	if (CalPwm) { delete CalPwm; CalPwm=NULL; }
	if (GenStat) { delete GenStat; GenStat=NULL; }
	
	if (ReInitADC) { delete ReInitADC; ReInitADC=NULL; }
	if (curr_low_rng) { delete curr_low_rng; curr_low_rng=NULL; }

	if (Error) { delete Error; Error=NULL; }
	if (ErrCnt) { delete ErrCnt; ErrCnt=NULL; }

}


void CHVMod24f::SetID(uw16 id)
{
	if (IDM==NULL) IDM = new uw16;
	*IDM=id;
	SetIDC(id);
}

uw16 CHVMod24f::GetID(void)
{
	if (IDM!=0)
	{
		//*ModLogOn=false;      // LogOnTimer wird HVModul->LogOn mit false nicht auswerten
		return (*IDM)&0xfffe;
					   // without R/W-bit
	}
	else
		return 0;
}

uw8 CHVMod24f::GetDevCl(void)
{
	return *DevClass;
}

void CHVMod24f::SetDevCl(uw8 dc)
{
	*DevClass=dc;
}

bool CHVMod24f::getDcpLogOn(void)
{
	uw8  status;
	char tstamp[20];

	strcpy(tstamp, SendTime);
	*BitLogOn=CanLogOnOff(IDM, &status, DevClass, tstamp);

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

void CHVMod24f::setDcpLogOn(bool LogStat)
{
	char tstamp[20];
	strcpy(tstamp, SendTime);
	*BitLogOn=LogStat;
	LogOnOff(GetID(), LogStat, tstamp);
}

void CHVMod24f::setEdcpRampV(TFloatVal GRAD)
{
	uw8 CanBuff[10];

	CanBuff[0]=0x06;
	CanBuff[1]=(uw8)(EDCP_DATAID_MOD_VOLTAGE_RAMP_SPEED>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_MOD_VOLTAGE_RAMP_SPEED;
	memrcpy(CanBuff+3, (uw8 *)&GRAD.V , 4);
	Write2Can(GetID(), CanBuff, GRAD.TSt);
	*RampV=GRAD;
}

TFloatVal CHVMod24f::getEdcpRampV(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=2;
		CanBuff[1]=(uw8)(EDCP_DATAID_MOD_VOLTAGE_RAMP_SPEED>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_MOD_VOLTAGE_RAMP_SPEED;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)&RampV->V, CanBuff+3, 4);
			RampV->Q=QUALITY_GOOD;
			strcpy(RampV->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			RampV->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *RampV;
}

void CHVMod24f::setEdcpRampI(TFloatVal GRAD)
{
	uw8 CanBuff[10];

	CanBuff[0]=0x06;
	CanBuff[1]=(uw8)(EDCP_DATAID_MOD_CURRENT_RAMP_SPEED>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_MOD_CURRENT_RAMP_SPEED;
	memrcpy(CanBuff+3, (uw8 *)&GRAD.V , 4);
	Write2Can(GetID(), CanBuff, GRAD.TSt);
	*RampI=GRAD;
}

TFloatVal CHVMod24f::getEdcpRampI(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=2;
		CanBuff[1]=(uw8)(EDCP_DATAID_MOD_CURRENT_RAMP_SPEED>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_MOD_CURRENT_RAMP_SPEED;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)&RampI->V, CanBuff+3, 4);
			RampI->Q=QUALITY_GOOD;
			strcpy(RampI->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			RampI->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *RampI;
}

void CHVMod24f::setDcpOnOff(uw32 onoff)
{
	uw8  CanBuff[10];
	char tstamp[20];

	CanBuff[1]=DCP_DATAID_MOD_ON_OFF;
	CanBuff[0]=0x03;
	memrcpy(CanBuff+2, (uw8*)&onoff, 2);
	strcpy(tstamp, SendTime);
	Write2Can(GetID(), CanBuff, tstamp);
	*OnOff=onoff;
}

uw32 CHVMod24f::getDcpOnOff(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=1;
		CanBuff[1]=DCP_DATAID_MOD_ON_OFF;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)OnOff, CanBuff+2, 2);
			//OnOff->Q=QUALITY_GOOD;
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *OnOff;
}

void CHVMod24f::setDcpEmcy(uw16 emcy)
{
	uw8  CanBuff[10];
	char tstamp[20];

	CanBuff[0]=0x03;
	CanBuff[1]=DCP_DATAID_MOD_EMERGENCY_OFF;
	memrcpy(CanBuff+2, (uw8*)&emcy, 2);
	strcpy(tstamp, SendTime);
	Write2Can(GetID(), CanBuff, tstamp);
	*EMCY=emcy;
}

void CHVMod24f::resetEdcpModEvntStat(bool SLoop)
{
	uw8  CanBuff[10];
	char tstamp[20];

	EventStatus->Word=0;
	CanBuff[0]=0x03;
	CanBuff[1]=(uw8)(EDCP_DATAID_MOD_EVENT_STATUS>>8);
	CanBuff[2]=EDCP_DATAID_MOD_EVENT_STATUS;

	EventStatus->Bit.ESFLPngd=true;
	EventStatus->Bit.ETMPngd=true;
	EventStatus->Bit.ESPLYngd=true;
	EventStatus->Bit.EMODngd=true;

	memrcpy(CanBuff+3, (uw8*)&EventStatus->Word, 2);
	strcpy(tstamp, SendTime);
	Write2Can(GetID(), CanBuff, tstamp);
}

void CHVMod24f::setEdcpModCtrlKILena(bool kill)
{
	uw8  CanBuff[10];
	char tstamp[20];

	CanBuff[0]=0x04;
	CanBuff[1]=(uw8)(EDCP_DATAID_MOD_CONTROL>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_MOD_CONTROL;


	if (kill) Control->Bit.setKILENA=true;
	else      Control->Bit.setKILENA=false;
	memrcpy(CanBuff+3, (uw8*)&Control->Word, 2);
	CanBuff[4]=0;
	strcpy(tstamp, SendTime);
	Write2Can(GetID()|EXT_INSTR, CanBuff, tstamp);
}

bool CHVMod24f::getEdcpModCtrlKILena(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=2;
		CanBuff[1]=(uw8)(EDCP_DATAID_MOD_CONTROL>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_MOD_CONTROL;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)&Control->Word, (uw8*)CanBuff+3, 2);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return Control->Bit.setKILENA;
}

void CHVMod24f::setEdcpModCtrlAdjust(bool Adjust)
{
	uw8  CanBuff[10];
	char tstamp[20];

	CanBuff[0]=0x04;
	CanBuff[1]=(uw8)(EDCP_DATAID_MOD_CONTROL>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_MOD_CONTROL;
	if (Adjust) Control->Bit.setADJ=true;
	else        Control->Bit.setADJ=false;
	memrcpy(CanBuff+3, (uw8*)&Control->Word, 2);
	strcpy(tstamp, SendTime);
	Write2Can(GetID()|EXT_INSTR, CanBuff, tstamp);
}

bool CHVMod24f::getEdcpModCtrlAdjust(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=2;
		CanBuff[1]=(uw8)(EDCP_DATAID_MOD_CONTROL>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_MOD_CONTROL;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)&Control->Word, CanBuff+3, 2);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return Control->Bit.setADJ;
}


uw16 CHVMod24f::getEdcpModStat(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=2;
		CanBuff[1]=(uw8)(EDCP_DATAID_MOD_STATUS>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_MOD_STATUS;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)&Status->Word, CanBuff+3, 2);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			*Error=IDOK;
		}
	} while (*Error==IDRETRY);

	return Status->Word;
}


void CHVMod24f::setEdcpModCtrl(TEdcpMdControl Ctrl)
{
	uw8  CanBuff[10];
	char tstamp[20];

	CanBuff[0]=0x04;
	CanBuff[1]=(uw8)(EDCP_DATAID_MOD_CONTROL>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_MOD_CONTROL;
	Control->Word=Ctrl.Word;
	memrcpy(CanBuff+3, (uw8*)&Control->Word, 2);
	strcpy(tstamp, SendTime);
	Write2Can(GetID(), CanBuff, tstamp);
}

TEdcpMdControl CHVMod24f::getEdcpModCtrl(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=2;
		CanBuff[1]=(uw8)(EDCP_DATAID_MOD_CONTROL>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_MOD_CONTROL;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)&Control->Word, CanBuff+3, 2);
			//Control->Q=QUALITY_GOOD;
			//strcpy(Control->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//Control->Q=QUALITY_BAD;
			//EvalMessageError();
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *Control;
}

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

void CHVMod24f::setEdcpModEvntStat(TEdcpMdEventStatus evntstat)
{
	uw8  CanBuff[10];
	char tstamp[20];

	CanBuff[0]=0x04;
	CanBuff[1]=(uw8)(EDCP_DATAID_MOD_EVENT_STATUS>>8);
	CanBuff[2]=(uw8)EDCP_DATAID_MOD_EVENT_STATUS;
	memrcpy(CanBuff+3, (uw8 *)&evntstat.Word , 2);
	strcpy(tstamp, SendTime);
	Write2Can(GetID(), CanBuff, tstamp);
	*EventStatus=evntstat;

}
TEdcpMdEventStatus CHVMod24f::getEdcpModEvntStat(void)
{
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=2;
		CanBuff[1]=(uw8)(EDCP_DATAID_MOD_EVENT_STATUS>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_MOD_EVENT_STATUS;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)&EventStatus->Word, CanBuff+3, 2);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *EventStatus;
}

uw16 CHVMod24f::getEdcpModEvntStat2(void)
{
	uw16 data = 0;
	uw8  CanBuff[10];
	char tstamp[20];

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

		CanBuff[0]=2;
		CanBuff[1]=(uw8)(EDCP_DATAID_MOD_EVENT_STATUS2>>8);
		CanBuff[2]=(uw8)EDCP_DATAID_MOD_EVENT_STATUS2;
		strcpy(tstamp, SendTime);
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			memrcpy((uw8*)&data, CanBuff+3, 2);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return data;
}

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

struct TDevIDR CHVMod24f::GetDcpDevIDR(void)
{
	uw8  CanBuff[10];
	char tstamp[20];
	uw32 data;

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

		CanBuff[0]=1;
		CanBuff[1]=DCP_DATAID_MOD_DEVICEID_SOFTWAREID;
		strcpy(tstamp, SendTime);
		DevIDR->Q=QUALITY_BAD;
		if (WriteReadfCan(GetID()|DATA_DIR, CanBuff, tstamp)) {
			data=(CanBuff[2]*0x10000)+(CanBuff[3]*0x100)+CanBuff[4];
			ltoa(data,DevIDR->GID,16);
			DevIDR->SID[0]=(CanBuff[5]&0x0f)+0x30;
			DevIDR->SID[1]='.';
			DevIDR->SID[2]=( (CanBuff[6]>>4)&0x0f)+0x30;
			DevIDR->SID[3]=(CanBuff[6]&0x0f)+0x30;
			DevIDR->SID[4]=0x00;

			DevIDR->ChNb=CanBuff[7];
				
			DevIDR->Q=QUALITY_GOOD;

			strcpy(DevIDR->TSt, tstamp);
			*Error=IDOK;
			*ErrCnt=0;
		}
		else {
			//EvalMessageError();
			DevIDR->Q=QUALITY_BAD;
			Sleep(*ErrCnt*DECOUPLING);
		}
	} while (*Error==IDRETRY);

	return *DevIDR;
}

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