[code]#ifndef VPRINCIPAL_H
#define VPRINCIPAL_H

#include <stdint.h>
#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <stdint.h>
#include <iostream>
#include <sstream>
#include <string>
#include <fstream>
#include <cstring>
#include <ctime>
#include <wx/timer.h>
#include <wx/datetime.h>
#include <wx/menu.h>
#include <wx/wx.h>
#include <wx/app.h>
#include <wx/msgdlg.h>

#include "Ventanas.h"

using namespace std;

class VPrincipal:public VentanaPrincipal{
private:
	
	//void comenzar_tiempo(wxTimerEvent&);
protected:
	
public:
	VPrincipal(wxWindow *parent);
	//void OnBotonCerrar(wxEvent &evt);
	
	HANDLE OpenSerialPort(	char *psPort, 		// "COM1","COM2"
		DWORD bBaudRate, 	// CBR_9600, CBR_19200. CBR_56000
		BYTE bByteSize, 	// 7,8
		BYTE bParity, 		// NOPARITY, EVENPARITY, ODDPARITY
		BYTE bStopBits,		// ONESTOPBIT, ONE5STOPBITS, TWOSTOPBITS
		DWORD ReadTimeout   // Programmable Read Timeout
		);
	
	// Send a byte				 
	BOOL SerialSendByte(HANDLE hPort, BYTE byte);
	// return TRUE: Send OK
	
	// Receive a byte
	BOOL SerialReceiveByte(HANDLE hPort, BYTE *pbyte, BOOL *pTimeout);
	// return TRUE & *pTimeout TRUE Send OK
	// return TRUE & *pTimeout FALSE Timeout
	// return FALSE Receive Error
	
	// Close Serial Port
	BOOL CloseSerialPort(HANDLE hPort);
};

#endif

//////////////////////////////////////////////////////////////////////////////

#include "VPrincipal.h"

VPrincipal::VPrincipal(wxWindow* parent):VentanaPrincipal(parent){

	
	Show();
	
	HANDLE hPort;
	BOOL bRes;
	BYTE byte;
	BOOL timeout;
	
	string muestra="espera";
	
	hPort=serieOpenSerialPort("COM1",CBR_9600,8,NOPARITY,ONESTOPBIT,1000);
	
	if (hPort==INVALID_HANDLE_VALUE)
	{
	wxMessageBox("Error abriendo puerto com1");
	//return 1;
	}
	
	while(1){
	
	bRes=SerialReceiveByte(hPort,&byte,&timeout);
	
	if (!bRes)
	{
	break;
	}
		
	if (timeout)
	{
	m_textCtrl1->Clear();
	m_textCtrl1->SetValue("espera");
	//i++;
	} 
		
	else
	{
	putchar(byte);
	}
	
	}
	
	
	if (!bRes) 
	{
	wxMessageBox("Error leyendo de puerto com1");
	//return 1;
	}
	
	CloseSerialPort(hPort);

}
	

HANDLE VPrincipal::OpenSerialPort(char *psPort, 		// "COM1","COM2"
	DWORD dwBaudRate, 	// CBR_9600, CBR_19200. CBR_56000
	BYTE bByteSize,		// 7,8
	BYTE bParity, 		// NOPARITY, EVENPARITY, ODDPARITY
	BYTE bStopBits,		// ONESTOPBIT, ONE5STOPBITS, TWOSTOPBITS
	DWORD Timeout       // Timeout
	) {
		
		HANDLE hPort;								// port handler
		DCB dcbPort;								// Port configuration
		COMMTIMEOUTS commTimeouts;					// Port Timeouts
		DWORD dwError;								// Error code
		
		// Open Serial Port
		hPort=CreateFile(
			psPort,							// pointer to name of the file 
			GENERIC_READ | GENERIC_WRITE,	// access (read-write) mode 
			0,								// share mode: 0 the object cannot be share 
			NULL,							// pointer to security attributes: NULL the handle cannot be inherited 
			OPEN_EXISTING,					// how to create: Comx exist 
			0,								// file/port attributes 
			NULL); 							// handle to file/port with attributes to copy  
		
		// If the function fails, the return value 
		//is INVALID_HANDLE_VALUE
		if ( hPort == INVALID_HANDLE_VALUE ) {
			dwError = GetLastError (); 				// Flush error code
			return hPort;
		}
		
		// Set Port Configuration
		
		// Delete DCB configuration
		FillMemory(&dcbPort, sizeof(dcbPort), 0);
		dcbPort.DCBlength = sizeof(dcbPort);
		
		// Current DCB in use for the communications port
		GetCommState (hPort, &dcbPort);
		
		// Update DCB with new parameters
		dcbPort.BaudRate = dwBaudRate;         		
		dcbPort.ByteSize = bByteSize;                
		dcbPort.Parity = bParity;            		
		dcbPort.StopBits = bStopBits;        		
		
		// Fixed parameters (Disable XON-XOFF and modem handshake)
		dcbPort.fBinary = TRUE;               		// Binary mode; no EOF check 
		dcbPort.fParity = TRUE;               		// Enable parity checking 
		dcbPort.fOutxCtsFlow = FALSE;         		// No CTS output flow control 
		dcbPort.fOutxDsrFlow = FALSE;         		// No DSR output flow control 
		dcbPort.fDtrControl = DTR_CONTROL_ENABLE; 
		// DTR flow control type 
		// Raises the DTR line when the device is opened
		dcbPort.fDsrSensitivity = FALSE;      		// DSR sensitivity 
		dcbPort.fTXContinueOnXoff = TRUE;     		// XOFF continues Tx 
		dcbPort.fOutX = FALSE;                		// No XON/XOFF out flow control 
		dcbPort.fInX = FALSE;                 		// No XON/XOFF in flow control 
		dcbPort.fErrorChar = FALSE;           		// Disable error replacement 
		dcbPort.fNull = FALSE;                		// Disable null stripping 
		dcbPort.fRtsControl = RTS_CONTROL_ENABLE; 
		// RTS flow control 
		// Raises the RTS line when the device is opened
		dcbPort.fAbortOnError = FALSE;        		// Do not abort reads/writes on 
		// error
		// Set new configuration
		if (!SetCommState (hPort, &dcbPort)) {
			dwError = GetLastError (); 				// Flush error code
			CloseSerialPort(hPort);
			hPort = INVALID_HANDLE_VALUE;
			return hPort;
		}
		
		// Set Port Timeouts
		// Timeouts preparation  MORE INFORMATION IN WIN32 API: COMMTIMEOUTS 
		commTimeouts.ReadIntervalTimeout = 0;  			// Specifies the maximum time, in milliseconds, allowed to elapse between the arrival
		// of two characters on the communications line
		// A value of zero indicates that interval time-outs are not used.
		commTimeouts.ReadTotalTimeoutMultiplier = 50;   // Specifies the multiplier, in milliseconds, used to calculate 
		// the total time-out period for read operations. 
		// For each read operation, this value is multiplied
		// by the requested number of bytes to be read.
		commTimeouts.ReadTotalTimeoutConstant = Timeout;// Specifies the constant, in milliseconds, used to calculate the total 
		// time-out period for read operations
		// 
		commTimeouts.WriteTotalTimeoutMultiplier = 10;  // Specifies the multiplier, in milliseconds, used to calculate the 
		// total time-out period for write operations. 
		// For each write operation, this value is multiplied
		// by the number of bytes to be written.
		commTimeouts.WriteTotalTimeoutConstant = 1000;  // Specifies the constant, in milliseconds, used to calculate the total time-out period
		// for write operations
		// See de win32 api for more information
		// Set Timeouts
		if (!SetCommTimeouts (hPort, &commTimeouts)) {
			dwError = GetLastError (); 					// Flush error code
			CloseSerialPort(hPort);
			hPort = INVALID_HANDLE_VALUE;
			return hPort;
		}
		return hPort;
	}

BOOL VPrincipal::SerialSendByte(HANDLE hPort, BYTE byte){
	BOOL bRes;
	DWORD dwError, dwNumBytesWritten=0;
	
	bRes=WriteFile(
		hPort,							// handle to file or serial port to write to 
		&byte,							// pointer to data to write to file 
		1,								// number of bytes to write 
		&dwNumBytesWritten,				// pointer to number of bytes written 
		NULL							// NULL
		);
	
	
	if ((!bRes)||(dwNumBytesWritten!=1)){
		dwError = GetLastError ();		// Flush error code
	}
	return bRes;
}

BOOL VPrincipal::SerialReceiveByte(HANDLE hPort, BYTE *pbyte, BOOL *pTimeout){
	BOOL bRes;
	DWORD dwError, lpNumberOfBytesRead=0;
	
	*pTimeout=FALSE;
	bRes=ReadFile(	hPort,							// handle of file or serial port to read 
		pbyte,							// address of buffer that receives data  
		1,								// number of bytes to read 
		&lpNumberOfBytesRead,			// address of number of bytes read 
		NULL 							// NULL  
		);
	
	if (!bRes) {
		dwError = GetLastError ();		// Flush error code
	}
	if ((bRes)&&(lpNumberOfBytesRead==0)){
		*pTimeout = TRUE;				
	}
	return bRes;
}	



BOOL VPrincipal::CloseSerialPort(HANDLE hPort){
	BOOL bRes;
	DWORD dwError;
	
	bRes=CloseHandle(hPort);
	if (!bRes) {
		dwError = GetLastError (); 				// Flush error code
	}
	return bRes;
}

hPort=OpenSerialPort("COM1",{1200, 2400, 4800, 9600},7,NOPARITY,ONESTOPBIT,5000);

[code]printf("%.2x",byte);

C°xxCx°    Cx°Cx   xxx°   xCx      x°xC     C    C    C    C    C   C

C°

C°xxCx°

C°xxCx°     Cx°Cx   xxx°   xCx      x°xC     C    C    C    C    C   C

C°xxCx°     Cx°Cx      xxx°     xCx      x°xC     C    C   C   °C   °CC   °C