plc_utility.lib

//$Id: plc_utility.lib,v 1.8 2008-09-15 21:48:55 charlie Exp $

/*

   $Log: plc_utility.lib,v $

*/

/*** BeginHeader */

#ifndef __ISM_UTILITY_

#define __ISM_UTILITY_

/*** EndHeader */

/*** BeginHeader

	InitializeUtility,

	MsDelay,

	BitToMask,

	GetXmemChar,

	StrSafeCopy,

	IntUnitString3,

	IntUnitString,

	ParseFloatString,

	ParseIntString,

	Halt,

	RuntimeHalt,

	SetNow,

	GetNow,

	IbRegister,

	ExternalAddress,

	ForceSetVectExtern,

	BeepToggleQuiet,

	DivRound,

	GetTimeOfDay,

	SetTimeOfDay,

	AccumInt,

   UpdateDigit,

	_my_xexit,

   mygetcrc,

	 UpdateConfiguration,

	 TestConfiguration,

	 DupeConfiguration,

	 CorrespondingMd5,

    CalculateMd5,

    SourcePort,

    mid

*/

nodebug void InitializeUtility();

nodebug void MsDelay(int);

nodebug int  BitToMask(int i);

nodebug void StrSafeCopy(char *dst, char *src, int n);

nodebug char *IntUnitString3(char *s, long x, char *units);

nodebug char *IntUnitString(char *s, long x, char *units, int len);

nodebug void SeqDiag1d(char *fmt, double ts, int n1);

nodebug void SeqDiag2d(char *fmt, double ts, int n1, int n2);

nodebug void SeqDiag1s1f(char *fmt, double ts, char *s1, double f1);

nodebug void SeqDiag1s(char *fmt, double ts, char *s1);

nodebug void SeqDiag(char *fmt);

nodebug void SeqDiag1s1d(char *fmt, double ts, char *s1, int n1);

nodebug void SeqDiag1s2d(char *fmt, double ts, char *s1, int n1, int n2);

nodebug void SeqDiag2s1d(char *fmt, double td, char *s1, char *s2, int n1);

nodebug void SeqDiag1s1d1s1d(char *fmt, double td, char *s1, int n1, char *s2, int n2);

nodebug void SeqDiag3d(char *fmt, double ts, int n1, int n2, int n3);

nodebug void SeqDiagnt3d(char *fmt, int n1, int n2, int n3);

nodebug unsigned long ParseFloatString(char *s, int endOfNumber, unsigned long multiplier);

nodebug unsigned long ParseIntString(char *s, int endOfNumber);

nodebug void Halt();

nodebug void RuntimeHalt(int errorCode, int extra, int xpc, int returnAdr);

nodebug void SetNow();

nodebug Ms GetNow();

nodebug int  IbRegister(int bit);

nodebug int  ExternalAddress(int bit);

nodebug useix nodebug unsigned ForceSetVectExtern(int interruptNum, void *isr);

nodebug void BeepToggleQuiet();

nodebug long DivRound(long dividend, int divisor);

nodebug void  SetTimeOfDay (int year, int month, int day, int hour, int minute, int second);

nodebug void  GetTimeOfDay (struct tm *tod);

nodebug int  AccumInt(int code, char *aString, int aLabelStart, int aLabelEnd, int intSize);

nodebug void UpdateDigit(int code, char *aString, int aLabelStart, int aLabelEnd,

				    float aResolution, float aLowLimit, float aHighLimit, int aFast);

nodebug int mygetcrc(char *data, int count, int accum);

nodebug void trim(char *s);

nodebug void rtrim( char * string, char * trim );

nodebug void ltrim( char * string, char * trim );

/*** EndHeader */

Ms nowTime;

nodebug void stringPair(char *buffer, int len, int left, char *leftMsg, char *rightMsg, int right);

int beepQuietness;

void InitializeUtility()

{

	char aNull;

	printf("Init Utility ...\n");

	aNull = 0;

	beepQuietness = 0;

}

void MsDelay(int t)

{

	Ms now;

	now = (Ms)MS_TIMER;

	while (MS_TIMER  - now < (Ms)t);

}

int BitToMask(int i)

{

  int result;

  result = 1;

  result <<= i;

  return result;

}

void StrSafeCopy(char *dst, char *src, int n)

{

	strncpy(dst, src, n);

  dst[n] = 0;

}

long DivRound(long dividend, int divisor)

{

	long result;

	result = 0;

	if (divisor != 0)

	{

		result = dividend;

		if (result > 0) result += divisor / 2;

		else result -= divisor / 2;

		result /= divisor;

	}

	return result;

}

unsigned long ParseFloatString(char *s, int endOfNumber, unsigned long multiplier)

{

	int i;

	unsigned long result;

	long intPart;

	long fracPart;

	long div;

	result = 0L;

	div = 0;

	intPart = 0L;

	fracPart = 0L;

	for (i = 0 ; i < endOfNumber ; i++)

	{

		if (s[i] >= '0' && s[i] <=  '9')

		{

			if (div == 0)

			{

				intPart *= 10;

				intPart += s[i] - '0';

			}

			else

			{

				div *= 10;

				fracPart *= 10;

				fracPart += s[i] - '0';

			}

		}

		else if (s[i] == '.')

		{

			div = 1;

		}

	}

	result = intPart * multiplier;

	if (div != 0) result += fracPart * multiplier / div;

	return result;

}

unsigned long ParseIntString(char *s, int endOfNumber)

{

	int i;

	unsigned long result;

	long intPart;

	result = 0L;

	intPart = 0L;

	for (i = 0 ; i < endOfNumber ; i++)

	{

		if (s[i] >= '0' && s[i] <=  '9')

		{

			intPart *= 10;

			intPart += s[i] - '0';

		}

	}

	result = intPart;;

	return result;

}

void RuntimeHalt(int errorCode, int extra, int returnXpc, int returnAdr)

{

Ms start;

#if CRASHREBOOT == 1

   printf("Rebooting!!!!!\n");

   start = MS_TIMER;

   while (MS_TIMER - start < 2000);

   forceSoftReset();

#else

	   sprintf(ErrorMessage, "Runtime error #%d at %02x%04x", errorCode, (int)((returnXpc>>8)&0xff), returnAdr);

	   Halt();

#endif

}

const char flag[] = " >> ";

void Halt()

{

	char displayErrorMessage[DISPLAY_LENGTH_DEF];

	char longerErrorMessage[ERROR_MESSAGE_LENGTH + sizeof(flag)];

	int idx;

	int i,j;

	char aChar;

	idx = 0;

	strcpy(longerErrorMessage, flag);

	for (i = 0, j = strlen(longerErrorMessage) ; ErrorMessage[i] != 0 ; i++, j++)

	{

		aChar = ErrorMessage[i];

		if (aChar < ' ') aChar = ' ';

		longerErrorMessage[j] = aChar;

	}

	longerErrorMessage[j] = 0;

	while (!kbhit())

	{

		for (i = 0 ; i < strlen(longerErrorMessage + idx) && i < DISPLAY_LENGTH ; i++)

		{

			displayErrorMessage[i] = longerErrorMessage[idx + i];

		}

		if (i == strlen(longerErrorMessage + idx))

		{

	      for (j = 0 ; j < strlen(longerErrorMessage) && i < DISPLAY_LENGTH ; j++,i++)

	      {

	      	displayErrorMessage[i] = longerErrorMessage[j];

	      }

	   }

	   displayErrorMessage[i] = 0;

	   DisplayText(displayErrorMessage);

		MsDelay(150);

		if (++idx >= strlen(longerErrorMessage)) idx = 0;

	}

	getchar();

}

void SetNow() {nowTime = (Ms)MS_TIMER;}

Ms GetNow() {return nowTime;}

int IbRegister(int bit)

{

  int result;

  switch (bit)

  {

  case 0: result = IB0CR; break;

  case 1: result = IB1CR; break;

  case 2: result = IB2CR; break;

  case 3: result = IB3CR; break;

  case 4: result = IB4CR; break;

  case 5: result = IB5CR; break;

  case 6: result = IB6CR; break;

  case 7: result = IB7CR; break;

  }

  return result;

}

int ExternalAddress(int bit)

{

	int result;

	switch (bit)

	{

	case 0: result = 0x0000; break;

	case 1: result = 0x2000; break;

	case 2: result = 0x4000; break;

	case 3: result = 0x6000; break;

	case 4: result = 0x8000; break;

	case 5: result = 0xA000; break;

	case 6: result = 0xC000; break;

	case 7: result = 0xE000; break;

	}

	return result;

}

useix nodebug unsigned ForceSetVectExtern(int interruptNum, void *isr)

{

#asm

	; check for invalid vector number

	ld    de,0xfff0

	and   hl,de

	jr    z,.vecNumOK

	ld    hl,0

	push  hl

	jr    .done

.vecNumOK:

	; table entries are 16 bytes

	ld 	de,16

	ld 	hl,(ix+interruptNum)

	ld    b,h

	ld    c,l

	mul

	; the eir reg contains the external vectable offset/100h

	ld    a,eir

	ld    e,c

	ld    d,a

	add	hl, de	; hl now points to the table entry

	; put the jump instruction first

	ld    (hl),0xc3

	push  hl

	inc   hl

	ld		iy, hl

	; put the isr address next

	ld    hl,(ix+isr)

  	ld    (iy),hl

.done:

	; return the address of the vector table entry

	pop   hl

#endasm

}

//GetTimeOfDay function *****************************************************************

void GetTimeOfDay (struct tm *tod)

{

	unsigned long seconds;

	seconds = read_rtc();

	mktm(tod, seconds);

}

//SetTimeOfDay function *****************************************************************

void SetTimeOfDay (int year, int month, int day,

                   int hour, int minute, int second)

{

	struct tm tod;

	unsigned long seconds;

	tod.tm_sec  = second;

	tod.tm_min  = minute;

	tod.tm_hour = hour;

	tod.tm_mday = day;

	tod.tm_mon  = month;

	tod.tm_year = year - 1900;

	tod.tm_wday = 0;

   seconds = mktime(&tod);

	write_rtc(seconds);	

}

void stringPair(char *buffer, int len, int left, char *leftMsg, char *rightMsg, int right)

{

	int i;

	int pad;

	buffer[len] = 0;

	pad = len - left - right - strlen(leftMsg) - strlen(rightMsg) - 1;

	for (i = 0 ; (i < left) && len; i++)

	{

		*buffer++ = ' ';

		len--;

	}

	StrSafeCopy(buffer, leftMsg, len);

	buffer += strlen(leftMsg);

	len -= strlen(leftMsg);

	for (i = 0 ; (i < pad) && len; i++)

	{

		*buffer++ = ' ';

		len--;

	}

	StrSafeCopy(buffer, rightMsg, len);

	buffer += strlen(rightMsg);

	len -= strlen(rightMsg);

	for (i = 0 ; (i < right) && len ; i++)

	{

		*buffer++ = ' ';

		len--;

	}

	if (len) *buffer++ = '\n';

	*buffer++ = 0;

}

#asm root

_my_xexit::

   push   af

   ld      a,(dkSendFlags)

   set   DKF_SEND_STATUS,a

   set   DKF_SEND_ACK,a

   ld      (dkSendFlags),a

   ld      a,(dkStatusFlags)

   res   DKF_STAT_RUNMODE,a

   set   DKF_STAT_ATEXIT,a

   set   DKF_STAT_AT_BP,a

   ld      (dkStatusFlags),a

   ld      a,TC_DEBUG_ATBREAKPOINT

   ld      (dkAckToSend),a

   ld      a,(OPMODE)                     ;

   and   8

   jr      z, _xexit_skiprst20enable

   ld      a,0xc3

   ld      (INTVEC_BASE+RST20_OFS),a

_xexit_skiprst20enable:

   pop   af

   push	af ; +2

   push	bc ; +4

   push	de ; +6

   push	hl ; +8

   push	ix ; +10

   push 	iy ; +12

   exx

   push	bc ; +14

   push 	de ; +16

   push	hl ; +18

   ld		a,xpc

   push	af ; +20

	ld		hl,(sp+28) ; Return adr

	push	hl

	ld		hl,(sp+28) ; XPC

	push	hl

	ld		hl,(sp+28) ; Extra

	push	hl

	ld		hl,(sp+28) ; Error Code

	push	hl

	call	RuntimeHalt

	add	sp,8

	pop	af

	ld		xpc,a

   pop	hl

   pop	de

   pop	bc

   exx

   pop	iy

   pop	ix

   pop	hl

   pop	de

   pop	bc

   pop	af

   add   sp,8

   rst   0x20

   ipset 3

   ld    a,0x00

   ioi   ld (WDTTR),a

_xexitLoop:

   jr      _xexitLoop

#endasm

#if 0

int LowStack()

{

	char *ptr;

	int i;

	int result;

	result = 0;

	ptr = (char*)(STACKORG);

	for (i = 0 ; i < STACK_MONITOR_SIZE ; i++)

	{

		if (*ptr++ != STACK_FILL)

		{

			result = (int)ptr;

			break;

		}

	}

	return result;

}

#endif

int mmin(int x, int y)

{

	int result;

   result = x;

   if (y < x) result = y;

   return result;

}

int mygetcrc(char *data, int count, int accum)

{

	int remaining;

   int result;

   int chunk;

   remaining = count;

   result = accum;

   while (remaining)

   {

   	chunk = mmin(255, remaining);

		result = getcrc(data, chunk, result);

      remaining -= chunk;

      data += chunk;

   }

   return result;

}

// AccumInt boardrev B ***********************************************************

int AccumInt(int code, char *aString, int aLabelStart, int aLabelEnd, int intSize)

{

	int result;

	int i;

	int ints;

	result = 0;

	ints = 0;

	for (i = aLabelStart-1 ; i < aLabelEnd ; i++)

	{

		if (aString[i] >= '0' && aString[i] <= '9')

		{

			ints++;

		}

	}

	if (code >= '0' && code <= '9' || '.')

	{

		if (ints >= intSize)

		{

			result = 1;

		}

		else

		{

			for (i = aLabelStart-1 ; i < aLabelEnd - 1; i++)

			{

				aString[i] = aString[i+1];

			}

	    aString[i] = code;

		}

	}

	return result;

}

// UpdateDigit boardrev C ***********************************************************

void UpdateDigit(int code, char *aString, int aLabelStart, int aLabelEnd,

				    float aResolution, float aLowLimit, float aHighLimit, int aFast)

{

	int i;

   char chValue[6];

   float value;

   int charWidth;

   char chFormat[6];

   strncpy(chValue, aString+aLabelStart, aLabelEnd - aLabelStart);

   chValue[aLabelEnd - aLabelStart] = '\0';

   value = atof(chValue);

   code = code == UPPB ? 1 : -1;

   value += code * aResolution * aFast;

   if (value < aLowLimit)

   	value = aHighLimit;

   else if (value > aHighLimit)

   	value = aLowLimit;

   if (aLabelEnd > DISPLAY_LENGTH) aLabelEnd = DISPLAY_LENGTH;

   charWidth = aLabelEnd - aLabelStart;

   sprintf(chValue, "%d", charWidth);

   strcpy(chFormat,"%");

   strcat(chFormat,chValue);

   if (aResolution < 1.0)

   	strcat(chFormat,".1f");

   else

   	strcat(chFormat,".0f");

   sprintf(chValue, chFormat, value);

   strcpy(aString+aLabelStart, chValue);

}

void trim(char *s)

{

	int i;

  int j;

  i = 0;

	while((s[i]==' ')||(s[i]=='\t')) {

		i++;

	}

	if(i>0) {

		for(j=0;j<strlen(s);j++) {

			s[j]=s[j+i];

		}

	s[j]='\0';

	}

	i=strlen(s)-1;

	while((s[i]==' ')||(s[i]=='\t')) {

		i--;

	}

	if(i<(strlen(s)-1)) {

		s[i+1]='\0';

	}

}

void rtrim( char * string, char * trim )

{

	int i;

	for( i = strlen (string) - 1; i >= 0

	&& strchr ( trim, string[i] ) != NULL; i-- )

		string[i] = '\0';

}

void ltrim( char * string, char * trim )

{

	while ( string[0] != '\0' && strchr ( trim, string[0] ) != NULL )

	{

		memmove( &string[0], &string[1], strlen(string) );

	}

}

/*** BeginHeader */

#endif

/*** EndHeader */