COM2 EN LINUX

4 12 2007

ANTES DE NADA MIRAROS ESTE LINK–>

Vamos a ver como lo hago, e encontrado codigo sobre el com2 en linux…. pero tiene su miga gorda asi que estaria bien que lo leyeseis o algo, es importante que decidamos si vamos a hacerlo en linux o no, pero que quede claro que va a ser una fiesta importante, hay va :

DEFINICION DE CLASE:

//serialport.h
#ifndef SERIALPORT_H
#define SERIALPORT_H

#include <qobject.h>
#include <qcstring.h>
#include <qfile.h>

#include <termios.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <fcntl.h>

#define LS_CTS 0x01
#define LS_DSR 0x02
#define LS_DCD 0x04
#define LS_RI 0x08
#define LS_RTS 0x10
#define LS_DTR 0x20
#define LS_ST 0x40
#define LS_SR 0x80

enum FlowType {
FLOW_OFF,
FLOW_HARDWARE,
FLOW_XONXOFF
};

enum ParityType {
PAR_NONE,
PAR_ODD,
PAR_EVEN,
};

enum DataBitsType {
DATA_5,
DATA_6,
DATA_7,
DATA_8
};

enum StopBitsType {
STOP_1,
STOP_2
};

enum BaudRateType {
BAUD50, //POSIX ONLY
BAUD75, //POSIX ONLY
BAUD110,
BAUD134, //POSIX ONLY
BAUD150, //POSIX ONLY
BAUD200, //POSIX ONLY
BAUD300,
BAUD600,
BAUD1200,
BAUD1800, //POSIX ONLY
BAUD2400,
BAUD4800,
BAUD9600,
BAUD19200,
BAUD38400,
BAUD57600,
BAUD76800, //POSIX ONLY
BAUD115200,
};

struct PortSettings {
FlowType FlowControl;
ParityType Parity;
DataBitsType DataBits;
StopBitsType StopBits;
BaudRateType BaudRate;
unsigned long Timeout_Sec;
unsigned long Timeout_Millisec;
};

/**
@author FERNANDO VARGAS
*/
/*!
Una clase con el fin de facilitar el manejo del puerto serie en linux.

\note
Se distribuye sin ninguna garantía bajo los parametros GPL, es para su consideración y es libre de ser modificada,
mejorada y copiada.
*/

class SerialPort : public QObject
{
Q_OBJECT
public:
SerialPort(const char *name = “/dev/ttyS0”, QObject *parent = 0);

~SerialPort();
bool openPort();
bool isOpen();
void setDataBits(DataBitsType dataBits);
void setBaudRate(BaudRateType baudRate);
void setStopBits(StopBitsType);
void setParity(ParityType parity);
void setFlowControl(FlowType flow);
void setTimeout(unsigned long sec = 0, unsigned long millisec = 0);
int bytesWating();
void closePort();
void flush();
int putch(char ch);
int writeBlock(const char *data, unsigned int len);
char getch(int *res = 0);
int readBlock(char *data, unsigned int len);
void setDTR(bool set = true);
void setRTS(bool set = true);
unsigned long lineStatus();
void setName(const char *name);

protected:
QCString pName;
struct termios CommConfig;
struct termios tmpCommConfig;
int fd;
bool portOpen;
PortSettings Settings;
int tmpStatus;
protected:
void construct();
};

INCLUDES ETC…

/***************************************************************************
* Copyright (C) 2004 by FERNANDO VARGAS *
* fernandovargas@cable.net.co *
* *
* 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., *
* 59 Temple Place – Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/

#include “serialport.h”

/*!
\fn SerialPort::SerialPort(const char *name = “/dev/ttyS0”, QObject *parent)
Constructor estandar.
Construye un SerialPort asociado al dispositivo name. Recibe un apuntador al objeto padre.
*/
SerialPort::SerialPort(const char *portName, QObject *parent)
: QObject(parent)
{
pName = portName;
construct();
}

SerialPort::~SerialPort()
{
closePort();
}

#include “serialport.moc”
FUNCION DE ABRIR EL PUERTO:

/*!
\fn SerialPort::openPort()
Abre el puerto asociado con el objeto, Por ejemplo /dev/ttySN N=0,1,2….
El puerto es abierto y configurado de acuerdo a la struct Settings que es configurada
utilizando funciones como setStopBits, setParity, etc.
Si no ha configurado previamente el comportamiento del puerto, éste tendrá los valores
por defecto: (9600 8N1: Control de flujo por hardware si es posible, en caso contrario
sin control de flujo y 100 ms para tiempo de espera)
*/
bool SerialPort::openPort()
{
if(!portOpen){
fd = open(pName, O_RDWR | O_NOCTTY | O_NDELAY);
if(fd >= 0){
portOpen = true;

ioctl(fd, TIOCMGET, &tmpStatus);
tcgetattr(fd, &tmpCommConfig);

bzero(&CommConfig, sizeof(CommConfig));

CommConfig.c_cflag|=CREAD|CLOCAL;
CommConfig.c_lflag&=(~(ICANON|ECHO|ECHOE|ECHOK|ECHONL|ISIG));
CommConfig.c_iflag&=(~(INPCK|IGNPAR|PARMRK|ISTRIP|IXANY));
CommConfig.c_oflag&=(~OPOST);
CommConfig.c_cc[VMIN]=0;
CommConfig.c_cc[VINTR] = _POSIX_VDISABLE;
CommConfig.c_cc[VQUIT] = _POSIX_VDISABLE;
CommConfig.c_cc[VSTART] = _POSIX_VDISABLE;
CommConfig.c_cc[VSTOP] = _POSIX_VDISABLE;
CommConfig.c_cc[VSUSP] = _POSIX_VDISABLE;

setBaudRate(Settings.BaudRate);
setDataBits(Settings.DataBits);
setStopBits(Settings.StopBits);
setParity(Settings.Parity);
setFlowControl(Settings.FlowControl);
setTimeout(Settings.Timeout_Sec , Settings.Timeout_Millisec);

tcsetattr(fd, TCSAFLUSH, &CommConfig);
}
}

return portOpen;
}

/*!
\fn SerialPort::isOpen()
Retorna verdadero si el puerto se encuentra abierto.
*/
bool SerialPort::isOpen()
{
return portOpen;
}

NUMERO DE BITS DE DATOS USADOS POR EL PUERTO:
/*!
\fn SerialPort::setDataBits(DataBitsType dataBits)
Establece el número de bits de datos usados por el puerto.
Los valores posibles para dataBits son:
\verbatim
DATA_5 5 bits
DATA_6 6 bits
DATA_7 7 bits
DATA_8 8 bits
\endverbatim

\note
Esta función está sujeta a las siguiente condición:
\par
No se pueden usar datos de 5 bits con 2 bits de parada.
*/
void SerialPort::setDataBits(DataBitsType dataBits)
{
if (Settings.DataBits!=dataBits) {
if (!(Settings.StopBits==STOP_2 && dataBits==DATA_5)) {
Settings.DataBits=dataBits;
}
}

if (portOpen) {
switch(dataBits) {

/*5 data bits*/
case DATA_5:
if (~(Settings.StopBits==STOP_2)) {
Settings.DataBits=dataBits;
CommConfig.c_cflag&=(~CSIZE);
CommConfig.c_cflag|=CS5;
tcsetattr(fd, TCSAFLUSH, &CommConfig);
}
break;

/*6 data bits*/
case DATA_6:
Settings.DataBits=dataBits;
CommConfig.c_cflag&=(~CSIZE);
CommConfig.c_cflag|=CS6;
tcsetattr(fd, TCSAFLUSH, &CommConfig);

break;

/*7 data bits*/
case DATA_7:
Settings.DataBits=dataBits;
CommConfig.c_cflag&=(~CSIZE);
CommConfig.c_cflag|=CS7;
tcsetattr(fd, TCSAFLUSH, &CommConfig);

break;

/*8 data bits*/
case DATA_8:
Settings.DataBits=dataBits;
CommConfig.c_cflag&=(~CSIZE);
CommConfig.c_cflag|=CS8;
tcsetattr(fd, TCSAFLUSH, &CommConfig);

break;
}
}
}
VELOCIDAD DEL PUERTO:

/*!
\fn SerialPort::setBaudRate(BaudRateType baudRate)
Establece la velocidad del puerto.
\note
BAUD76800 probablemente no es soportado por todos los sitemas POSIX.
Los sistemas SGI/IRIX no soportan BAUD1800.
\verbatim

TASA(baudRate) Velocidad
————– ———–
BAUD50 50
BAUD75 75
*BAUD110 110
BAUD134 134.5
BAUD150 150
BAUD200 200
*BAUD300 300
*BAUD600 600
*BAUD1200 1200
BAUD1800 1800
*BAUD2400 2400
*BAUD4800 4800
*BAUD9600 9600
*BAUD19200 19200
*BAUD38400 38400
*BAUD57600 57600
BAUD76800 76800
*BAUD115200 115200
\endverbatim

*/
void SerialPort::setBaudRate(BaudRateType baudRate)
{
if(baudRate == BAUD76800){
#ifndef B76800
Settings.BaudRate=BAUD57600;
#else
Settings.BaudRate=baudRate;
#endif
}
else{
Settings.BaudRate=baudRate;
}

if (portOpen) {
switch (baudRate) {

/*50 baud*/
case BAUD50:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B50;
#else
cfsetispeed(&CommConfig, B50);
cfsetospeed(&CommConfig, B50);
#endif
break;

/*75 baud*/
case BAUD75:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B75;
#else
cfsetispeed(&CommConfig, B75);
cfsetospeed(&CommConfig, B75);
#endif
break;

/*110 baud*/
case BAUD110:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B110;
#else
cfsetispeed(&CommConfig, B110);
cfsetospeed(&CommConfig, B110);
#endif
break;

/*134.5 baud*/
case BAUD134:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B134;
#else
cfsetispeed(&CommConfig, B134);
cfsetospeed(&CommConfig, B134);
#endif
break;

/*150 baud*/
case BAUD150:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B150;
#else
cfsetispeed(&CommConfig, B150);
cfsetospeed(&CommConfig, B150);
#endif
break;

/*200 baud*/
case BAUD200:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B200;
#else
cfsetispeed(&CommConfig, B200);
cfsetospeed(&CommConfig, B200);
#endif
break;

/*300 baud*/
case BAUD300:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B300;
#else
cfsetispeed(&CommConfig, B300);
cfsetospeed(&CommConfig, B300);
#endif
break;

/*600 baud*/
case BAUD600:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B600;
#else
cfsetispeed(&CommConfig, B600);
cfsetospeed(&CommConfig, B600);
#endif
break;

/*1200 baud*/
case BAUD1200:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B1200;
#else
cfsetispeed(&CommConfig, B1200);
cfsetospeed(&CommConfig, B1200);
#endif
break;

/*1800 baud*/
case BAUD1800:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B1800;
#else
cfsetispeed(&CommConfig, B1800);
cfsetospeed(&CommConfig, B1800);
#endif
break;

/*2400 baud*/
case BAUD2400:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B2400;
#else
cfsetispeed(&CommConfig, B2400);
cfsetospeed(&CommConfig, B2400);
#endif
break;

/*4800 baud*/
case BAUD4800:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B4800;
#else
cfsetispeed(&CommConfig, B4800);
cfsetospeed(&CommConfig, B4800);
#endif
break;

/*9600 baud*/
case BAUD9600:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B9600;
#else
cfsetispeed(&CommConfig, B9600);
cfsetospeed(&CommConfig, B9600);
#endif
break;

/*19200 baud*/
case BAUD19200:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B19200;
#else
cfsetispeed(&CommConfig, B19200);
cfsetospeed(&CommConfig, B19200);
#endif
break;

/*38400 baud*/
case BAUD38400:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B38400;
#else
cfsetispeed(&CommConfig, B38400);
cfsetospeed(&CommConfig, B38400);
#endif
break;

/*57600 baud*/
case BAUD57600:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B57600;
#else
cfsetispeed(&CommConfig, B57600);
cfsetospeed(&CommConfig, B57600);
#endif
break;

/*76800 baud*/
case BAUD76800:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);

#ifdef B76800
CommConfig.c_cflag|=B76800;
#else
CommConfig.c_cflag|=B57600;
#endif //B76800
#else //CBAUD
#ifdef B76800
cfsetispeed(&CommConfig, B76800);
cfsetospeed(&CommConfig, B76800);
#else
cfsetispeed(&CommConfig, B57600);
cfsetospeed(&CommConfig, B57600);
#endif //B76800
#endif //CBAUD
break;

/*115200 baud*/
case BAUD115200:
#ifdef CBAUD
CommConfig.c_cflag&=(~CBAUD);
CommConfig.c_cflag|=B115200;
#else
cfsetispeed(&CommConfig, B115200);
cfsetospeed(&CommConfig, B115200);
#endif
break;
}
tcsetattr(fd, TCSAFLUSH, &CommConfig);
}
}

NUMERO DE BITS DE PARADA (nosotros usaremos uno):

/*!
\fn SerialPort::setStopBits(StopBitsType stopBits)
Estavlece el número de bits de parada usados por el puerto serie.
Los valores posibles para stopBits son:
\verbatim
STOP_1 1 stop bit
STOP_2 2 stop bits
\endverbatim
\note
La función esta sujeta a las siguientes restricciones
\par
2 bits de parada no se pueden usar con 5 bits de datos
\par
POSIX no soporta bits de parada de 1.5
*/

void SerialPort::setStopBits(StopBitsType stopBits)
{
if (Settings.StopBits!=stopBits) {
if (!(Settings.DataBits==DATA_5 && stopBits==STOP_2)) {
Settings.StopBits=stopBits;
}
}
if (portOpen) {
switch (stopBits) {

/*one stop bit*/
case STOP_1:
Settings.StopBits=stopBits;
CommConfig.c_cflag&=(~CSTOPB);
tcsetattr(fd, TCSAFLUSH, &CommConfig);
break;

/*two stop bits*/
case STOP_2:
if (Settings.DataBits!=DATA_5) {
Settings.StopBits=stopBits;
CommConfig.c_cflag|=CSTOPB;
tcsetattr(fd, TCSAFLUSH, &CommConfig);
}
break;
}
}
}

ADECUAR LA PARIDAD:

/*!
\fn SerialPort::setParity(ParityType parity)
Establece la paridad asociada al puerto serie.
Los valores posibles para parity son:
\verbatim
PAR_NONE Sin paridad
PAR_EVEN Paridad par
PAR_ODD Paridad impar
\endverbatim
*/
void SerialPort::setParity(ParityType parity)
{
Settings.Parity=parity;

if (portOpen) {
switch (parity) {

case PAR_NONE:
CommConfig.c_cflag&=(~PARENB);
tcsetattr(fd, TCSAFLUSH, &CommConfig);
break;

/*even parity*/
case PAR_EVEN:
CommConfig.c_cflag&=(~PARODD);
CommConfig.c_cflag|=PARENB;
tcsetattr(fd, TCSAFLUSH, &CommConfig);
break;

/*odd parity*/
case PAR_ODD:
CommConfig.c_cflag|=(PARENB|PARODD);
tcsetattr(fd, TCSAFLUSH, &CommConfig);
break;
}
}
}

CONTROL DE FLUJO:

/*!
\fn SerialPort::setFlowControl(FlowType flow)
Fija el control de flujo usado por el puerto. Los valores posibles para flow son:
\verbatim
FLOW_OFF Sin control de flujo
FLOW_HARDWARE Control por Hardware (RTS/CTS)
FLOW_XONXOFF Control por Software (XON/XOFF)
\endverbatim
\note
FLOW_HARDWARE podría no ser soportado en todas las versiones de UNIX. En caso de
no ser soportado FLOW_HARDWARE será lo mismo que FLOW_OFF.
*/
void SerialPort::setFlowControl(FlowType flow)
{
if (Settings.FlowControl!=flow) {
Settings.FlowControl=flow;
}
if (portOpen) {
switch(flow) {

/*no flow control*/
case FLOW_OFF:
CommConfig.c_cflag&=(~CRTSCTS);
CommConfig.c_iflag&=(~(IXON|IXOFF|IXANY));
tcsetattr(fd, TCSAFLUSH, &CommConfig);
break;

/*software (XON/XOFF) flow control*/
case FLOW_XONXOFF:
CommConfig.c_cflag&=(~CRTSCTS);
CommConfig.c_iflag|=(IXON|IXOFF|IXANY);
tcsetattr(fd, TCSAFLUSH, &CommConfig);
break;

case FLOW_HARDWARE:
CommConfig.c_cflag|=CRTSCTS;
CommConfig.c_iflag&=(~(IXON|IXOFF|IXANY));
tcsetattr(fd, TCSAFLUSH, &CommConfig);
break;
}
}
}

TIEMPO DE ESPERA PARA LAS OPERACIONES DE LECTURA ESCRITURA:

/*!
\fn SerialPort::setTimeout(unsigned long sec = 0, unsigned long millisec = 0)

Establece el tiempo de espera para las operaciones de lectura y escritura del puerto
con sec = segundos y millisec = milisegundos. Estes es un tiempo de espera por caracter
de tal manera que la espera será por caracter y no por toda la operación de lectura.

\note
Los sistemas POSIX no soportan valores de control de tiempo del orden de los milisegundos.
Cualquier tiempo de espera establecido con esta función se establecerá al valor bajo más
cercano en décimas de segundos. Por ejemplo un tiempo de espera de 550 milisegundos será
vistó por la clase como un tiempo de espera de 500 milisegundos.
*/
void SerialPort::setTimeout(unsigned long sec, unsigned long millisec)
{
Settings.Timeout_Sec=sec;
Settings.Timeout_Millisec=millisec;
tcgetattr(fd, &CommConfig);
CommConfig.c_cc[VTIME]=sec*10+millisec/100;
if (portOpen) {
tcsetattr(fd, TCSAFLUSH, &CommConfig);
}
}

/*!
\fn SerialPort::construct()
Establece los valores por defecto para el puerto.
*/
void SerialPort::construct()
{
setBaudRate(BAUD9600);
setDataBits(DATA_8);
setStopBits(STOP_1);
setParity(PAR_NONE);
setFlowControl(FLOW_HARDWARE);
setTimeout(0, 100);
}

VALORES POR DEFECTO PARA EL PUERTO:

/*!
\fn SerialPort::construct()
Establece los valores por defecto para el puerto.
*/
void SerialPort::construct()
{
setBaudRate(BAUD9600);
setDataBits(DATA_8);
setStopBits(STOP_1);
setParity(PAR_NONE);
setFlowControl(FLOW_HARDWARE);
setTimeout(0, 100);
}

DEVUELVE EL NUMERO DE BYTES ESPERANDO EN COLA:

/*!
\fn SerialPort::bytesWating()
Retorna el número de bytes esperando en la cola de recepción del puerto serie.
Retorna -1 en caso de no estar abireto el puerto.
*/
int SerialPort::bytesWating()
{
int bytes = -1;

if(portOpen){
ioctl(fd, FIONREAD, &bytes);
}
return bytes;
}

CERRAR PUERTO:

/*!
\fn SerialPort::closePort()
Cierra el puerto asociado a la clase. En caso de no estar abierto la función no tendrá
ningún efecto.
*/
void SerialPort::closePort()
{
flush();
setRTS(false);
//ioctl(fd, TIOCMSET, &tmpStatus);
tcsetattr(fd, TCSAFLUSH, &tmpCommConfig);

close(fd);
portOpen = false;
}

BORRA TODOS LOS DATOS DE ENTRADA O SALIDA DEL PUERTO:

/*!
\fn SerialPort::flush()
Borra todos los datos de entrada o salida pendientes en el puerto.
No tiene efecto si el puerto no está abierto.
*/
void SerialPort::flush()
{
if(portOpen){
ioctl(fd, TCFLSH);
}
}

ESCRIBE UN CARACTER EN EL PUERTO SERIE:

/*!
\fn SerialPort::putch(char ch)
Escribe un caracter en el puerto serie. Retorna el número de caracteres escritos, -1 si
ocurrió un error o el puerto no esta abierto.
*/
int SerialPort::putch(char ch)
{
int n = -1;
char *chr = &ch;

if(portOpen){
n = write(fd, chr, 1);
}
return n;
}

DEVUELVE UN CARACTER LEIDO DEL PUERTO:

/*!
\fn SerialPort::getch(int *res)
Retorna un caracter leido del puerto serie. Esta función no tiene efecto si el puerto
no está abierto.
La función almacenará un valor en el entero al que apunta res de la siguiente forma:
-1, si el puerto no está abierto aún o si ocurrió un error al leer el dato.
0, si no se leyó ningún dato y el tiempo de espera finalizó.
1, si se leyó exitosamente el dato y éste es el contenido en el valor retornado.
\note
Recuerde que las funciones de lectura se ven directamente afectadas por el valor que se
haya establecido como tiempo de espera. Si el tiempo de espera es cero, la función se
bloqueará hasta que se haya terminado el proceso de lectura.
*/
char SerialPort::getch(int *res)
{
char buff[1] = {”};
int bres = -1;

if(portOpen){
bres = read(fd, buff, 1);
}
if(res != 0){
*res = bres;
}
return buff[0];
}

ESCRIBE UN BLOQUE DE CARACTERES:

/*!
\fn SerialPort::writeBlock(const char *data, unsigned int len)
Escribe un bloque de caracteres. Escribe el número de caracteres dado por len
a los cuales apunta data. Retorna la cantidad de caracteres escritos, -1 en caso de
error o de no estar abierto el puerto.
*/
int SerialPort::writeBlock(const char *data, unsigned int len)
{
int n = -1;

if(portOpen){
n = write(fd, data, len);
}
return n;
}

LEE UN BLOKE DE CARACTERES:

/*!
\fn SerialPort::readBlock(char *data, unsigned int len)
Lee un bloque de caracteres del puerto serie del tamaño de len. Los datos son almacenados
en data y la función retorna el número de caracteres leidos o -1 en caso de erro o de estar
cerrado el puerto.

\note
Recuerde que las funciones de lectura se ven directamente afectadas por el valor que se
haya establecido como tiempo de espera. Si el tiempo de espera es cero, la función se
bloqueará hasta que se haya terminado el proceso de lectura.
*/
int SerialPort::readBlock(char *data, unsigned int len)
{
int res = -1;
if(portOpen){
tcgetattr(fd, &CommConfig);
CommConfig.c_cc[VMIN]=len;
tcsetattr(fd, TCSANOW, &CommConfig);

res = read(fd, data, 255);

tcgetattr(fd, &CommConfig);
CommConfig.c_cc[VMIN]=0;
tcsetattr(fd, TCSANOW, &CommConfig);
}
return res;
}

ESTABLECE EL DTR (alto por defecto):

/*!
\fn SerialPort::setDTR(bool set = true)
Establece la línea DTR al estado requerido (Alto por defecto). La función no tendrá efecto
si el puerto no está abierto.
*/
void SerialPort::setDTR(bool set)
{
if (portOpen) {
int status;
ioctl(fd, TIOCMGET, &status);
if (set) {
status|=TIOCM_DTR;
}
else {
status&=~TIOCM_DTR;
}
ioctl(fd, TIOCMSET, &status);
}
}

ESTABLECE EL RTS (alto por defecto):

/*!
\fn SerialPort::setRTS(bool set = true)
Establece la línea RTS al estado requerido (Alto por defecto). La función no tendrá efecto
si el puerto no está abierto.
*/
void SerialPort::setRTS(bool set)
{
if (portOpen) {
int status;
ioctl(fd, TIOCMGET, &status);
if (set) {
status|=TIOCM_RTS;
}
else {
status&=~TIOCM_RTS;
}
ioctl(fd, TIOCMSET, &status);
}
}

DEVUELVE EL ESTADO DE LAS LINEAS DE PUERTO:
/*!
\fn unsigned long SerialPort::lineStatus()
Retorna el estado de las líneas del puerto. Esta función extrae el estado de las siguientes
lineas: DCD, CTS, DSR, and RI. En sistemas POSIX las siguientes lineas adicionales podrían
ser monitoreadas: DTR, RTS, TXD Secundaria, RXD Secundaria. El valor retornado es del tipo
unsigned long con bits específicos indicando el estado de cada línea. Las siguientes
constantes deben ser usadas para examinar el estado de cada línea mediante enmascaramiento:

\verbatim
Mascara Linea
——- —–
LS_CTS CTS
LS_DSR DSR
LS_DCD DCD
LS_RI RI
LS_RTS RTS (POSIX solamente)
LS_DTR DTR (POSIX solamente)
LS_ST TXD Secundaria (POSIX solamente)
LS_SR RXD Secundaria (POSIX solamente)
\endverbatim

Esta función retornará 0 si el puerto asociado con la clase no está abierto.
*/
unsigned long SerialPort::lineStatus()
{
unsigned long Status=0, Temp;

if (portOpen) {
ioctl(fd, TIOCMGET, &Temp);
if (Temp & TIOCM_CTS) {
Status |= LS_CTS;
}
if (Temp & TIOCM_DSR) {
Status |= LS_DSR;
}
if (Temp & TIOCM_RI) {
Status |= LS_RI;
}
if (Temp & TIOCM_CD) {
Status |= LS_DCD;
}
if (Temp & TIOCM_DTR) {
Status |= LS_DTR;
}
if (Temp & TIOCM_RTS) {
Status |= LS_RTS;
}
if (Temp & TIOCM_ST) {
Status |= LS_ST;
}
if (Temp & TIOCM_SR) {
Status |= LS_SR;
}
}
return Status;
}

ESTABLECE EL NOMBRE DEL DISPOSITIVO:
/*!
\fn unsigned long SerialPort::lineStatus()
Retorna el estado de las líneas del puerto. Esta función extrae el estado de las siguientes
lineas: DCD, CTS, DSR, and RI. En sistemas POSIX las siguientes lineas adicionales podrían
ser monitoreadas: DTR, RTS, TXD Secundaria, RXD Secundaria. El valor retornado es del tipo
unsigned long con bits específicos indicando el estado de cada línea. Las siguientes
constantes deben ser usadas para examinar el estado de cada línea mediante enmascaramiento:

\verbatim
Mascara Linea
——- —–
LS_CTS CTS
LS_DSR DSR
LS_DCD DCD
LS_RI RI
LS_RTS RTS (POSIX solamente)
LS_DTR DTR (POSIX solamente)
LS_ST TXD Secundaria (POSIX solamente)
LS_SR RXD Secundaria (POSIX solamente)
\endverbatim

Esta función retornará 0 si el puerto asociado con la clase no está abierto.
*/
unsigned long SerialPort::lineStatus()
{
unsigned long Status=0, Temp;

if (portOpen) {
ioctl(fd, TIOCMGET, &Temp);
if (Temp & TIOCM_CTS) {
Status |= LS_CTS;
}
if (Temp & TIOCM_DSR) {
Status |= LS_DSR;
}
if (Temp & TIOCM_RI) {
Status |= LS_RI;
}
if (Temp & TIOCM_CD) {
Status |= LS_DCD;
}
if (Temp & TIOCM_DTR) {
Status |= LS_DTR;
}
if (Temp & TIOCM_RTS) {
Status |= LS_RTS;
}
if (Temp & TIOCM_ST) {
Status |= LS_ST;
}
if (Temp & TIOCM_SR) {
Status |= LS_SR;
}
}
return Status;
}

Bueno hay teneis toda la basura ahora toca rebuscar…

E MARCADO EN ROJO LAS QUE CONSIDERO IMPORTANTES

BY ION…


Acciones

Information

4 responses

4 12 2007
Igor Ordoñez Rodriguez

Mira el link que puse arriba y me dices que tal.

4 12 2007
ionbixen

ME CAGO EN DIOS NO SE QUE COÑO E HECHO PERO AHORA SALE ESE PUTO LINK DE MIERDA EN TODO EL POST JODER!!!! T_T

4 12 2007
Igor Ordoñez Rodriguez

Arreglado y añadi este boton https://proiektutaldea.wordpress.com/wp-includes/js/tinymce/plugins/wordpress/images/more.gif

Para que haya que pulsar en leer mas, sino macho me llenais entre tu y Dani con un a noticia todo el blog.

Un saludo.

20 01 2008
Publicados nuevos posts « Proiektutaldea-ren Weblog

[…] -COM2 EN LINUX […]

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s




A %d blogueros les gusta esto: