eibdrv_fl.c

欧洲安装总线系统的USB串口接口驱动c程序源代码.软件代码由西门子公司提供

/* ---------------------------------------------------------------------------
   eibdrv_fl.c
   ---------------------------------------------------------------------------
   eibdrv_fl Version 0.2.1
   Copyright (C) 2002, Wolfgang Tumfart
                       Donaustrasse 104/9
                       A-2344 Maria Enzersdorf
                       Austria (Europe)
                       [e-mail]

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   675 Mass Ave, Cambridge, MA 02139, USA.
   --------------------------------------------------------------------------- */

/* ---------------------------------------------------------------------------
   This file represents only a rough and incomplete implementation of
   some functions to access the Forms Library for buidling the GUI of
   all eibdrv-Tools.
   --------------------------------------------------------------------------- */

/* ---------------------------------------------------------------------------
   FormsLibrary is copyrighted by T.C. Zhao and Mark Overmars. It is not
   public domain, but may be used for running publically available free
   software.
   --------------------------------------------------------------------------- */

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

#include "forms.h"
#include "eibdrv_fl.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>

int errutility;


int bin_input_filter(FL_OBJECT *obj, const char *old, const char *cur, int c)
{  if ((c<48)||(c>49))
      return FL_INVALID|FL_RINGBELL;
   else
      return FL_VALID;
}



int hex_input_filter(FL_OBJECT *obj, const char *old, const char *cur, int c)
{  if ((c<48)||((c>57)&&(c<65))||((c>70)&&(c<97))||(c>102))
      return FL_INVALID|FL_RINGBELL;
   else
      return FL_VALID;
}



int dec_input_filter(FL_OBJECT *obj,const char *old,const char *cur,int c)
{  if ((c<48)||(c>57))
      return FL_INVALID|FL_RINGBELL;
   else
      return FL_VALID;
}

int asciiID_input_filter2(FL_OBJECT *obj,const char *old,const char *cur,int c)
{  switch(strlen(old))
   {   case 0: 
       case 1:
       case 2: if (((c>=48)&&(c<=57))||((c>=65)&&(c<=90)))
                  return FL_VALID;
               else
                  return FL_INVALID|FL_RINGBELL;
       case 3: 
       case 5: if (((c>=48)&&(c<=57))||((c>=65)&&(c<=70)))
                  return FL_VALID;
               else
                  return FL_INVALID|FL_RINGBELL;
       case 4: if (c==46)
                  return FL_VALID;
               else
                  return FL_INVALID|FL_RINGBELL;
   }
}



long BinToLong(char *Bin)
{  
   char *BinValue;
   long DecValue=0;
   
   if (strlen(Bin)>32)
   {  errutility=-2;
      return 0;
   }
   else
   {  for (BinValue=Bin;*BinValue!='\0';BinValue++)
         switch(*BinValue)
         {  case '0' : DecValue=DecValue*2;   break;
            case '1' : DecValue=DecValue*2+1; break;
            default  : errutility=-1;
                       return 0;
                       break;
         }
      errutility=0;
      return DecValue;
   }
}



char *BinToHex(char *Bin,char *Hex)
{  int Length=strlen(Bin);
   char *help=(char *)malloc((Length+4)*sizeof(char));
   char help2[5];
   char *help3;
   char *BinCode[16][2]={{"0000","0"},
                         {"0001","1"},
                         {"0010","2"},
                         {"0011","3"},
                         {"0100","4"},
                         {"0101","5"},
                         {"0110","6"},
                         {"0111","7"},
                         {"1000","8"},
                         {"1001","9"},
                         {"1010","A"},
                         {"1011","B"},
                         {"1100","C"},
                         {"1101","D"},
                         {"1101","E"},
                         {"1111","F"}};
   int i,j;
      
   strcpy(help,"");
   for (i=1;i<=(div(Length,4)).rem;i++)
      strcat(help,"0");
   strcat(help,Bin);
   help3=help;
   while (*help3!='\0')
   {  for (i=0;i<4;i++)
      {  if ((*help3!='0')&&(*help3!='1'))
         {   strcpy(Hex,"");
             return Hex;
         }
         else 
         {  help2[i]=*help3;
            help3++;
         }
      }
      help2[4]='\0';
      j=0;
      while (strcmp(BinCode[j][0],&help2[0])!=0)
         j++;
      strcat(Hex,BinCode[j][1]);
   }
   return Hex;
}



char *HexToBin(char *Hex,char *Bin)
{  char *help2;
   int i;
   int help;
   char *BinCode[22]={"0000","0001","0010","0011","0100","0101","0110","0111",
                     "1000","1001","1010","1011","1100","1101","1101","1111",
                     "1010","1011","1100","1101","1101","1111"};

   for (help2=Hex;(*help2)!='\0';help2++)
   {   help=(int)*help2;

       if ((help>=48)&&(help<=57))
          strcat(Bin,BinCode[help-48]);
       else if ((help>=65)&&(help<=70))
          strcat(Bin,BinCode[help-55]);
       else if ((help>=97)&&(help<=102))
          strcat(Bin,BinCode[help-81]);
       else 
       {  strcpy(Bin,"");
          errutility=-2;
          return Bin;
       }
   }
   errutility=0;
   help2=strchr(Bin,'1');
   if (help2!=NULL)
      strcpy(Bin,help2);
   else
      strcpy(Bin,"0");
   return Bin;
}


int hextobin(char *hex,char *bin)
{  char *help2;
   int i;
   int help;
   char *binCode[22]={"0000","0001","0010","0011","0100","0101","0110","0111",
                     "1000","1001","1010","1011","1100","1101","1101","1111",
                     "1010","1011","1100","1101","1101","1111"};

   strcpy(bin,"");                    
   for (help2=hex;*help2!='\0';help2++)
   {   help=(int)*help2;
       if ((help>=48)&&(help<=57))
          strcat(bin,binCode[help-48]);
       else if ((help>=65)&&(help<=70))
          strcat(bin,binCode[help-55]);
       else if ((help>=97)&&(help<=102))
          strcat(bin,binCode[help-81]);
       else 
       {  errutility=-2;
          return 0;
       }
   }
   errutility=0;
   help2=strchr(bin,'1');
   if (help2!=NULL)
      strcpy(bin,help2);
   else
      strcpy(bin,"0");
   return strlen(bin);
}


void IntToString2(int value,char *string)
{  char help[2];
   int stelle;

   stelle=value%10;
   help[0]='0'+stelle;
   help[1]='\0';

   if (value/10>0) IntToString2(value/10,string);

   strcat(string,&help[0]);
}


void AsciiChipID_to_HexChipID2(char *AsciiChipID, char *HexChipID)
{  int i;
   int length=strlen(AsciiChipID);
   char helpHex[3];
   
   strcpy(HexChipID,"");
   i=0;
   while((i<=(length-1))&&(i<=2))
   {  sprintf(&helpHex[0],"%x",((*(AsciiChipID+i))-'0'+0x30));
      strcat(HexChipID,&helpHex[0]);
      i++;
   }
   if (length>=4)
   {  sprintf(&helpHex[0],"%x",((*(AsciiChipID+3))-'0'));
      strcat(HexChipID,&helpHex[0]);
   }
   if (length>=6)
   {  sprintf(&helpHex[0],"%x",((*(AsciiChipID+5))-'0'));
      strcat(HexChipID,&helpHex[0]);
   }
}

int read_ValueEditfield(FL_OBJECT *obj,int base,unsigned long *value)
{  int length=strlen(fl_get_input(obj));
   char *helpHexPtr=(char *)malloc(9*sizeof(char));
   char *helpHex2Ptr=(char *)malloc(11*sizeof(char));
   
//   printf("ReadValueEditfield mit Base=%i\n",base);
   switch(base)
   {  case 2:
      case 10:
      case 16: *value=strtoul(fl_get_input(obj),NULL,base);
               break;
      case 90: *value=strtoul(fl_get_input(obj),NULL,16);
               break;
      case 91: AsciiChipID_to_HexChipID2((char *)fl_get_input(obj),helpHexPtr);
               *value=strtoul(helpHexPtr,NULL,16);
               break;
   }
   switch(errno)
   {  case 0:      return length;
                   break;
      case ERANGE: return -1;
                   break;
      default:     return -2;
                   break;
   }
   free(helpHexPtr);
}


void HexChipID_to_AsciiChipID2(char *HexChipID, char *AsciiChipID)
{   int i,j=0;
    char hex_help[3];
    char ascii_help[7];
    
    for (i=0;i<=4;i+=2)
    {   hex_help[0]=(*((HexChipID)+i));
        hex_help[1]=(*((HexChipID)+i+1));
        hex_help[2]='\0';
        ascii_help[j]=(int)strtol(&hex_help[0],NULL,16);
        j++;
    }      
    ascii_help[3]=(*((HexChipID)+6));
    ascii_help[4]='.';
    ascii_help[5]=(*((HexChipID)+7));
    ascii_help[6]='\0';
    
    strcpy(AsciiChipID,&ascii_help[0]);
}


int write_ValueEditfield(FL_OBJECT *obj,int base,unsigned long value,int maxchars)
{  int i;
   int l;
   int ReturnValue;
   char *objstring=(char *)malloc(33*sizeof(char));
   char *helpstring=(char *)malloc(33*sizeof(char));
   char *nullstring=(char *)malloc(33*sizeof(char));
   
   strcpy(objstring,"");
   strcpy(helpstring,""); 
   strcpy(nullstring,"0000000000000000000000000000000000");
   
   if (value>ULONG_MAX)
      ReturnValue=-1;
   else
   {  switch(base)
      {  case 10: l=sprintf(objstring,"%li",value);
                  break;
         case 16: l=sprintf(objstring,"%x",value);
                  break;
         case 2:  sprintf(helpstring,"%x",value);
                  l=hextobin(helpstring,objstring);
                  break;
         case 90: sprintf(objstring,"%x",value);
                  l=strlen(objstring);        
                  break;
         case 91: sprintf(helpstring,"%x",value);
                  HexChipID_to_AsciiChipID2(helpstring,objstring);
                  l=strlen(objstring);
                  break;
      }
      if (l<0)
         ReturnValue=-2;
      else 
      { /* if (maxchars>l)
         {  strncat(helpstring,nullstring,maxchars-l);
            strcat(helpstring,objstring);
            fl_set_input(obj,helpstring);
         }
         else  */
            fl_set_input(obj,objstring);
         ReturnValue=l;
      }