Home | Blog | Develop | Download | Contact

Funciones para Windows

Definiciones

#define MAX_SIZE_BUFFER   8192
#define NONE   0
#define RTSCTS   1
#define HARD   1
#define XONXOFF   2
#define SOFT   2

Funciones

HANDLE Open_Port (char COMx[])
DCB Get_Configure_Port (HANDLE fd)
DCB Configure_Port (HANDLE fd, unsigned int BaudRate, char CharParity[])
int Set_Configure_Port (HANDLE fd, DCB PortDCB)
long Write_Port (HANDLE fd, char Data[], int SizeData)
long Read_Port (HANDLE fd, char *Data, int SizeData)
long Gets_Port (HANDLE fd, char *Data, int SizeData)
long Getc_Port (HANDLE fd, char *Data)
int Kbhit_Port (HANDLE fd)
int Close_Port (HANDLE fd)
int Set_Hands_Haking (HANDLE fd, int FlowControl)
int Set_RThreshold (HANDLE fd, int n)
int Set_BaudRate (HANDLE fd, unsigned int BaudRate)
int Set_Time (HANDLE fd, unsigned int Time)
int IO_Blocking (HANDLE fd, int Modo)
int Clean_Buffer (HANDLE fd)
int Setup_Buffer (HANDLE fd, unsigned long InQueue, unsigned long OutQueue)

Variables

BOOL ERROR_CONFIGURE_PORT = FALSE

Documentación de las definiciones

#define HARD   1

Definición en la línea 45 del archivo seriewindows.h.

#define MAX_SIZE_BUFFER   8192

Definición en la línea 41 del archivo seriewindows.h.

Referenciado por Configure_Port().

#define NONE   0

Definición en la línea 43 del archivo seriewindows.h.

#define RTSCTS   1

Definición en la línea 44 del archivo seriewindows.h.

#define SOFT   2

Definición en la línea 47 del archivo seriewindows.h.

#define XONXOFF   2

Definición en la línea 46 del archivo seriewindows.h.


Documentación de las funciones

int Clean_Buffer ( HANDLE  fd  ) 

Definición en la línea 457 del archivo seriewindows.h.

00458     {
00459        return PurgeComm( fd , PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR );
00460     }

int Close_Port ( HANDLE  fd  ) 

Definición en la línea 267 del archivo seriewindows.h.

Hace referencia a FALSE, INVALID_HANDLE_VALUE, y TRUE.

00268     {
00269          if (fd != INVALID_HANDLE_VALUE)
00270          {  // Close the communication port.
00271             
00272             // Liberar máscara de eventos del puerto serie:
00273             SetCommMask(fd, 0);
00274             
00275             if (!CloseHandle (fd))
00276             {printf("Error cerrando el puerto serie\n");return FALSE;}
00277             else
00278             {fd = INVALID_HANDLE_VALUE;return TRUE;}
00279          }
00280              return FALSE;
00281     }

DCB Configure_Port ( HANDLE  fd,
unsigned int  BaudRate,
char  CharParity[] 
)

Definición en la línea 87 del archivo seriewindows.h.

Hace referencia a ERROR_CONFIGURE_PORT, FALSE, MAX_SIZE_BUFFER, y TRUE.

00088     {
00089          DCB PortDCB;
00090          PortDCB.DCBlength = sizeof (DCB); 
00091          
00092          // Configuramos el tamaño del buffer de escritura/lectura
00093          if(!SetupComm(fd, MAX_SIZE_BUFFER, MAX_SIZE_BUFFER)) 
00094          {
00095                printf("Error configurando buffer\n");
00096                ERROR_CONFIGURE_PORT=TRUE;
00097                return PortDCB;
00098          }
00099 
00100          if(!GetCommState (fd, &PortDCB))
00101          {
00102                printf("Error Pidiendo configuración de Puerto\n");
00103                ERROR_CONFIGURE_PORT=TRUE;
00104                return PortDCB;
00105          }
00106 
00107          // Change the DCB structure settings.
00108          PortDCB.BaudRate = BaudRate;             // Current baud 
00109          PortDCB.fBinary = TRUE;                  // Binary mode; no EOF check 
00110          //PortDCB.EofChar = 0;
00111          PortDCB.fErrorChar = FALSE;              // Disable error replacement. 
00112          PortDCB.fNull = FALSE;                   // Disable null stripping. 
00113          PortDCB.fAbortOnError = FALSE;           // Do not abort reads/writes on error.
00114          PortDCB.fParity = FALSE;                 // Disable parity checking.
00115          
00116          PortDCB.fRtsControl = RTS_CONTROL_DISABLE; // RTS flow control   
00117          
00118          PortDCB.fDtrControl = DTR_CONTROL_DISABLE; // DTR flow control type        
00119 
00120          PortDCB.fOutxCtsFlow = FALSE;            // No CTS output flow control 
00121          PortDCB.fOutxDsrFlow = FALSE;            // No DSR output flow control
00122 
00123          PortDCB.fDsrSensitivity = FALSE;         // DSR sensitivity 
00124 
00125          PortDCB.fOutX = FALSE;                   // No XON/XOFF out flow control 
00126          PortDCB.fInX = FALSE;                    // No XON/XOFF in flow control 
00127          PortDCB.fTXContinueOnXoff = TRUE;        // XOFF continues Tx 
00128          
00129          if(strncmp(CharParity,"8N1",3)==0)
00130          {
00131          PortDCB.ByteSize = 8;                    // Number of bits/bytes, 4-8 
00132          PortDCB.Parity = NOPARITY;               // 0-4=no,odd,even,mark,space 
00133          PortDCB.StopBits = ONESTOPBIT;           // 0,1,2 = 1, 1.5, 2 
00134          }
00135          if(strncmp(CharParity,"7E1",3)==0)
00136          {
00137          PortDCB.ByteSize = 7;                    // Number of bits/bytes, 4-8 
00138          PortDCB.Parity = EVENPARITY;             // 0-4=no,odd,even,mark,space 
00139          PortDCB.StopBits = ONESTOPBIT;           // 0,1,2 = 1, 1.5, 2 
00140          }
00141          if(strncmp(CharParity,"7O1",3)==0)
00142          {
00143          PortDCB.ByteSize = 7;                    // Number of bits/bytes, 4-8 
00144          PortDCB.Parity = ODDPARITY;              // 0-4=no,odd,even,mark,space 
00145          PortDCB.StopBits = ONESTOPBIT;           // 0,1,2 = 1, 1.5, 2 
00146          }
00147          if(strncmp(CharParity,"7S1",3)==0)
00148          {
00149          PortDCB.ByteSize = 7;                    // Number of bits/bytes, 4-8 
00150          PortDCB.Parity = SPACEPARITY;            // 0-4=no,odd,even,mark,space 
00151          PortDCB.StopBits = ONESTOPBIT;           // 0,1,2 = 1, 1.5, 2 
00152          }   
00153          
00154          if (!SetCommState (fd, &PortDCB))
00155          {  // Could not configure the serial port.
00156             printf("Error: configurando puerto\n");
00157             ERROR_CONFIGURE_PORT=TRUE;
00158             return PortDCB;
00159          }
00160 
00161          // Configure timeouts 
00162          COMMTIMEOUTS timeouts;
00163          // No timeouts 
00164          timeouts.ReadIntervalTimeout = 0;
00165          timeouts.ReadTotalTimeoutMultiplier = 0;
00166          timeouts.ReadTotalTimeoutConstant = 0;
00167          timeouts.WriteTotalTimeoutMultiplier = 0;
00168          timeouts.WriteTotalTimeoutConstant = 0;
00169 
00170          if (!SetCommTimeouts(fd, &timeouts)) 
00171          {
00172                 printf("ERROR: No se pudo poner SetCommTimeouts: %s\n", 
00173                                                                GetLastError());
00174             ERROR_CONFIGURE_PORT=TRUE;
00175             return PortDCB;
00176          }
00177 
00178 
00179          ERROR_CONFIGURE_PORT=FALSE;
00180              return PortDCB;
00181     }

DCB Get_Configure_Port ( HANDLE  fd  ) 

Definición en la línea 71 del archivo seriewindows.h.

Hace referencia a ERROR_CONFIGURE_PORT, FALSE, y TRUE.

00072     {
00073          DCB PortDCB;
00074          PortDCB.DCBlength = sizeof (DCB);     
00075          
00076          if(!GetCommState (fd, &PortDCB))
00077          {
00078                printf("Error pidiendo la configuración de puerto serie.\n");
00079                ERROR_CONFIGURE_PORT=TRUE; 
00080                return PortDCB;        
00081          }
00082          ERROR_CONFIGURE_PORT=FALSE;
00083          return PortDCB;
00084     }

long Getc_Port ( HANDLE  fd,
char *  Data 
)

Definición en la línea 245 del archivo seriewindows.h.

00246     {
00247          long n;
00248 
00249          ReadFile(fd,Data,(DWORD)1,(DWORD*)(&n),NULL);
00250         
00251          return n;
00252     }

long Gets_Port ( HANDLE  fd,
char *  Data,
int  SizeData 
)

Definición en la línea 226 del archivo seriewindows.h.

00227     {
00228          long n=0,i=0;
00229 
00230          for(i=0;i<SizeData;i++)
00231          {
00232                ReadFile(fd,&Data[i],(DWORD)1,(DWORD*)(&n),NULL);
00233                if(((Data[i]==13)||(Data[i]==10)||(Data[i]==0))&&(i!=0))
00234                {
00235                 n=i+1;
00236                 if(n<SizeData) Data[n]=0;
00237                 i=SizeData;
00238                }
00239          }
00240          
00241          return n;
00242     }

int IO_Blocking ( HANDLE  fd,
int  Modo 
)

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

Hace referencia a FALSE, y TRUE.

00414     {
00415         COMMTIMEOUTS CommTimeouts;
00416 
00417         if(!GetCommTimeouts (fd, &CommTimeouts))
00418         {
00419               printf("Error obteniendo configuracion time-out actual: %s\n", 
00420                                                               GetLastError());
00421               return FALSE;
00422         }
00423         
00424         // Especifica que la operación de lectura debe regresar inmediatamente 
00425         // con los caracteres que ya se hayan recibido, incluso aunque no se 
00426         // haya recibido ninguno.
00427         if(Modo==FALSE)// No bloqueante
00428         {
00429          CommTimeouts.ReadIntervalTimeout = MAXDWORD;
00430          CommTimeouts.ReadTotalTimeoutMultiplier = 0;
00431          CommTimeouts.ReadTotalTimeoutConstant = 0;
00432          CommTimeouts.WriteTotalTimeoutMultiplier = 0;
00433          CommTimeouts.WriteTotalTimeoutConstant = 0;
00434         }
00435         // indica que el tiempo total de time-out no se usa para operaciones de
00436         // lectura/escritura.
00437         if(Modo==TRUE)// Bloqueante.
00438         {
00439          CommTimeouts.ReadIntervalTimeout = 0;
00440          CommTimeouts.ReadTotalTimeoutMultiplier = 0;
00441          CommTimeouts.ReadTotalTimeoutConstant = 0;
00442          CommTimeouts.WriteTotalTimeoutMultiplier = 0;
00443          CommTimeouts.WriteTotalTimeoutConstant = 0;
00444         }
00445 
00446         if(!SetCommTimeouts (fd, &CommTimeouts)) 
00447         {
00448               printf("Error estableciendo nueva configuración bloqueante/no-bloqueante: %s\n", 
00449                                                               GetLastError());
00450               return FALSE;
00451         }
00452 
00453         return TRUE;
00454     }

int Kbhit_Port ( HANDLE  fd  ) 

Definición en la línea 255 del archivo seriewindows.h.

00256     {
00257         DWORD x;
00258         COMSTAT cs;
00259         // Actualizar COMSTAT, sirve para averiguar el número de bytes en el 
00260         // buffer de entrada:
00261         ClearCommError(fd, &x, &cs);
00262         return cs.cbInQue;
00263     }

HANDLE Open_Port ( char  COMx[]  ) 

Definición en la línea 51 del archivo seriewindows.h.

Hace referencia a INVALID_HANDLE_VALUE.

00052     {
00053          HANDLE fd;
00054          fd = CreateFile( COMx,                    // pointer to name of the file 
00055                      GENERIC_READ | GENERIC_WRITE, // access (read-write) mode 
00056                      0,                            // share mode 
00057                      NULL,                         // pointer to security attributes 
00058                      OPEN_EXISTING,                // how to create
00059                      0,                            // file attributes
00060                      NULL);                        // handle to file with attributes
00061                                                    // to copy 
00062 
00063          if (fd == INVALID_HANDLE_VALUE) 
00064          {
00065               printf("Error:No se puede abrir puerto: %s \n",COMx); 
00066               return INVALID_HANDLE_VALUE;
00067          } 
00068          return (fd);
00069     }

long Read_Port ( HANDLE  fd,
char *  Data,
int  SizeData 
)

Definición en la línea 213 del archivo seriewindows.h.

00214     {
00215          long n;
00216 
00217          ReadFile (fd,                // Port handle
00218                    Data,              // Pointer to the data to write 
00219                    (DWORD)SizeData,   // Number of bytes to write
00220                    (DWORD*)(&n),      // Pointer to the number of bytes read
00221                    NULL);             // Must be NULL for Windows CE
00222          return n;
00223     }

int Set_BaudRate ( HANDLE  fd,
unsigned int  BaudRate 
)

Definición en la línea 348 del archivo seriewindows.h.

Hace referencia a ERROR_CONFIGURE_PORT, FALSE, y TRUE.

00349     {
00350         DCB PortDCB;
00351 
00352         if(!GetCommState (fd, &PortDCB))
00353          {
00354                printf("Error Pidiendo configuración del Puerto\n");
00355                ERROR_CONFIGURE_PORT=TRUE;
00356                return FALSE;
00357          }
00358          
00359         PortDCB.BaudRate = BaudRate;                // Binary mode; no EOF check 
00360 
00361         if (!SetCommState (fd, &PortDCB))
00362         {
00363               printf("Error configurando el BaudRate\n");
00364               ERROR_CONFIGURE_PORT=TRUE;
00365               return FALSE;
00366         }
00367         ERROR_CONFIGURE_PORT=FALSE;
00368 
00369             return TRUE;
00370     }

int Set_Configure_Port ( HANDLE  fd,
DCB  PortDCB 
)

Definición en la línea 184 del archivo seriewindows.h.

Hace referencia a ERROR_CONFIGURE_PORT, FALSE, y TRUE.

00185     {
00186          // Ahora limpiamos el buffer de entrada y salida del puerto 
00187          // y activamos la configuración del puerto.
00188          if (!SetCommState (fd, &PortDCB))
00189          {
00190             printf("ERROR: No se pudo poner configuración del puerto serie\n" );
00191             ERROR_CONFIGURE_PORT=TRUE;
00192             return FALSE;
00193          }
00194          ERROR_CONFIGURE_PORT=FALSE;
00195 
00196              return TRUE;
00197     }    

int Set_Hands_Haking ( HANDLE  fd,
int  FlowControl 
)

NONE

RTS/CTS

XON/OFF

DTR/DSR

Definición en la línea 285 del archivo seriewindows.h.

Hace referencia a ERROR_CONFIGURE_PORT, FALSE, y TRUE.

00286     {
00287         DCB PortDCB;
00288         if(!GetCommState (fd, &PortDCB))
00289          {
00290                printf("Error Pidiendo configuración de puerto serie\n");
00291                ERROR_CONFIGURE_PORT=TRUE;
00292                return FALSE;
00293          }
00294         
00295         switch(FlowControl)
00296         {
00297          case 0: 
00298               {
00299               PortDCB.fOutX = FALSE;                      // No XON/XOFF out flow control. 
00300               PortDCB.fInX = FALSE;                       // No XON/XOFF in flow control.
00301               
00302               PortDCB.fRtsControl = RTS_CONTROL_ENABLE;   // RTS flow control.  
00303                
00304               PortDCB.fDtrControl = DTR_CONTROL_ENABLE;   // DTR flow control type.
00305               break;
00306               }
00307          case 1: 
00308               {
00309               PortDCB.fRtsControl = RTS_CONTROL_HANDSHAKE;// RTS flow control.  
00310               break;
00311               }
00312          case 2: 
00313               {
00314               PortDCB.fOutX = TRUE;                       // XON/XOFF out flow control. 
00315               PortDCB.fInX = TRUE;                        // XON/XOFF in flow control.  
00316               PortDCB.XonChar=0x11;                       // ASCII_XON.
00317               PortDCB.XoffChar=0x13;                      // ASCII_XOFF.
00318               PortDCB.XonLim=100;
00319               PortDCB.XoffLim=100;
00320               break;
00321               }
00322          case 3: 
00323               {
00324               PortDCB.fDtrControl = DTR_CONTROL_HANDSHAKE;// DTR flow control type.
00325               break;
00326               }
00327         }
00328         
00329         if (!SetCommState (fd, &PortDCB))
00330         {
00331               printf("ERROR: Configurando el puerto serie\n");
00332               ERROR_CONFIGURE_PORT=TRUE;
00333               return FALSE;
00334         }
00335         ERROR_CONFIGURE_PORT=FALSE;
00336 
00337             return TRUE;
00338     }

int Set_RThreshold ( HANDLE  fd,
int  n 
)

Definición en la línea 342 del archivo seriewindows.h.

Hace referencia a TRUE.

00343     {
00344             return TRUE;
00345     }

int Set_Time ( HANDLE  fd,
unsigned int  Time 
)

Definición en la línea 373 del archivo seriewindows.h.

Hace referencia a FALSE, y TRUE.

00374     {
00375         COMMTIMEOUTS CommTimeouts;
00376 
00377         if(!GetCommTimeouts (fd, &CommTimeouts))
00378         {
00379               printf("Error obteniendo configuración time-out actual: %s\n", 
00380                                                               GetLastError());
00381               return FALSE;
00382         }
00383 
00384         // Tiempo maximo en mseg. entre caracteres consecutivos
00385         CommTimeouts.ReadIntervalTimeout = Time*200;
00386 
00387         // Time-Out=TotalTimeoutMultiplier*number_of_bytes+TotalTimeoutConstant
00388 
00389         // Especifique el multiplicador de tiempo fuera de lectura con el miembro 
00390         // ReadTotalTimeoutMultiplier. En cada operación de lectura , este número 
00391         // se multiplica por el número de bytes que la lectura espera recibir .
00392         CommTimeouts.ReadTotalTimeoutMultiplier = Time*100;
00393         // Constante a sumar al time-out total de recepción.
00394         CommTimeouts.ReadTotalTimeoutConstant = 0;
00395 
00396         // Igual que lectura.
00397         CommTimeouts.WriteTotalTimeoutMultiplier = Time*100;
00398         // Igual que lectura
00399         CommTimeouts.WriteTotalTimeoutConstant = 0;
00400 
00401         // Establecemos nuevos valores de time-out.
00402         if(!SetCommTimeouts (fd, &CommTimeouts)) 
00403         {
00404               printf("Error estableciendo nueva configuración time-out: %s\n", 
00405                                                               GetLastError());
00406               return FALSE;
00407         }
00408 
00409         return TRUE;
00410     }

int Setup_Buffer ( HANDLE  fd,
unsigned long  InQueue,
unsigned long  OutQueue 
)

Definición en la línea 463 del archivo seriewindows.h.

00464     {
00465        return SetupComm(fd,InQueue,OutQueue);
00466     }

long Write_Port ( HANDLE  fd,
char  Data[],
int  SizeData 
)

Definición en la línea 200 del archivo seriewindows.h.

00201     {
00202          long n;
00203 
00204          WriteFile(fd,                // Port handle
00205                    Data,              // Pointer to the data to write 
00206                    (DWORD)SizeData,   // Number of bytes to write
00207                    (DWORD*)&n,        // Pointer to the number of bytes written
00208                    NULL);             // Must be NULL for Windows CE
00209          return n;
00210     }


Documentación de las variables

BOOL ERROR_CONFIGURE_PORT = FALSE

Definición en la línea 49 del archivo seriewindows.h.

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