Home | Blog | Develop | Download | Contact

Funciones para Gnu-Linux

Definiciones

#define FALSE   0
#define TRUE   1
#define BOOL   int
#define INVALID_HANDLE_VALUE   -1
#define NONE   0
#define RTSCTS   1
#define HARD   1
#define XONXOFF   2
#define SOFT   2

Tipos definidos

typedef struct termios DCB
typedef int HANDLE

Funciones

int Kbhit_Port (HANDLE fd)
 Indica el número de caracteres disponibles en el buffer de entrada del puerto serie.
HANDLE Open_Port (char COMx[])
 Abre el puerto de comunicaciones.
DCB Get_Configure_Port (HANDLE fd)
 Devuelve la configuración actual del Puerto serie.
DCB Configure_Port (HANDLE fd, unsigned int BaudRate, char CharParity[])
 Configura el puerto serie.
int Set_Configure_Port (HANDLE fd, DCB newtio)
 Coloca la configuración en el puerto serie a partir de una estructura DCB.
long Write_Port (HANDLE fd, char Data[], int SizeData)
 Escribe en el puerto serie.
long Read_Port (HANDLE fd, char *Data, int SizeData)
 Recibe datos en el puerto serie.
long Gets_Port (HANDLE fd, char *Data, int SizeData)
 Recibe datos en el puerto serie,lee hasta encontrar un 0x0A,0x0D (rellenando el siguiente byte con un cero - "solo si existe") o hasta completar SizeData caracteres.
long Getc_Port (HANDLE fd, char *Data)
 Recibe un caracter en el puerto serie.
int Close_Port (HANDLE fd)
 Cierra el puerto serie.
int Set_Hands_Haking (HANDLE fd, int FlowControl)
 Configura el control de flujo en el puerto serie.
int Set_RThreshold (HANDLE fd, int n)
 configura el numero mínimo de caracteres que permitirá que se ejecute la lectura del puerto
int Set_BaudRate (HANDLE fd, unsigned int BaudRate)
 Configura la velocidad puerto serie.
int Set_Time (HANDLE fd, unsigned int Time)
 Configura temporizador para la lectura y escritura en el puerto serie.
int IO_Blocking (HANDLE fd, int Modo)
 Configura si la lectura y escritura de datos se ejecutará en modo bloqueante.
int Clean_Buffer (HANDLE fd)
 Termina las operaciones de lectura y escritura pendientes y limpia las colas de recepción y de transmisión.

Variables

BOOL ERROR_CONFIGURE_PORT = FALSE

Documentación de las definiciones

#define BOOL   int

Definición en la línea 54 del archivo serielinux.h.

#define FALSE   0
#define HARD   1

Definición en la línea 60 del archivo serielinux.h.

#define INVALID_HANDLE_VALUE   -1

Definición en la línea 57 del archivo serielinux.h.

Referenciado por Close_Port(), y Open_Port().

#define NONE   0

Definición en la línea 58 del archivo serielinux.h.

#define RTSCTS   1

Definición en la línea 59 del archivo serielinux.h.

#define SOFT   2

Definición en la línea 62 del archivo serielinux.h.

#define TRUE   1
#define XONXOFF   2

Definición en la línea 61 del archivo serielinux.h.


Documentación de los tipos definidos

typedef struct termios DCB

Definición en la línea 66 del archivo serielinux.h.

typedef int HANDLE

Definición en la línea 67 del archivo serielinux.h.


Documentación de las funciones

int Clean_Buffer ( HANDLE  fd  ) 
Parámetros:
fd Es el manejador del puerto.
Devuelve:
TRUE si todo fue bien y FALSE si no lo fue.

Definición en la línea 597 del archivo serielinux.h.

Hace referencia a FALSE, y TRUE.

00598     {
00599         if(tcflush(fd, TCIOFLUSH)!=0)
00600         {
00601               printf("Error Limpiando el Buffer  de entrada y salida.\n");
00602               return FALSE;
00603         }
00604        return TRUE;
00605     }

int Close_Port ( HANDLE  fd  ) 
Parámetros:
fd Es el manejador del puerto.
Devuelve:
TRUE si se ha cerrado el Puerto y FALSE en el caso contrario.

Definición en la línea 413 del archivo serielinux.h.

Hace referencia a FALSE, INVALID_HANDLE_VALUE, y TRUE.

Referenciado por main().

00414     {
00415          if (fd != INVALID_HANDLE_VALUE)
00416          {  // Close the communication port.
00417                 // Ahora limpiamos el buffer de entrada y salida del puerto y activamos 
00418                 // la configuración del puerto.
00419                 //tcflush(fd, TCIOFLUSH);
00420             if (close(fd)!=0)
00421             {printf("Error cerrando el puerto serie\n");return FALSE;}
00422             else
00423             {fd = INVALID_HANDLE_VALUE;return TRUE;}
00424          }
00425          return FALSE;
00426     }

DCB Configure_Port ( HANDLE  fd,
unsigned int  BaudRate,
char  CharParity[] 
)
Parámetros:
fd Es el manejador del puerto.
BaudRate Es la velocidad en baudios del puerto.
CharParity Indica el número de bits en la transmisión y la paridad "8N1","8E1","7E1","7O1" y "7S1".
Devuelve:
Una estructura de tipo DCB con la configuración del puerto serie, además carga ERROR_CONFIGURE_PORT con FALSE, en caso de error carga ERROR_CONFIGURE_PORT con TRUE.

Definición en la línea 132 del archivo serielinux.h.

Hace referencia a ERROR_CONFIGURE_PORT, y TRUE.

Referenciado por main().

00133     {
00134         DCB newtio;
00135         bzero(&newtio, sizeof(newtio));    //limpiamos struct para recibir los
00136                                            //nuevos parámetros del puerto.
00137         //tcflush(fd, TCIOFLUSH);
00138 
00139         //CLOCAL  : conexion local, sin control de modem.
00140         //CREAD   : activa recepcion de caracteres.
00141         newtio.c_cflag =CLOCAL | CREAD ;
00142         
00143         cfsetispeed(&newtio,BaudRate);
00144         cfsetospeed(&newtio,BaudRate);
00145         
00146         if(strncmp(CharParity,"8N1",3)==0)      //CS8     : 8n1 (8bit,no paridad,1 bit de parada)
00147         {
00148                 newtio.c_cflag &= ~PARENB;
00149                 newtio.c_cflag &= ~CSTOPB;
00150                 newtio.c_cflag &= ~CSIZE;
00151                 newtio.c_cflag |= CS8;
00152         }
00153         if(strncmp(CharParity,"8E1",3)==0)
00154         {
00155                 newtio.c_cflag |=PARENB;
00156                 newtio.c_cflag &= ~PARODD;
00157                 newtio.c_cflag &= ~CSTOPB;
00158                 newtio.c_cflag &= ~CSIZE;
00159                 newtio.c_cflag |= CS8;
00160         }
00161         if(strncmp(CharParity,"7E1",3)==0)
00162         {
00163                 newtio.c_cflag |= PARENB;
00164                 newtio.c_cflag &= ~PARODD;
00165                 newtio.c_cflag &= ~CSTOPB;
00166                 newtio.c_cflag &= ~CSIZE;
00167                 newtio.c_cflag |= CS7;
00168         }
00169         if(strncmp(CharParity,"7O1",3)==0)
00170         {
00171                 newtio.c_cflag |= PARENB;
00172                 newtio.c_cflag |= PARODD;
00173                 newtio.c_cflag &= ~CSTOPB;
00174                 newtio.c_cflag &= ~CSIZE;
00175                 newtio.c_cflag |= CS7;
00176         }
00177         if(strncmp(CharParity,"7S1",3)==0)
00178         {
00179                 newtio.c_cflag &= ~PARENB;
00180                 newtio.c_cflag &= ~CSTOPB;
00181                 newtio.c_cflag &= ~CSIZE;
00182                 newtio.c_cflag |= CS8;
00183         }
00184 
00185         // IGNPAR  : ignora los bytes con error de paridad.
00186         // ICRNL   : mapea CR a NL (en otro caso una entrada CR del otro ordenador
00187         // no terminaría la entrada) en otro caso hace un dispositivo en bruto
00188         // (sin otro proceso de entrada).
00189         newtio.c_iflag = 0;
00190         //newtio.c_iflag = IGNPAR;
00191         //newtio.c_iflag |= ICRNL;
00192 
00193         //Salida en bruto.
00194         newtio.c_oflag = 0;
00195 
00196         //ICANON  : activa entrada canónica(Modo texto).
00197         //desactiva todas las funcionalidades del eco, y no envía señales al
00198         //programa llamador.
00199         //newtio.c_lflag = ICANON;
00200         newtio.c_lflag = 0;
00201 
00202         // inicializa todos los caracteres de control.
00203         // Los valores por defecto se pueden encontrar en /usr/include/termios.h,
00204         // y vienen dadas en los comentarios, pero no los necesitamos aquí.
00205 
00206         newtio.c_cc[VTIME]    = 0;     /* temporizador entre caracter, no usado */
00207         newtio.c_cc[VMIN]     = 1;     /* bloquea lectura hasta llegada de un caracter */
00208         
00209         if(tcsetattr(fd,TCSANOW,&newtio)!=0)
00210         {
00211                 printf("ERROR: No se pudo poner la configuración del puerto serie\n" );
00212                 ERROR_CONFIGURE_PORT=TRUE;
00213                 return newtio;
00214         }
00215 
00216         return newtio;
00217     }

DCB Get_Configure_Port ( HANDLE  fd  ) 
Parámetros:
fd Es el manejador del puerto.
Devuelve:
Una estructura de tipo DCB con la configuración actual del puerto serie, además carga ERROR_CONFIGURE_PORT con FALSE, en caso de error carga ERROR_CONFIGURE_PORT con TRUE.

Definición en la línea 108 del archivo serielinux.h.

Hace referencia a ERROR_CONFIGURE_PORT, FALSE, y TRUE.

Referenciado por main().

00109     {
00110         struct termios oldtio;
00111         if(tcgetattr(fd,&oldtio)!=0)  /* almacenamos la configuración actual del puerto */
00112         {
00113                 printf("Error pidiendo la configuración de puerto serie.\n");
00114                 ERROR_CONFIGURE_PORT=TRUE;
00115                 return oldtio;
00116         }
00117         ERROR_CONFIGURE_PORT=FALSE;
00118         return oldtio;
00119     }

Getc_Port ( HANDLE  fd,
char *  Data 
)
Parámetros:
fd Es el manejador del puerto.
Data Es el dato(8-bit) a mandar.
Devuelve:
En caso de éxito, se devuelve el número de bytes recibidos (cero indica que no se ha recibido nada). En GNU-LINUX en caso de error, se devuelve -1.

Definición en la línea 369 del archivo serielinux.h.

Referenciado por SERIAL_PORT_EVENT().

00370     {
00371         struct termios newtio;
00372         struct timeval inic,fin,temp;
00373         float tiempo,t;
00374 
00375         if(tcgetattr(fd,&newtio)!=0) return -1;
00376 
00377         gettimeofday(&inic,NULL);
00378         tiempo=(float)newtio.c_cc[VTIME];
00379         do
00380         {
00381                 gettimeofday(&fin,NULL);
00382                 temp.tv_sec=fin.tv_sec-inic.tv_sec;
00383                 temp.tv_usec=fin.tv_usec-inic.tv_usec ;
00384                 t=((temp.tv_usec/1000.0)+temp.tv_sec*1000.0)/100.0;
00385         }while( (t<tiempo) && (Kbhit_Port(fd)==0) );
00386 
00387         if( (Kbhit_Port(fd)!=0)||(tiempo==0) )  return read(fd,Data,1);
00388         else                                    return 0;
00389     }

long Gets_Port ( HANDLE  fd,
char *  Data,
int  SizeData 
)
Parámetros:
fd Es el manejador del puerto.
Data Es el vector donde se almacenarán los datos recibidos.
SizeData Es el tamaño máximo del vector.
Devuelve:
En caso de éxito, se devuelve el número de bytes recibidos (los números serán siempre mayores o iguales a cero).

Definición en la línea 326 del archivo serielinux.h.

Hace referencia a Kbhit_Port().

Referenciado por main().

00327     {
00328         struct termios newtio;
00329         long n=0,i=0;
00330         struct timeval inic,fin,temp;
00331         float tiempo,t;
00332 
00333         if(tcgetattr(fd,&newtio)!=0) return -1;
00334 
00335         for(i=0;i<SizeData;i++)
00336         {
00337                 gettimeofday(&inic,NULL);
00338                 tiempo=(float)newtio.c_cc[VTIME];
00339                 do
00340                 {
00341                         gettimeofday(&fin,NULL);
00342                         temp.tv_sec=fin.tv_sec-inic.tv_sec;
00343                         temp.tv_usec=fin.tv_usec-inic.tv_usec ;
00344                         t=((temp.tv_usec/1000.0)+temp.tv_sec*1000.0)/100.0;
00345                 }while( (t<tiempo) && (Kbhit_Port(fd)==0) );
00346 
00347                 Data[i]=0;
00348                 if( (Kbhit_Port(fd)!=0)||(tiempo==0) ) read(fd,&Data[i],1);
00349 
00350                 if( ((Data[i]==13)||(Data[i]==10)||(Data[i]==0))&&(i!=0) )
00351                 {
00352                         n=i+1;
00353                         if(n<SizeData) Data[n]=0;
00354                         i=SizeData;
00355                 }
00356         }
00357  
00358         return n;
00359     }

Gráfico de llamadas para esta función:

int IO_Blocking ( HANDLE  fd,
int  Modo 
)
Parámetros:
fd Es el manejador del puerto.
Modo Escoge el tipo de bloqueo.
TRUE : Modo bloqueante.
FALSE: Modo no bloqueante.
Devuelve:
TRUE si todo fue bien y FALSE si no lo fue.

Definición en la línea 560 del archivo serielinux.h.

Hace referencia a FALSE, y TRUE.

Referenciado por main().

00561     {
00562         struct termios newtio;
00563         /* almacenamos la configuracion actual del puerto */
00564         if(tcgetattr(fd,&newtio)!=0)
00565         {
00566                 printf("Error obteniendo configuración time-out actual\n");
00567                 return FALSE;
00568         }
00569         
00570         if(Modo==FALSE)
00571         {
00572                 newtio.c_cc[VTIME]    = 0;     /* Temporizador entre caracter.*/
00573                 newtio.c_cc[VMIN]     = 0;     /* No bloquea lectura hasta llegada de un caracter. */
00574         }
00575         if(Modo==TRUE)
00576         {
00577                 newtio.c_cc[VTIME]    = 0;     /* Temporizador entre caracter.*/
00578                 newtio.c_cc[VMIN]     = 1;     /* Bloquea lectura hasta llegada de un caracter. */
00579         }
00580         
00581         if(tcsetattr(fd, TCSANOW, &newtio)!=0)
00582         {
00583                 printf("Error estableciendo nueva configuración bloqueante/no-bloqueante.\n");
00584                 return FALSE;
00585         }
00586         
00587         return TRUE;    
00588     }

int Kbhit_Port ( HANDLE  fd  ) 
Parámetros:
fd Es el manejador del puerto.
Devuelve:
El número de caracteres en el buffer de entrada del puerto serie.

Definición en la línea 398 del archivo serielinux.h.

Referenciado por Gets_Port(), main(), y Read_Port().

00399     {
00400        int bytes;
00401        ioctl(fd, FIONREAD, &bytes);
00402        return bytes;
00403 
00404     }

HANDLE Open_Port ( char  COMx[]  ) 
Parámetros:
COMx Es el puerto a abrir.
En Gnu-Linux: "/dev/ttyS0","/dev/ttyS1","/dev/ttyACM0","/dev/ttyUSB0",...
En Windows: "COM1","COM2","COM3","COM4",...
Devuelve:
El manejador del puerto, en caso de error devuelve INVALID_HANDLE_VALUE.

Definición en la línea 83 del archivo serielinux.h.

Hace referencia a INVALID_HANDLE_VALUE.

Referenciado por main().

00084     {
00085         int fd; // File descriptor for the port.
00086 
00087         fd = open(COMx, O_RDWR | O_NOCTTY );//| O_NDELAY);
00088 
00089         if (fd <0)      
00090         {
00091                 printf("open_port:fd=%d: No se puede abrir %s\n",fd,COMx);
00092                 return INVALID_HANDLE_VALUE;
00093         }
00094         printf("open_port:fd=%d: Abierto puerto %s\n",fd,COMx);
00095         tcflush(fd, TCIOFLUSH);
00096         return (fd);
00097     }

long Read_Port ( HANDLE  fd,
char *  Data,
int  SizeData 
)
Parámetros:
fd Es el manejador del puerto.
Data Es el vector donde se almacenarán los datos recibidos.
SizeData Es el número de datos que se desea recibir, este número tiene que ser menor o igual que el tamaño del vector Data.
Devuelve:
En caso de éxito, se devuelve el número de bytes recibidos (cero indica que no se ha recibido nada). En GNU-LINUX en caso de error, se devuelve -1.

Definición en la línea 270 del archivo serielinux.h.

Hace referencia a Kbhit_Port().

Referenciado por main(), y SERIAL_PORT_EVENT().

00271     {
00272         struct termios newtio;
00273         struct timeval inic,fin,temp;
00274         float tiempo,t;
00275         int bytes;
00276         int ESTADO;
00277         int TEMPO;
00278 
00279         if(tcgetattr(fd,&newtio)!=0) return -1;
00280         else
00281         {
00282                 ESTADO=newtio.c_cc[VMIN];
00283                 TEMPO=newtio.c_cc[VTIME];
00284                 if( (ESTADO==0)&&(TEMPO==0) )
00285                 {
00286                         return read(fd,Data,SizeData);
00287                 }
00288                 else
00289                 {
00290                         if(TEMPO==0)
00291                         {
00292                                 do{ioctl(fd, FIONREAD, &bytes);}
00293                                 while(bytes<SizeData);
00294                                 return read(fd,Data,SizeData);
00295                         }
00296                         else
00297                         {
00298                                 gettimeofday(&inic,NULL);
00299                                 tiempo=newtio.c_cc[VTIME];
00300                                 do
00301                                 {
00302                                         gettimeofday(&fin,NULL);
00303                                         temp.tv_sec=fin.tv_sec-inic.tv_sec;
00304                                         temp.tv_usec=fin.tv_usec-inic.tv_usec ;
00305                                         t=((temp.tv_usec/1000.0)+temp.tv_sec*1000.0)/100.0;
00306                                 }while( (t<tiempo*SizeData) && (Kbhit_Port(fd)<SizeData) );
00307 
00308                                 if(Kbhit_Port(fd)!=0)   return read(fd,Data,SizeData);
00309                                 else                    return 0;
00310                         }
00311                 }
00312         }
00313     }

Gráfico de llamadas para esta función:

int Set_BaudRate ( HANDLE  fd,
unsigned int  BaudRate 
)
Parámetros:
fd Es el manejador del puerto.
BaudRate Es la velocidad en baudios del puerto.
Devuelve:
TRUE si todo fue bien y FALSE si no lo fue.

Definición en la línea 496 del archivo serielinux.h.

Hace referencia a FALSE, y TRUE.

00497     {
00498         struct termios newtio;
00499 
00500         if(tcgetattr(fd,&newtio)!=0)
00501         {
00502               printf("Error obteniendo configuración del puerto\n");
00503               return FALSE;
00504         }
00505         
00506         cfsetispeed(&newtio, BaudRate);
00507         cfsetospeed(&newtio, BaudRate);
00508         
00509         if(tcsetattr(fd, TCSANOW, &newtio)!=0)
00510         {
00511               printf("Error configurando el BaudRate\n");
00512               return FALSE;
00513         }
00514         
00515         return TRUE;    
00516     }

int Set_Configure_Port ( HANDLE  fd,
DCB  PortDCB 
)
Parámetros:
fd Es el manejador del puerto.
PortDCB Es la configuración del puerto.
Devuelve:
TRUE Si todo fue bien o FALSE si no lo fue.

Definición en la línea 227 del archivo serielinux.h.

Hace referencia a ERROR_CONFIGURE_PORT, FALSE, y TRUE.

Referenciado por main().

00228     {
00229         // ahora limpiamos el buffer de entrada y salida del modem y activamos 
00230         // la configuración del puerto
00231         //tcflush(fd, TCIOFLUSH);
00232         
00233         if(tcsetattr(fd,TCSANOW,&newtio)!=0)
00234         {
00235                 printf("ERROR: No se pudo poner configuración del puerto serie\n" );
00236                 ERROR_CONFIGURE_PORT=TRUE;
00237                 return FALSE;
00238         }
00239         ERROR_CONFIGURE_PORT=FALSE;
00240         
00241         return TRUE;
00242     }

int Set_Hands_Haking ( HANDLE  fd,
int  FlowControl 
)
Parámetros:
fd Es el manejador del puerto.
FlowControl 0 Ninguno
1 RTS/CTS
2 Xon/Xoff
3 DTR/DSR
Devuelve:
TRUE si todo fue bien y FALSE si no lo fue.

Definición en la línea 440 del archivo serielinux.h.

00441     {
00442         struct termios newtio;
00443         tcgetattr(fd,&newtio);  /* almacenamos la configuración actual del puerto */
00444         switch (FlowControl)
00445         {
00446                 case 0://NONE
00447                 {
00448                         newtio.c_cflag &= ~CRTSCTS;
00449                         newtio.c_iflag &= ~(IXON | IXOFF | IXANY);
00450                         newtio.c_cc[VSTART]   = 0;     /* Ctrl-q */
00451                         newtio.c_cc[VSTOP]    = 0;     /* Ctrl-s */
00452                         break;
00453                 }
00454                 case 1://RTS/CTS - HARD
00455                 {
00456                         newtio.c_cflag |= CRTSCTS;
00457                         newtio.c_iflag &= ~(IXON | IXOFF | IXANY);
00458                         newtio.c_cc[VSTART]   = 0;     /* Ctrl-q */
00459                         newtio.c_cc[VSTOP]    = 0;     /* Ctrl-s */
00460                         break;
00461                 }
00462                 case 2://XON/XOFF - SOFT
00463                 {
00464                         newtio.c_cflag &= ~CRTSCTS;
00465                         newtio.c_iflag |= (IXON | IXOFF );//| IXANY);
00466                         newtio.c_cc[VSTART]   = 17;     /* Ctrl-q */
00467                         newtio.c_cc[VSTOP]    = 19;     /* Ctrl-s */
00468                         break;
00469                 }
00470         }
00471         tcsetattr(fd, TCSANOW, &newtio);
00472         return 0;
00473     }

int Set_RThreshold ( HANDLE  fd,
int  n 
)
Parámetros:
fd Es el manejador del puerto.
n Es el numero de caracteres que activará la lectura.
Devuelve:
TRUE si todo fue bien y FALSE si no lo fue.

Definición en la línea 484 del archivo serielinux.h.

Hace referencia a TRUE.

00485     {
00486             return TRUE;
00487     }

int Set_Time ( HANDLE  fd,
unsigned int  Time 
)
Parámetros:
fd Es el manejador del puerto.
Time Tiempo (T) entre bits, T=Time*0.1s, para tamaño total de time-out en la lectura y escritura.
Timeout = (Time *0.1* number_of_bytes) seg
Devuelve:
TRUE si todo fue bien y FALSE si no lo fue.

Definición en la línea 528 del archivo serielinux.h.

Hace referencia a FALSE, y TRUE.

Referenciado por main().

00529     {
00530         struct termios newtio;
00531         /* almacenamos la configuracion actual del puerto */
00532         if(tcgetattr(fd,&newtio)!=0)
00533         {
00534               printf("Error obteniendo configuración time-out actual\n");
00535               return FALSE;
00536         }
00537         
00538         newtio.c_cc[VTIME]    = Time;/*temporizador entre caracter*/
00539         newtio.c_cc[VMIN]     = 1;   /*bloquea lectura hasta llegada de un
00540                                        caracter  */
00541         
00542         if(tcsetattr(fd, TCSANOW, &newtio)!=0)
00543         {
00544               printf("Error estableciendo nueva configuración time-out\n");
00545               return FALSE;
00546         }
00547         
00548             return TRUE;        
00549     }

long Write_Port ( HANDLE  fd,
char  Data[],
int  SizeData 
)
Parámetros:
fd Es el manejador del puerto.
Data Es el vector de datos a mandar.
SizeData es el tamaño del vector de datos.
Devuelve:
En caso de éxito, se devuelve el número de bytes escritos (cero indica que no se ha escrito nada). En GNU-LINUX en caso de error se devuelve -1.

Definición en la línea 254 del archivo serielinux.h.

Referenciado por main().

00255     {
00256         return  write(fd,Data,SizeData);
00257     }


Documentación de las variables

BOOL ERROR_CONFIGURE_PORT = FALSE

Definición en la línea 64 del archivo serielinux.h.

Referenciado por Configure_Port(), Get_Configure_Port(), Set_BaudRate(), Set_Configure_Port(), y Set_Hands_Haking().

Manual de referencia generado el Sat Feb 26 14:27:35 2011 para la biblioteca LnxComm usando  doxygen 1.6.3