Club Builder - Foros de discusión Club Builder
Foro de C++Builder en español
 
 FAQFAQ   BuscarBuscar   MiembrosMiembros   Grupos de UsuariosGrupos de Usuarios   RegistrarseRegistrarse 
 PerfilPerfil   Entra para ver tus mensajes privadosEntra para ver tus mensajes privados   EntrarEntrar 

API_2

 
Publicar nuevo tema   Responder al tema    Foros de discusión -> Consultas
Ver tema anterior :: Ver tema siguiente  
Autor Mensaje
Mensaje    Asunto: API_2 Responder citando

Hola todos.
Viendo que alguien preguntó sobre las API aprovecho para exponer mi duda.
En la siguiente función he intentado sin éxito otro parametro de
velocidad, para esto he definido una variable int baudios que toma
distintos valóres dependiendo de la selección del usuario.
Pero no funciona y francamente NO ENTIENDO COMO DEBO HACERLO.

NO funciona
BuildCommDCB("Com4:baudios,N,8,1", &dcb);
Si funciona
BuildCommDCB("Com4:1200,N,8,1", &dcb);

Gracias
Verónica Arrechea

Volver arriba
Mensaje    Asunto: API_2 Responder citando

Hola..

ahhh...yaaa

Ves las comillas?
Estas comillas significan que lo que encierran es una cadena de caracteres, y que posteriormente la función o método de la API que la utiliza la interpretará posteriormente para aplicar.

Ahora...
Creo que baudios es una variable.. y en efecto tú le habrás puesto algún valor....
Pero en el contexto de BuildCommDCB no es más que un pedazo de la cadena de caracteres que al tratar de interpretar lanza algún error o excepción.

Sugerencia:
Utiliza algún DCB (buscar en la API) para configurar las opciones y posteriormente SetCommState para efectivamente colocarlo.

Ejemplo: (como yo lo uso...las librerias incluidas son mias.. no de la API...)

//---------------------------------------------------------------------------
#include <vcl.h>
#include <stdio.h>

#pragma hdrstop
//---------------------------------------------------------------------------
#include "CommPort.h"
#include "Principal.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------

static int DefaultBaudRate = 6;
static int DefaultParityBit = 0;
static int DefaultDataBits = 4;
static int DefaultFlowControl = 1;
static int DefaultStopBit = 0;
static int DefaultSerialPort = 0;
static int ActuallyBaudRate = DefaultBaudRate;
static int ActuallyParityBit = DefaultParityBit;
static int ActuallyDataBits = DefaultDataBits;
static int ActuallyFlowControl = DefaultFlowControl;
static int ActuallyStopBit = DefaultStopBit;
static int ActuallySerialPort = DefaultSerialPort;
static int CommPortSelected;
static DWORD BaudRateSelected;
#define COLARX 4096
#define COLATX 4096
//---------------------------------------------------------------------------
TComm::TComm()
{
}
//---------------------------------------------------------------------------
bool TComm::OpenPort()
{
DWORD OldCommMask;

if(EstablishedConnection)
return EstablishedConnection;
EstablishedConnection = false;
char szPuerto[10];
bool Success = false;
sprintf(szPuerto, "COM%d", ActuallySerialPort+1); // Formar "COM" más número
CommPortSelected = ActuallySerialPort+1;
if (MyFileHandle) CloseHandle(MyFileHandle); // Cerrar puerto por si está abierto
MyFileHandle = CreateFile(szPuerto, // Abrir el puerto de comunicaciones
GENERIC_READ | GENERIC_WRITE,
0, // acceso exclusivo
NULL, // sin atributos de seguridad
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL);

if(MyFileHandle == INVALID_HANDLE_VALUE)
{
ShowMessage("Port Not Opened");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);return false;
}

GetCommMask(MyFileHandle,&OldCommMask);
// Especificar eventos que se atenderán
if(!SetCommMask( MyFileHandle, EV_RXCHAR | EV_TXEMPTY | EV_RX80FULL | EV_ERR))
{
ShowMessage("SetCommMask Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);
CloseHandle(MyFileHandle);return false;
}
// Establecer tamaño de colas de recepción y de transmisión
if(!SetupComm(MyFileHandle, COLARX, COLATX))
{
ShowMessage("SetupComm Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);
CloseHandle(MyFileHandle);return false;
}
// Terminar operaciones de lectura y escritura pendientes y limpiar las colas Rx y Tx
if(!PurgeComm( MyFileHandle, PURGE_TXABORT | PURGE_RXABORT |PURGE_TXCLEAR | PURGE_RXCLEAR ))
{
ShowMessage("PurgeComm Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);
CloseHandle(MyFileHandle);return false;
}
// Establecer los parámetros de la comunicación
Success = MyConfigureCommunication();
if (Success)
{
EstablishedConnection = true;
MessageBeep(MB_ICONEXCLAMATION);
Sleep(100);
MessageBeep(MB_OK );
EscapeCommFunction(MyFileHandle, SETDTR); // Enviar señal DTR (data-terminal-ready).
}
else
{
EstablishedConnection = false;
CloseHandle(MyFileHandle);
}
return EstablishedConnection;
}
//---------------------------------------------------------------------------
bool TComm::ClosePort()
{
if(!EstablishedConnection) // if already closed, return
return !EstablishedConnection;
if(CloseHandle(MyFileHandle) != 0) // CloseHandle is non-zero on success
{
MessageBeep(MB_ICONEXCLAMATION);
Sleep(100);
MessageBeep(MB_OK );
EstablishedConnection = false;
}
else
{
ShowMessage("Port Not Closed");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);
}
return !EstablishedConnection;
}
//---------------------------------------------------------------------------
bool TComm::MyConfigureCommunication(void)
{
BaudRateTable[0] = CBR_110;
BaudRateTable[1] = CBR_300;
BaudRateTable[2] = CBR_600;
BaudRateTable[3] = CBR_1200;
BaudRateTable[4] = CBR_2400;
BaudRateTable[5] = CBR_4800;
BaudRateTable[6] = CBR_9600;
BaudRateTable[7] = CBR_14400;
BaudRateTable[8] = CBR_19200;
BaudRateTable[9] = CBR_38400;
BaudRateTable[10] = CBR_56000;
BaudRateTable[11] = CBR_128000;
BaudRateTable[12] = CBR_256000;
ParityTable[0] = NOPARITY;
ParityTable[1] = EVENPARITY;
ParityTable[2] = ODDPARITY;
ParityTable[3] = MARKPARITY;
ParityTable[4] = SPACEPARITY;
StopBitTable[0] = ONESTOPBIT;
StopBitTable[1] = ONE5STOPBITS;
StopBitTable[2] = TWOSTOPBITS;

BYTE Establishing;
DCB DcbNew;//,DcbOld;
DcbNew.DCBlength = sizeof(DCB);

if(!GetCommState(MyFileHandle, &DcbNew)) // Obtener propiedades DCB de puerto recien abierto
{ MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);return false; }

DcbNew.BaudRate = BaudRateTable[ActuallyBaudRate];
BaudRateSelected = DcbNew.BaudRate;
DcbNew.Parity = ParityTable[ActuallyParityBit];
DcbNew.ByteSize = (BYTE)(ActuallyDataBits + 4);
DcbNew.StopBits = StopBitTable[ActuallyStopBit];
// Establecer el control de flujo software
Establishing = (BYTE)(ActuallyFlowControl == 1); // Xon/Xoff
DcbNew.fInX = DcbNew.fOutX = Establishing;
DcbNew.XonChar = 0x11; // ASCII_XON
DcbNew.XoffChar = 0x13; // ASCII_XOFF
DcbNew.XonLim = 100;
DcbNew.XoffLim = 100;
// Establecer el control de flujo hardware
Establishing = (BYTE)(ActuallyFlowControl == 2); // DTR/DSR
DcbNew.fOutxDsrFlow = Establishing;
if (Establishing)
DcbNew.fDtrControl = DTR_CONTROL_HANDSHAKE;
else
DcbNew.fDtrControl = DTR_CONTROL_ENABLE;

Establishing = (BYTE)(ActuallyFlowControl == 3); // RTS/CTS
DcbNew.fOutxCtsFlow = Establishing;
if (Establishing)
DcbNew.fRtsControl = RTS_CONTROL_HANDSHAKE;
else
DcbNew.fRtsControl = RTS_CONTROL_ENABLE;

DcbNew.fBinary = true; // Otras especificaciones
DcbNew.fParity = true;

if(!SetCommState(MyFileHandle, &DcbNew)) //Disponer propiedades puerto según especificaciones
{
ShowMessage("SetupCommState Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);return false;
}

COMMTIMEOUTS CommTimeOuts; // Establecer tiempos límites para operaciones de E/S
CommTimeOuts.ReadIntervalTimeout = MAXDWORD;
CommTimeOuts.ReadTotalTimeoutMultiplier = 0;
CommTimeOuts.ReadTotalTimeoutConstant = 1000;
CommTimeOuts.WriteTotalTimeoutMultiplier = 2*CBR_9600/DcbNew.BaudRate;
CommTimeOuts.WriteTotalTimeoutConstant = 0;
if(!SetCommTimeouts(MyFileHandle, &CommTimeOuts))
{
ShowMessage("SetupCommTimeouts Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);return false;
} return true;
}
//---------------------------------------------------------------------------
DWORD TComm::GetCommBaudRate()
{ return BaudRateSelected;}
//---------------------------------------------------------------------------
int TComm::GetCommPort()
{ return CommPortSelected;}
//---------------------------------------------------------------------------
void TComm::MyErrorMessage( DWORD nError )
{
MessageBeep(0xFFFFFFFF);
Sleep(10);
MessageBeep(0xFFFFFFFF);
Sleep(10);
MessageBeep(0xFFFFFFFF);
LPVOID lpMsg;
::FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, //Fuente y opciones de procesamiento
NULL, //puntero a la fuente del mensaje
nError, //Identificador del mensaje solicitado
MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT), //Lenguaje identificador para mensaje solicitado
(LPTSTR) &lpMsg, //Puntero al buffer del mensaje
0, //Máximo tamaño del buffer del mensaje
NULL //Dirección del arreglo de mensajes insertados
);
ShowMessage((LPCTSTR)lpMsg);// Mostrar error
::LocalFree( lpMsg ); // Liberar el buffer
}
//---------------------------------------------------------------------------
unsigned int TComm::InputDetected(void)
{
//VerifyOpen();
COMSTAT comstat;
DWORD dummy;

if(!ClearCommError(MyFileHandle, &dummy, &comstat))
{
MyErrorMessage(GetLastError());
MessageBeep(0xFFFFFFFF);
}
return comstat.cbInQue;
}
//---------------------------------------------------------------------------
bool TComm::ReceivedEvent(void)
{
DWORD DwEvent;
OVERLAPPED OverlappedEvent = {0, 0, 0, 0, 0};
// Crear un evento de E/S utilizado para lecturas solapadas
OverlappedEvent.hEvent = CreateEvent(NULL, // sin seguridad
true, // iniciación manual
false, // inicialmente ocupado
NULL); // sin nombre
if (OverlappedEvent.hEvent == NULL)
{
ShowMessage("Failure to create event for the thread ");
}
if(WaitCommEvent(MyFileHandle, &DwEvent,&OverlappedEvent))
{
CloseHandle(OverlappedEvent.hEvent );
if(DwEvent & EV_RXCHAR)
return true;
}
return false;
}
//---------------------------------------------------------------------------
DWORD TComm::ReadInput(BYTE *BufferInput,DWORD DwMaxBytesR)
{
bool bLeer;
COMSTAT EstadoCom;
DWORD dwCodsError;
DWORD dwNumBytes;
DWORD dwError;
char szError[10];
// Leer cada vez como máximo BloqueMax caracteres
bLeer = ReadFile(MyFileHandle,BufferInput,DwMaxBytesR,&dwNumBytes,&OverlappedRead);
BufferInput[dwNumBytes] = 0; // finalizar con el carácter nulo
if (!bLeer)
{
if (GetLastError() == ERROR_IO_PENDING)
{
while(!GetOverlappedResult(MyFileHandle,&OverlappedRead,&dwNumBytes,false))
{
dwError = GetLastError();
if(dwError == ERROR_IO_INCOMPLETE)// Si no terminó, dwError vale ERROR_IO_INCOMPLETE
continue;
else
{
MyErrorMessage(dwError);// Ocurrió un error, intentar recuperarlo
ClearCommError(MyFileHandle,&dwCodsError,&EstadoCom );
if ( dwCodsError > 0 )
{
sprintf(szError,"Com: <CE-%u>",dwCodsError );// Los errores IE son < 0 (winbase.h)
ShowMessage(szError);
}
break;
}
} // fin while
}
else // error distinto de ERROR_IO_PENDING
{
dwNumBytes = 0;
ClearCommError(MyFileHandle, &dwCodsError, &EstadoCom );
if ( dwCodsError > 0 )
{
sprintf( szError,"Com: <CE-%u>",dwCodsError); // Los errores IE son < 0 (winbase.h)
ShowMessage(szError);
}
}
}
return dwNumBytes;
// add a null terminate if bytes_read < byteCount
// if the two are equal, there is no space to put a null terminator
/*if(bytes_read < MaxBytes)
buffer[bytes_read]='\0';
return bytes_read; */
}
//---------------------------------------------------------------------------
DWORD TComm::WriteOutput(BYTE *BufferOutput,DWORD DwMaxBytesW)
{
COMSTAT EstadoCom;
bool bEscribir;
DWORD dwNumBytes;
DWORD dwCodsError;
DWORD dwError;
DWORD dwBytesEnviados=0;
char szError[128];

bEscribir = WriteFile(MyFileHandle,BufferOutput,DwMaxBytesW,&dwNumBytes,&OverlappedWrite);
if (!bEscribir)
{
if( GetLastError() == ERROR_IO_PENDING )
{
while(!GetOverlappedResult(MyFileHandle,&OverlappedWrite,&dwNumBytes,false))
{
dwError = GetLastError();
if(dwError == ERROR_IO_INCOMPLETE) // Si no terminó, dwError vale ERROR_IO_INCOMPLETE
{
dwBytesEnviados += dwNumBytes;
continue;
}
else
{
MyErrorMessage(dwError); // ocurrió un error, intentar recuperarlo
ClearCommError(MyFileHandle,&dwCodsError,&EstadoCom );
if ( dwCodsError > 0 )
{
sprintf(szError,"Com: <CE-%u>",dwCodsError );// Los errores IE son < 0 (winbase.h)
ShowMessage(szError);
}
break;
}
}
dwBytesEnviados += dwNumBytes;
if( dwBytesEnviados != DwMaxBytesW)
sprintf(szError,"\nTiempo límite excedido.\nBytes enviados %ld", dwBytesEnviados);
else
sprintf(szError,"\n%ld bytes escritos", dwBytesEnviados);
}
else // error distinto de ERROR_IO_PENDING
{
ClearCommError(MyFileHandle, &dwCodsError, &EstadoCom );
if (dwCodsError > 0)
{
sprintf( szError, "Com: <CE-%u>", dwCodsError );
ShowMessage(szError);
}
return dwBytesEnviados;
}
}
return dwBytesEnviados;
}

joseluisbz@bigfoot.com

Volver arriba
Mensaje    Asunto: API_2 Responder citando

Hola..

ahhh...yaaa

Ves las comillas?
Estas comillas significan que lo que encierran es una cadena de caracteres, y que posteriormente la función o método de la API que la utiliza la interpretará posteriormente para aplicar.

Ahora...
Creo que baudios es una variable.. y en efecto tú le habrás puesto algún valor....
Pero en el contexto de BuildCommDCB no es más que un pedazo de la cadena de caracteres que al tratar de interpretar lanza algún error o excepción.

Sugerencia:
Utiliza algún DCB (buscar en la API) para configurar las opciones y posteriormente SetCommState para efectivamente colocarlo.

Ejemplo: (como yo lo uso...las librerias incluidas son mias.. no de la API...)

//---------------------------------------------------------------------------
#include <vcl.h>
#include <stdio.h>

#pragma hdrstop
//---------------------------------------------------------------------------
#include "CommPort.h"
#include "Principal.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------

static int DefaultBaudRate = 6;
static int DefaultParityBit = 0;
static int DefaultDataBits = 4;
static int DefaultFlowControl = 1;
static int DefaultStopBit = 0;
static int DefaultSerialPort = 0;
static int ActuallyBaudRate = DefaultBaudRate;
static int ActuallyParityBit = DefaultParityBit;
static int ActuallyDataBits = DefaultDataBits;
static int ActuallyFlowControl = DefaultFlowControl;
static int ActuallyStopBit = DefaultStopBit;
static int ActuallySerialPort = DefaultSerialPort;
static int CommPortSelected;
static DWORD BaudRateSelected;
#define COLARX 4096
#define COLATX 4096
//---------------------------------------------------------------------------
TComm::TComm()
{
}
//---------------------------------------------------------------------------
bool TComm::OpenPort()
{
DWORD OldCommMask;

if(EstablishedConnection)
return EstablishedConnection;
EstablishedConnection = false;
char szPuerto[10];
bool Success = false;
sprintf(szPuerto, "COM%d", ActuallySerialPort+1); // Formar "COM" más número
CommPortSelected = ActuallySerialPort+1;
if (MyFileHandle) CloseHandle(MyFileHandle); // Cerrar puerto por si está abierto
MyFileHandle = CreateFile(szPuerto, // Abrir el puerto de comunicaciones
GENERIC_READ | GENERIC_WRITE,
0, // acceso exclusivo
NULL, // sin atributos de seguridad
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL);

if(MyFileHandle == INVALID_HANDLE_VALUE)
{
ShowMessage("Port Not Opened");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);return false;
}

GetCommMask(MyFileHandle,&OldCommMask);
// Especificar eventos que se atenderán
if(!SetCommMask( MyFileHandle, EV_RXCHAR | EV_TXEMPTY | EV_RX80FULL | EV_ERR))
{
ShowMessage("SetCommMask Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);
CloseHandle(MyFileHandle);return false;
}
// Establecer tamaño de colas de recepción y de transmisión
if(!SetupComm(MyFileHandle, COLARX, COLATX))
{
ShowMessage("SetupComm Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);
CloseHandle(MyFileHandle);return false;
}
// Terminar operaciones de lectura y escritura pendientes y limpiar las colas Rx y Tx
if(!PurgeComm( MyFileHandle, PURGE_TXABORT | PURGE_RXABORT |PURGE_TXCLEAR | PURGE_RXCLEAR ))
{
ShowMessage("PurgeComm Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);
CloseHandle(MyFileHandle);return false;
}
// Establecer los parámetros de la comunicación
Success = MyConfigureCommunication();
if (Success)
{
EstablishedConnection = true;
MessageBeep(MB_ICONEXCLAMATION);
Sleep(100);
MessageBeep(MB_OK );
EscapeCommFunction(MyFileHandle, SETDTR); // Enviar señal DTR (data-terminal-ready).
}
else
{
EstablishedConnection = false;
CloseHandle(MyFileHandle);
}
return EstablishedConnection;
}
//---------------------------------------------------------------------------
bool TComm::ClosePort()
{
if(!EstablishedConnection) // if already closed, return
return !EstablishedConnection;
if(CloseHandle(MyFileHandle) != 0) // CloseHandle is non-zero on success
{
MessageBeep(MB_ICONEXCLAMATION);
Sleep(100);
MessageBeep(MB_OK );
EstablishedConnection = false;
}
else
{
ShowMessage("Port Not Closed");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);
}
return !EstablishedConnection;
}
//---------------------------------------------------------------------------
bool TComm::MyConfigureCommunication(void)
{
BaudRateTable[0] = CBR_110;
BaudRateTable[1] = CBR_300;
BaudRateTable[2] = CBR_600;
BaudRateTable[3] = CBR_1200;
BaudRateTable[4] = CBR_2400;
BaudRateTable[5] = CBR_4800;
BaudRateTable[6] = CBR_9600;
BaudRateTable[7] = CBR_14400;
BaudRateTable[8] = CBR_19200;
BaudRateTable[9] = CBR_38400;
BaudRateTable[10] = CBR_56000;
BaudRateTable[11] = CBR_128000;
BaudRateTable[12] = CBR_256000;
ParityTable[0] = NOPARITY;
ParityTable[1] = EVENPARITY;
ParityTable[2] = ODDPARITY;
ParityTable[3] = MARKPARITY;
ParityTable[4] = SPACEPARITY;
StopBitTable[0] = ONESTOPBIT;
StopBitTable[1] = ONE5STOPBITS;
StopBitTable[2] = TWOSTOPBITS;

BYTE Establishing;
DCB DcbNew;//,DcbOld;
DcbNew.DCBlength = sizeof(DCB);

if(!GetCommState(MyFileHandle, &DcbNew)) // Obtener propiedades DCB de puerto recien abierto
{ MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);return false; }

DcbNew.BaudRate = BaudRateTable[ActuallyBaudRate];
BaudRateSelected = DcbNew.BaudRate;
DcbNew.Parity = ParityTable[ActuallyParityBit];
DcbNew.ByteSize = (BYTE)(ActuallyDataBits + 4);
DcbNew.StopBits = StopBitTable[ActuallyStopBit];
// Establecer el control de flujo software
Establishing = (BYTE)(ActuallyFlowControl == 1); // Xon/Xoff
DcbNew.fInX = DcbNew.fOutX = Establishing;
DcbNew.XonChar = 0x11; // ASCII_XON
DcbNew.XoffChar = 0x13; // ASCII_XOFF
DcbNew.XonLim = 100;
DcbNew.XoffLim = 100;
// Establecer el control de flujo hardware
Establishing = (BYTE)(ActuallyFlowControl == 2); // DTR/DSR
DcbNew.fOutxDsrFlow = Establishing;
if (Establishing)
DcbNew.fDtrControl = DTR_CONTROL_HANDSHAKE;
else
DcbNew.fDtrControl = DTR_CONTROL_ENABLE;

Establishing = (BYTE)(ActuallyFlowControl == 3); // RTS/CTS
DcbNew.fOutxCtsFlow = Establishing;
if (Establishing)
DcbNew.fRtsControl = RTS_CONTROL_HANDSHAKE;
else
DcbNew.fRtsControl = RTS_CONTROL_ENABLE;

DcbNew.fBinary = true; // Otras especificaciones
DcbNew.fParity = true;

if(!SetCommState(MyFileHandle, &DcbNew)) //Disponer propiedades puerto según especificaciones
{
ShowMessage("SetupCommState Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);return false;
}

COMMTIMEOUTS CommTimeOuts; // Establecer tiempos límites para operaciones de E/S
CommTimeOuts.ReadIntervalTimeout = MAXDWORD;
CommTimeOuts.ReadTotalTimeoutMultiplier = 0;
CommTimeOuts.ReadTotalTimeoutConstant = 1000;
CommTimeOuts.WriteTotalTimeoutMultiplier = 2*CBR_9600/DcbNew.BaudRate;
CommTimeOuts.WriteTotalTimeoutConstant = 0;
if(!SetCommTimeouts(MyFileHandle, &CommTimeOuts))
{
ShowMessage("SetupCommTimeouts Error");
MyErrorMessage(GetLastError());MessageBeep(0xFFFFFFFF);return false;
} return true;
}
//---------------------------------------------------------------------------
DWORD TComm::GetCommBaudRate()
{ return BaudRateSelected;}
//---------------------------------------------------------------------------
int TComm::GetCommPort()
{ return CommPortSelected;}
//---------------------------------------------------------------------------
void TComm::MyErrorMessage( DWORD nError )
{
MessageBeep(0xFFFFFFFF);
Sleep(10);
MessageBeep(0xFFFFFFFF);
Sleep(10);
MessageBeep(0xFFFFFFFF);
LPVOID lpMsg;
::FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, //Fuente y opciones de procesamiento
NULL, //puntero a la fuente del mensaje
nError, //Identificador del mensaje solicitado
MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT), //Lenguaje identificador para mensaje solicitado
(LPTSTR) &lpMsg, //Puntero al buffer del mensaje
0, //Máximo tamaño del buffer del mensaje
NULL //Dirección del arreglo de mensajes insertados
);
ShowMessage((LPCTSTR)lpMsg);// Mostrar error
::LocalFree( lpMsg ); // Liberar el buffer
}
//---------------------------------------------------------------------------
unsigned int TComm::InputDetected(void)
{
//VerifyOpen();
COMSTAT comstat;
DWORD dummy;

if(!ClearCommError(MyFileHandle, &dummy, &comstat))
{
MyErrorMessage(GetLastError());
MessageBeep(0xFFFFFFFF);
}
return comstat.cbInQue;
}
//---------------------------------------------------------------------------
bool TComm::ReceivedEvent(void)
{
DWORD DwEvent;
OVERLAPPED OverlappedEvent = {0, 0, 0, 0, 0};
// Crear un evento de E/S utilizado para lecturas solapadas
OverlappedEvent.hEvent = CreateEvent(NULL, // sin seguridad
true, // iniciación manual
false, // inicialmente ocupado
NULL); // sin nombre
if (OverlappedEvent.hEvent == NULL)
{
ShowMessage("Failure to create event for the thread ");
}
if(WaitCommEvent(MyFileHandle, &DwEvent,&OverlappedEvent))
{
CloseHandle(OverlappedEvent.hEvent );
if(DwEvent & EV_RXCHAR)
return true;
}
return false;
}
//---------------------------------------------------------------------------
DWORD TComm::ReadInput(BYTE *BufferInput,DWORD DwMaxBytesR)
{
bool bLeer;
COMSTAT EstadoCom;
DWORD dwCodsError;
DWORD dwNumBytes;
DWORD dwError;
char szError[10];
// Leer cada vez como máximo BloqueMax caracteres
bLeer = ReadFile(MyFileHandle,BufferInput,DwMaxBytesR,&dwNumBytes,&OverlappedRead);
BufferInput[dwNumBytes] = 0; // finalizar con el carácter nulo
if (!bLeer)
{
if (GetLastError() == ERROR_IO_PENDING)
{
while(!GetOverlappedResult(MyFileHandle,&OverlappedRead,&dwNumBytes,false))
{
dwError = GetLastError();
if(dwError == ERROR_IO_INCOMPLETE)// Si no terminó, dwError vale ERROR_IO_INCOMPLETE
continue;
else
{
MyErrorMessage(dwError);// Ocurrió un error, intentar recuperarlo
ClearCommError(MyFileHandle,&dwCodsError,&EstadoCom );
if ( dwCodsError > 0 )
{
sprintf(szError,"Com: <CE-%u>",dwCodsError );// Los errores IE son < 0 (winbase.h)
ShowMessage(szError);
}
break;
}
} // fin while
}
else // error distinto de ERROR_IO_PENDING
{
dwNumBytes = 0;
ClearCommError(MyFileHandle, &dwCodsError, &EstadoCom );
if ( dwCodsError > 0 )
{
sprintf( szError,"Com: <CE-%u>",dwCodsError); // Los errores IE son < 0 (winbase.h)
ShowMessage(szError);
}
}
}
return dwNumBytes;
// add a null terminate if bytes_read < byteCount
// if the two are equal, there is no space to put a null terminator
/*if(bytes_read < MaxBytes)
buffer[bytes_read]='\0';
return bytes_read; */
}
//---------------------------------------------------------------------------
DWORD TComm::WriteOutput(BYTE *BufferOutput,DWORD DwMaxBytesW)
{
COMSTAT EstadoCom;
bool bEscribir;
DWORD dwNumBytes;
DWORD dwCodsError;
DWORD dwError;
DWORD dwBytesEnviados=0;
char szError[128];

bEscribir = WriteFile(MyFileHandle,BufferOutput,DwMaxBytesW,&dwNumBytes,&OverlappedWrite);
if (!bEscribir)
{
if( GetLastError() == ERROR_IO_PENDING )
{
while(!GetOverlappedResult(MyFileHandle,&OverlappedWrite,&dwNumBytes,false))
{
dwError = GetLastError();
if(dwError == ERROR_IO_INCOMPLETE) // Si no terminó, dwError vale ERROR_IO_INCOMPLETE
{
dwBytesEnviados += dwNumBytes;
continue;
}
else
{
MyErrorMessage(dwError); // ocurrió un error, intentar recuperarlo
ClearCommError(MyFileHandle,&dwCodsError,&EstadoCom );
if ( dwCodsError > 0 )
{
sprintf(szError,"Com: <CE-%u>",dwCodsError );// Los errores IE son < 0 (winbase.h)
ShowMessage(szError);
}
break;
}
}
dwBytesEnviados += dwNumBytes;
if( dwBytesEnviados != DwMaxBytesW)
sprintf(szError,"\nTiempo límite excedido.\nBytes enviados %ld", dwBytesEnviados);
else
sprintf(szError,"\n%ld bytes escritos", dwBytesEnviados);
}
else // error distinto de ERROR_IO_PENDING
{
ClearCommError(MyFileHandle, &dwCodsError, &EstadoCom );
if (dwCodsError > 0)
{
sprintf( szError, "Com: <CE-%u>", dwCodsError );
ShowMessage(szError);
}
return dwBytesEnviados;
}
}
return dwBytesEnviados;
}

Volver arriba
Mostrar mensajes de anteriores:   
Cambiar a:  
No puedes publicar temas nuevos en este foro
No puedes responder a temas en este foro
No puedes editar tus mensajes en este foro
No puedes borrar tus mensajes en este foro
No puedes votar en las encuestas de este foro


Hosting WordPress Indedmedia desde 3,99 €
© 2002–2026 Club Builder · Funciona con phpBB.