void TimeSensor::frame(Time tTime, UInt32 uiFrame)
{
Real64 dFraction;
bool bDoTimeRange = bool(_sfStartTime.getValue() <
_sfStopTime .getValue());
bool bDoCycle = false;
if(bDoTimeRange)
{
dFraction =
Real64( tTime - _sfStartTime.getValue()) /
Real64(_sfStopTime.getValue() - _sfStartTime.getValue());
}
else
{
if(_sfCycleTime.getValue() > 0.0)
{
dFraction =
Real64(tTime - _sfCycleTime.getValue()) /
Real64(_sfCycleInterval.getValue());
bDoCycle = true;
}
else
{
dFraction =
Real64(tTime - _sfStartTime.getValue()) /
Real64(_sfCycleInterval.getValue());
}
}
if(_sfEnabled.getValue() == false)
{
if(_sfIsActive.getValue() == true)
{
setTime (tTime);
setIsActive(false);
setFraction(Real32(dFraction));
}
}
else
{
if(dFraction < 0.0) // before start
{
if(bDoCycle == true)
{
if(_sfIsActive.getValue() == true)
{
if(_sfLoop.getValue() == false)
{
setIsActive (false);
setTime (tTime);
setFraction (1.0 );
setCycleTime(tTime);
}
else
{
setCycleTime(_sfCycleTime .getValue() -
_sfCycleInterval.getValue());
setTime (tTime);
setFraction (dFraction + 1.0);
}
}
else
{
}
}
}
else if(dFraction > 1.0) // after end time
{
if(_sfIsActive.getValue() == true)
{
if(_sfLoop.getValue() == false)
{
setIsActive (false);
setTime (0.f );
setFraction (1.0 );
setCycleTime(0.f );
setEnabled (false);
}
else
{
setCycleTime(_sfCycleTime .getValue() +
_sfCycleInterval.getValue());
setTime (tTime);
setFraction (dFraction - 1.0);
}
}
else
{
if(bDoTimeRange == false)
{
setFraction (0.f);
setCycleTime(tTime -
(_sfFraction .getValue() *
_sfCycleInterval.getValue() ));
setIsActive (true);
setTime (tTime);
}
}
}
else // within cycle
{
if (_sfIsActive.getValue() == false)
{
if(bDoTimeRange == true)
{
setCycleTime(_sfStartTime.getValue());
setIsActive (true);
setTime (tTime);
setFraction (dFraction);
}
else
{
setCycleTime(tTime -
(_sfFraction .getValue() *
_sfCycleInterval.getValue() ));
if(_sfCycleTime.getValue() >
TypeTraits<Time>::getDefaultEps())
{
setIsActive(true);
}
setTime(tTime);
}
}
else
{
if(tTime >= _sfStopTime.getValue() &&
bDoTimeRange == true )
{
setIsActive(false);
}
else
{
if(tTime >= _sfStartTime.getValue())
{
setTime (tTime );
setFraction(dFraction);
}
}
}
}
}
}
int procSetUnit(unitPtr uPtr,char *sendBuf,short *sendLen,char bitpos,char *pRecvPtr) {
char string[256];
char error[1000];
char buffer[MAXBUF];
char input[MAXBUF];
char *errPtr=error;
/* short t; */
float erg=0.0;
int ergI=0;
short count;
char ergType;
float floatV;
char *inPtr;
/* hier die Typen fuer die Umrechnung in <type> Tag */
int8_t charV;
uint8_t ucharV;
int16_t shortV;
int16_t tmpS;
uint16_t ushortV;
uint16_t tmpUS;
int32_t intV;
int32_t tmpI;
uint32_t tmpUI;
uint32_t uintV;
bzero(errPtr,sizeof(error));
/* etwas logging */
int n=0;
char *ptr;
char dumBuf[10];
bzero(dumBuf,sizeof(dumBuf));
bzero(buffer,sizeof(buffer));
/* wir kopieren uns den sendBuf, da dieser auch als return genutzt wird */
strncpy(input,sendBuf,sizeof(input));
bzero(sendBuf,sizeof(sendBuf));
if (strstr(uPtr->type,"cycletime")==uPtr->type) { /* Schaltzeit */
if (! *input)
return(-1);
if (!(*sendLen=setCycleTime(input,sendBuf)))
return(-1);
else {
return(1);
}
}
if (strstr(uPtr->type,"systime")==uPtr->type) { /* Schaltzeit */
if (!(*sendLen=setSysTime(input,sendBuf,*sendLen)))
return(-1);
else {
return(1);
}
}
else if (strstr(uPtr->type,"enum")==uPtr->type) { /*enum*/
if (! *input)
return(-1);
if(!(count=text2Enum(uPtr->ePtr,input,&ptr,sendLen))) {
sprintf(sendBuf,"Kein passendes Enum gefunden");
return(-1);
}
else {
memcpy(sendBuf,ptr,count);
return(1);
}
}
if (! *input)
return(-1);
/* hier der uebergebene Wert */
if (uPtr->sCalc && *uPtr->sCalc) { /* <calc im XML und set darin definiert */
floatV=atof(input);
inPtr=uPtr->sCalc;
logIT(LOG_INFO,"Send Exp:%s [V=%f]",inPtr,floatV);
erg=execExpression(&inPtr,dumBuf,floatV,errPtr);
if (*errPtr) {
snprintf(string, sizeof(string),"Exec %s: %s",uPtr->sCalc,error);
logIT(LOG_ERR,string);
strcpy(sendBuf,string);
return(-1);
}
ergType=FLOAT;
}
if (uPtr->sICalc && *uPtr->sICalc) { /* <icalc im XML und set darin definiert */
inPtr=uPtr->sICalc;
if( uPtr->ePtr) {/* es gibt enums hier */
if (! *input) {
sprintf(sendBuf,"Input fehlt");
return(-1);
}
if(!(count=text2Enum(uPtr->ePtr,input,&ptr,sendLen))) {
sprintf(sendBuf,"Kein passendes Enum gefunden");
return(-1);
}
else {
bzero(dumBuf,sizeof(dumBuf));
memcpy(dumBuf,ptr,count);
logIT(LOG_INFO,"(INT) Exp:%s [BP:%d]",inPtr,bitpos);
ergI=execIExpression(&inPtr,dumBuf,bitpos,pRecvPtr,errPtr);
if (*errPtr) {
snprintf(string, sizeof(string),"Exec %s: %s",uPtr->sICalc,error);
logIT(LOG_ERR,string);
strcpy(sendBuf,string);
return(-1);
}
ergType=INT;
snprintf(string, sizeof(string),"Erg: (Hex max. 4Byte) %08x",ergI);
}
}
}
/* das Ergebnis steht in erg und muss nun je nach typ umgewandelt werden */
if (uPtr->type) {
if (strstr(uPtr->type,"char")==uPtr->type) { /* Umrechnung in Short 2Byte */
/* je nach CPU Typ wird hier die Wandlung vorgenommen */
(ergType==FLOAT) ? (charV=erg) : (charV=ergI);
memcpy(sendBuf,&charV,1);
*sendLen=1;
}
else if (strstr(uPtr->type,"uchar")==uPtr->type) {
/* je nach CPU Typ wird hier die Wandlung vorgenommen */
(ergType==FLOAT) ? (ucharV=erg) : (ucharV=ergI);
memcpy(sendBuf,&ucharV,1);
*sendLen=1;
}
else if (strstr(uPtr->type,"short")==uPtr->type) {
/* je nach CPU Typ wird hier die Wandlung vorgenommen */
(ergType==FLOAT) ? (tmpS=erg) : (tmpS=ergI);
shortV=__cpu_to_le16(tmpS);
memcpy(sendBuf,&shortV,2);
*sendLen=2;
}
else if (strstr(uPtr->type,"ushort")==uPtr->type) {
/* je nach CPU Typ wird hier die Wandlung vorgenommen */
(ergType==FLOAT) ? (tmpUS=erg) : (tmpUS=ergI);
ushortV=__cpu_to_le16(tmpUS);
memcpy(sendBuf,&ushortV,2);
*sendLen=2;
}
else if (strstr(uPtr->type,"int")==uPtr->type) {
/* je nach CPU Typ wird hier die Wandlung vorgenommen */
(ergType==FLOAT) ? (tmpI=erg) : (tmpI=ergI);
intV=__cpu_to_le32(tmpI);
memcpy(sendBuf,&intV,2);
*sendLen=4;
}
else if (strstr(uPtr->type,"uint")==uPtr->type) {
/* je nach CPU Typ wird hier die Wandlung vorgenommen */
(ergType==FLOAT) ? (tmpUI=erg) : (tmpUI=ergI);
uintV=__cpu_to_le32(tmpUI);
memcpy(sendBuf,&uintV,2);
}
else if (uPtr->type) {
bzero(string,sizeof(string));
snprintf(string, sizeof(string),"Unbekannter Typ %s in Unit %s",uPtr->type,uPtr->name);
logIT(LOG_ERR,string);
return(-1);
}
bzero(buffer,sizeof(buffer));
ptr=sendBuf;
while(*ptr) {
bzero(string,sizeof(string));
unsigned char byte=*ptr++ & 255;
snprintf(string, sizeof(string),"%02X ",byte);
strcat(buffer,string);
if (n >= MAXBUF-3) /* FN Wo wird 'n' eigentlich initialisiert */
break;
}
snprintf(string, sizeof(string),"Typ: %s (Bytes: %s) ",uPtr->type,buffer);
logIT(LOG_INFO,string);
return(1);
}
return (0); /* Wenn ich das richtig verstehe, sollten wir hier nie landen FN, deshalb; keep compiler happy */
}