item.cpp

英创386的LCD控制协议和函数,还有例程

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#include "item.h"
//#include "env.h"
/*/////////////////////////////////////////////////////////////////////////
		*** Item Base Class ***
/////////////////////////////////////////////////////////////////////////*/
Item::Item( )
{
   OutStr = new char[64];
   Prefix[0] = Unit[0] = '\0';
   RIdx = 0;
   HighLight = -1;
}

Item::~Item( )
{
   if( OutStr != NULL ) delete OutStr;
}

void Item::MakeOutStr( char* VUStr )
{
   int  TL, k;
   char TmpStr[32];

   TL = strlen(Prefix) + strlen(VUStr);
   if( TL <= ItemOutStrSize )
      sprintf( OutStr, "%s%s", Prefix, VUStr );
   else
      {
      k = strlen(Prefix) - (TL-ItemOutStrSize);
      if( k >= 0 )
	 {
	 strcpy( TmpStr, Prefix );
	 TmpStr[k] = '\0';
	 sprintf( OutStr, "%s%s", TmpStr, VUStr );
	 }
      else
	 {
	 sprintf( TmpStr, "%s%s", Prefix, VUStr );
	 TmpStr[ItemOutStrSize] = '\0';
	 strcpy( OutStr, TmpStr );
	 }
      }
}

void Item::SetNameUnit( char* PreStr, char* UnitStr )
{
   char TmpStr[40];

   strcpy( TmpStr, PreStr );
   if( strlen(TmpStr) > 12 ) TmpStr[12] = '\0';
   strcpy( Prefix, TmpStr );

   strcpy( TmpStr, UnitStr );
   if( strlen(TmpStr) > 4 ) TmpStr[4] = '\0';
   strcpy( Unit, TmpStr );
}

int  Item::OutStrAvailable( )
{
   if( OutStr != NULL )          return 1;
   else if( strlen(Prefix) > 0 ) return 2;
   else		                 return 0;
}

void Item::DefineItem( char* TextStr )
{
   char TmpStr[40];
   int  TextLen, PrefixLen = 14;

   if( TextStr == NULL ) { Prefix[0] = '\0'; return; }
   TextLen = strlen( TextStr );

   strcpy( TmpStr, TextStr );
   if( TextLen > PrefixLen ) TmpStr[PrefixLen] = '\0';
   strcpy( Prefix, TmpStr );
}

int Item::GetOutStr( char* StrBuf )
{
   strcpy( StrBuf, Prefix );
   strcpy( OutStr, StrBuf );
   return RIdx;
}

/*/////////////////////////////////////////////////////////////////////////
		*** Item Derived Class Item_i ***
/////////////////////////////////////////////////////////////////////////*/
Item_i::Item_i( )
{
   OutStr = new char[ItemOutStrSize+2];
   strcpy( OutStr, "未定义!" );
   Prefix[0] = Unit[0] = '\0';
   RIdx = 0;
   HighLight = -1;

   V = 0;
   MaxV = MinV = delta = DELTA = 0;
}

Item_i::~Item_i( )
{
   delete OutStr;
}

void Item_i::DefineItem( int InitV, int Max, int Min, int d, int D )
{
   long l;

   V = InitV;
   MaxV = Max;
   MinV = Min;
   delta = d;
   DELTA = D;

   if( V<MinV || V>MaxV )
      {
      l = ( (long)MaxV + (long)MinV ) / 2l;
      V = (int)l;
      if( V != 0 ) V = MinV;
      }
}

float Item_i::Value( void* pParStruct )
{
   return V;
}

void Item_i::ValueInc( )
{
   V += delta;
   if( V > MaxV ) V = MinV;
}

void Item_i::ValueDec( )
{
   V -= delta;
   if( V < MinV ) V = MaxV;
}

void Item_i::ValueINC( )
{
   V += DELTA;
   if( V > MaxV ) V = MinV;
}

void Item_i::ValueDEC( )
{
   V -= DELTA;
   if( V < MinV ) V = MaxV;
}

int Item_i::GetOutStr( char* StrBuf )
{
   char VUStr[12];

   sprintf( VUStr, "%d%s", V, Unit );
   MakeOutStr( VUStr );
   strcpy( StrBuf, OutStr );
   return RIdx;
}

/*/////////////////////////////////////////////////////////////////////////
		*** Item Derived Class Item_e ***
/////////////////////////////////////////////////////////////////////////*/
Item_e::Item_e( )
{
   OutStr = new char[ItemOutStrSize+2];
   strcpy( OutStr, "未定义!" );
   Prefix[0] = Unit[0] = '\0';
   RIdx = 0;
   HighLight = -1;

   V = 0;
   NumStr = 0;
   EnumAddr = NULL;
}

Item_e::~Item_e( )
{
   delete OutStr;
}

void Item_e::DefineItem( int EnumIdx, int NumEnum, char** EnumPtr )
{
   V = EnumIdx;
   NumStr = NumEnum;
   EnumAddr = EnumPtr;

   if( V<0 || V>=NumStr ) V = 0;
}

float Item_e::Value( void* pParStruct )
{
   return V;
}

void Item_e::ValueInc( )
{
   V += 1;
   if( V >= NumStr ) V = 0;
}

void Item_e::ValueDec( )
{
   V -= 1;
   if( V < 0 ) V = NumStr - 1;
}

void Item_e::ValueINC( )
{
   ValueInc( );
}

void Item_e::ValueDEC( )
{
   ValueDec( );
}

int Item_e::GetOutStr( char* StrBuf )
{
   char VUStr[16];

   if( strlen(EnumAddr[V]) > ItemOutStrSize )
      {
      for( int i=0; i<ItemOutStrSize; i++ ) VUStr[i] = EnumAddr[V][i];
      VUStr[ItemOutStrSize] = '\0';
      }
   else
      strcpy( VUStr, EnumAddr[V] );

   MakeOutStr( VUStr );
   strcpy( StrBuf, OutStr );
   return RIdx;
}


/*/////////////////////////////////////////////////////////////////////////
		*** Item Derived Class Item_f ***
/////////////////////////////////////////////////////////////////////////*/
Item_f::Item_f( )
{
   OutStr = new char[ItemOutStrSize+2];
   strcpy( OutStr, "未定义!" );
   Prefix[0] = Unit[0] = '\0';
   RIdx = 0;
   HighLight = -1;
   SignDigital = NULL;

   ActItem = 0;
   DecimalIdx = 0;
   NumExp = 1;
   NumEff = 5;
   NumItem = 0;
}

Item_f::~Item_f( )
{
   delete OutStr;
   if( SignDigital != NULL ) delete SignDigital;
}

void Item_f::DefineItem( float InitV, int EffPrecision, int ExpPrecision )
{
   int   i, j, k, SignFlg[2], InitD[8];
   float xf, AbsMax;
   char  FStr[10], AChar[2];

   if( SignDigital != NULL ) { delete SignDigital; SignDigital = NULL; }

   NumExp = abs(ExpPrecision) % 3;
   switch( NumExp )
      {
      case 0: if( EffPrecision <= 6 ) NumEff = abs(EffPrecision);
	      else	              NumEff = 6;
	      NumItem = 1+NumEff;
	      break;
      case 1: if( EffPrecision <= 5 ) NumEff = abs(EffPrecision);
	      else	              NumEff = 5;
	      NumItem = 1+NumEff+1+NumExp;
	      break;
      case 2: if( EffPrecision <= 4 ) NumEff = abs(EffPrecision);
	      else	              NumEff = 4;
	      NumItem = 1+NumEff+1+NumExp;
	      break;
      }

   if( NumEff < 3 ) return;
   SignDigital = new Item_i[NumItem];

   // split InitV
   if( InitV >= 0 ) SignFlg[0] = 0;
   else            SignFlg[0] = 1;
   xf = fabs(InitV);
   AChar[1] = '\0';
   if( NumExp == 0 )
      {
      AbsMax = pow10(NumEff) - 1;
      if( xf > AbsMax ) xf = AbsMax;
      sprintf( FStr, "%f", xf );
      for( i=0, j=0; i<NumEff; i++ )
	 {
	 if( FStr[j] == '.' ) j++;
	 AChar[0] = FStr[j];
	 InitD[i] = atoi( AChar );
	 j++;
	 }
      }
   else
      {
      k = 0;
      for( ; ; )
	 {
	 if( (xf>=1.0) && (xf<10.0) ) break;
	 if( xf >= 10.0 ) { xf /= 10.0; k++; }
	 if( xf < 1.0 ) { xf *= 10.0; k--; }
	 }
      sprintf( FStr, "%f", xf );
      for( i=0, j=0; i<NumEff; i++ )
	 {
	 if( FStr[j] == '.' ) j++;
	 AChar[0] = FStr[j];
	 InitD[i] = atoi( AChar );
	 j++;
	 }
      if( k >= 0 ) SignFlg[1] = 0;
      else	   SignFlg[1] = 1;
      k = abs( k );
      j = k / 10;
      k = k % 10;
      }

   SignDigital[0].SetNameUnit( );
   SignDigital[0].DefineItem( SignFlg[0], 1, 0, 1, 1 );
   for( i=0; i<NumEff; i++ )
      {
      SignDigital[i+1].SetNameUnit( );
      SignDigital[i+1].DefineItem( InitD[i], 9, 0, 1, 1 );
      }

   switch( NumExp )
      {
      case 1: SignDigital[1+NumEff].SetNameUnit( );
	      SignDigital[1+NumEff].DefineItem( SignFlg[1], 1, 0, 1, 1 );
	      SignDigital[2+NumEff].SetNameUnit( );
	      SignDigital[2+NumEff].DefineItem( k, 9, 0, 1, 1 );
	      break;
      case 2: SignDigital[1+NumEff].SetNameUnit( );
	      SignDigital[1+NumEff].DefineItem( SignFlg[1], 1, 0, 1, 1 );
	      SignDigital[2+NumEff].SetNameUnit( );
	      SignDigital[2+NumEff].DefineItem( j, 2, 0, 1, 1 );
	      SignDigital[1+2+NumEff].SetNameUnit( );
	      SignDigital[1+2+NumEff].DefineItem( k, 9, 0, 1, 1 );
	      break;
      }

   i = ItemOutStrSize-(NumItem+1);
   if( strlen(Prefix)>i ) Prefix[i] = '\0';

   ActItem = 0;
   DecimalIdx = 0;
   HighLight = strlen(Prefix);
}

float Item_f::Value( void* pParStruct )
{
   int i, j;
   float x, y;

   // make effective data
   x = 0;
   for( i=0, j=1; i<NumEff; i++, j++ )
      x += ( SignDigital[j].Value() * pow10(-i) );

   if( (int)(SignDigital[0].Value()) == 1 ) x = -x;

   // make exponent data
   switch( NumExp )
      {
      case 0: y = pow10( DecimalIdx ); break;
      case 1: y = SignDigital[2+NumEff].Value();
	      if( (int)(SignDigital[1+NumEff].Value())==1 ) y = pow10(-y);
	      else					    y = pow10(y);
	      break;
      case 2: y = 10*SignDigital[2+NumEff].Value()
		+ SignDigital[3+NumEff].Value();
	      if( (int)(SignDigital[1+NumEff].Value())==1 ) y = pow10(-y);
	      else					    y = pow10(y);
	      break;
      }

   return (x*y);
}

void Item_f::ValueInc( )
{
   SignDigital[ActItem].ValueInc( );
}

void Item_f::ValueDec( )
{
   SignDigital[ActItem].ValueDec( );
}

void Item_f::ValueINC( )
{
   int i = ItemOutStrSize-(NumItem+1);
   if( strlen(Prefix)>i ) Prefix[i] = '\0';

   ActItem += 1;
   if( ActItem >= NumItem ) ActItem = 0;

   HighLight = strlen(Prefix) + ActItem;
   if( (ActItem-1) > DecimalIdx ) HighLight += 1;
}

void Item_f::ValueDEC( )
{
   int i = ItemOutStrSize-(NumItem+1);
   if( strlen(Prefix)>i ) Prefix[i] = '\0';

   if( NumExp>0 )
      {
      ActItem -= 1;
      if( ActItem < 0 ) ActItem = NumItem-1;
      }
   else
      {
      DecimalIdx += 1;
      if( DecimalIdx >= NumEff ) DecimalIdx = 0;
      }

   HighLight = strlen(Prefix) + ActItem;
   if( (ActItem-1) > DecimalIdx ) HighLight += 1;
}

int Item_f::GetOutStr( char* StrBuf )
{
   int  i, j;
   char TmpStr[20], DStr[20], SIGN;

   if( (int)( SignDigital[0].Value() ) == 0 ) SIGN = '+';
   else                                       SIGN = '-';
   sprintf( TmpStr, "%c", SIGN );

   for( i=0, j=1; i<NumEff; i++, j++ )
      {
      if( (i-1) == DecimalIdx )
	 {
	 sprintf( DStr, "%s.", TmpStr );
	 strcpy( TmpStr, DStr );
	 }
      sprintf( DStr, "%s%d", TmpStr, (int)( SignDigital[j].Value() ) );
      strcpy( TmpStr, DStr );
      }
   if( (i-1) == DecimalIdx )
      {
      sprintf( DStr, "%s.", TmpStr );
      strcpy( TmpStr, DStr );
      }

   if( NumExp > 0 )
      {
      if( (int)( SignDigital[1+NumEff].Value() ) == 0 ) SIGN = '+';
      else						SIGN = '-';
      sprintf( DStr, "%s%c", TmpStr, SIGN );
      strcpy( TmpStr, DStr );

      for( i=0, j=2+NumEff; i<NumExp; i++, j++ )
	 {
	 sprintf( DStr, "%s%d", TmpStr, (int)( SignDigital[j].Value() ) );
	 strcpy( TmpStr, DStr );
	 }
      }

   sprintf( OutStr, "%s%s%s", Prefix, DStr, Unit );
   strcpy( StrBuf, OutStr );
   return RIdx;
}