In search for a way to send strings to an usb character display from within pd, I came upon the comport external: http://iem.kug.ac.at/ritsch/programmier/pd_externals/comport/
Although a bit outdated, it worked right out of the box, but lacked an implementation of the print method, although the function header was already present as a comment in the source.
The only way to send characters was by sending ascii codes as float messages. Since I don't know how to convert a string message to a series of float messages, I decided to implement the missing print method.
I also inlcuded the /dev/ttyUSB0-7 devices in the device list, to facilitate opening an usb serial device, like my Matrix Orbital LK204-24-USB.
The only problem still is that I can't send a message containing comma's, because the message is then split in two messages. Any suggestions on how to do this?
Of course, I could also have used the system object like this [system echo "Hello, world!" >/dev/ttyUSB0], but I also need input from the lcd module, and the system object doesn't provide that.
Modified comport.c attached. See above url for makefile.
#include "m_pd.h"
#ifdef NT #pragma warning( disable : 4244 ) #pragma warning( disable : 4305 ) #include <windows.h> #include <commctrl.h> #else #include <sys/time.h> #include <fcntl.h> #include <termios.h> /* for TERMIO ioctl calls */ #include <unistd.h> #define HANDLE int #define INVALID_HANDLE_VALUE -1 #endif
#include <string.h> #include <errno.h>
typedef struct comport { t_object x_obj;
long n; /* the state of a last input */
HANDLE comhandle; /* holds the comport handle */
#ifdef NT DCB dcb; /* holds the comm pars */ DCB dcb_old; /* holds the comm pars */ COMMTIMEOUTS old_timeouts; #else struct termios oldcom_termio; /* save the old com config */ struct termios com_termio; /* for the new com config */ #endif
short comport; /* holds the comport # */ float baud; /* holds the current baud rate */
short rxerrors; /* holds the rx line errors */
t_clock *x_clock; int x_hit; double x_deltime;
} t_comport;
#ifndef TRUE #define TRUE 1 #define FALSE 0 #endif
#ifndef ON #define ON 1 #define OFF 0 #endif
/* Serial Port Return Values */ #define NODATAAVAIL -1 #define RXERRORS -2 #define RXBUFOVERRUN -4 #define TXBUFOVERRUN -5
#ifdef NT
#define COMPORT_MAX 8 static char *sys_com_port[COMPORT_MAX] = { "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8" };
static long baudspeedbittable[] = { CBR_256000, CBR_128000, CBR_115200, CBR_57600, CBR_56000, CBR_38400, CBR_19200, CBR_14400, CBR_9600, CBR_4800, CBR_2400, CBR_1200, CBR_600, CBR_300, CBR_110 };
#else /* NT */
#ifdef IRIX
#define COMPORT_MAX 2
static char *sys_com_port[COMPORT_MAX] =
{
"/dev/ttyd1", "/dev/ttyd2"
};
#define OPENPARAMS (O_RDWR|O_NDELAY|O_NOCTTY)
#define TIONREAD FIONREAD /* re map the IOCTL function */
#define BAUDRATE_256000 -1
#define BAUDRATE_128000 -1
#define BAUDRATE_115200 -1
#define BAUDRATE_57600 -1
#define BAUDRATE_56000 -1
#define BAUDRATE_38400 B38400
#define BAUDRATE_14400 B19200 /* 14400 gibts nicht */
#else /* IRIX */
#define COMPORT_MAX 16
static char *sys_com_port[COMPORT_MAX] =
{
"/dev/ttyS0", "/dev/ttyS1", "/dev/ttyS2", "/dev/ttyS3",
"/dev/ttyS4", "/dev/ttyS5", "/dev/ttyS6", "/dev/ttyS7",
"/dev/ttyUSB0", "/dev/ttyUSB1", "/dev/ttyUSB2", "/dev/ttyUSB3",
"/dev/ttyUSB4", "/dev/ttyUSB5", "/dev/ttyUSB6", "/dev/ttyUSB7"
};
#define OPENPARAMS (O_RDWR|O_NDELAY|O_NOCTTY)
#define BAUDRATE_256000 -1
#define BAUDRATE_128000 -1
#define BAUDRATE_115200 B115200
#define BAUDRATE_57600 B57600
#define BAUDRATE_56000 B57600 /* 56000 gibts nicht */
#define BAUDRATE_38400 B38400
#define BAUDRATE_14400 B19200 /* 14400 gibts nicht */
#endif /* else IRIX */
static short baudspeedbittable[] = { BAUDRATE_256000, /* CPU SPECIFIC */ BAUDRATE_128000, /* CPU SPECIFIC */ BAUDRATE_115200, /* CPU SPECIFIC */ BAUDRATE_57600, /* CPU SPECIFIC */ BAUDRATE_56000, BAUDRATE_38400, /* CPU SPECIFIC */ B19200, BAUDRATE_14400, B9600, B4800, B2400, B1200, B600, B300, B110 };
struct timeval null_tv;
#endif /* else NT */
#define BAUDRATETABLE_LEN 15
static long baudratetable[] = { 256000L, 128000L, 115200L, 57600L, 56000L, 38400L, 19200L, 14400L, 9600L, 4800L, 2400L, 1200L, 600L, 300L, 110L }; /* holds the baud rate selections */
t_class *comport_class;
/* --------- sys independend serial setup helpers ---------------- */
static long get_baud_ratebits(t_float *baud) { int i = 0;
while(i < BAUDRATETABLE_LEN && baudratetable[i] > *baud) i++;
/* nearest Baudrate finding */ if(i==BAUDRATETABLE_LEN || baudspeedbittable[i] < 0){ post("*Warning* The baud rate %d is not suported or out of range, using 9600\n",*baud); i = 7; } *baud = baudratetable[i];
return baudspeedbittable[i]; }
/* ------------ sys dependend serial setup helpers ---------------- */
/* --------------------- NT ------------------------------------ */
#ifdef NT
static float set_baudrate(t_comport *x,t_float baud) { x->dcb.BaudRate = get_baud_ratebits(&baud);
return baud; }
/* bits are 5,6,7,8(default) */
static float set_bits(t_comport *x, int nr) {
if(nr < 4 && nr > 8) nr = 8;
// number of bits/byte, 4-8 return x->dcb.ByteSize = nr; }
/* 1 ... Parity even, -1 parity odd , 0 (default) no parity */ static float set_parity(t_comport *x,int n) { switch(n){ case 1: x->dcb.fParity = TRUE; // enable parity checking x->dcb.Parity = 2; // 0-4=no,odd,even,mark,space return 1;
case -1: x->dcb.fParity = TRUE; // enable parity checking x->dcb.Parity = 1; // 0-4=no,odd,even,mark,space return -1;
default: x->dcb.fParity = FALSE; // enable parity checking x->dcb.Parity = 0; // 0-4=no,odd,even,mark,space } return 0; }
/* aktivate second stop bit with 1, 0(default)*/ static float set_stopflag(t_comport *x, int nr) { if(nr == 1){ x->dcb.StopBits = 1; // 0,1,2 = 1, 1.5, 2 return 1; } else x->dcb.StopBits = 0; // 0,1,2 = 1, 1.5, 2
return 0; }
/* never testet */ static int set_ctsrts(t_comport *x, int nr) { if(nr == 1){ x->dcb.fOutxCtsFlow = TRUE; // CTS output flow control x->dcb.fRtsControl = RTS_CONTROL_ENABLE; // RTS flow control return 1; } x->dcb.fOutxCtsFlow = FALSE; // CTS output flow control x->dcb.fRtsControl = RTS_CONTROL_DISABLE; // RTS flow control return 0; }
static int set_xonxoff(t_comport *x, int nr) { // x->dcb.fTXContinueOnXoff = FALSE; // XOFF continues Tx
if(nr == 1){ x->dcb.fOutX = TRUE; // XON/XOFF out flow control x->dcb.fInX = TRUE; // XON/XOFF in flow control return 1; }
x->dcb.fOutX = FALSE; // XON/XOFF out flow control x->dcb.fInX = FALSE; // XON/XOFF in flow control return 0; }
static int set_serial(t_comport *x) {
if (SetCommState(x->comhandle, &(x->dcb))) return 1;
return 0; }
static HANDLE open_serial(int com_nr, t_comport *x) { HANDLE fd;
COMMTIMEOUTS timeouts;
float *baud = &(x->baud);
if(com_nr < 0 || com_nr >= COMPORT_MAX) { post("comport open %d, baud %d not valid (args: [portnum] [baud])",com_nr,*baud); return INVALID_HANDLE_VALUE; }
fd = CreateFile( sys_com_port[com_nr],
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
0);
if(fd == INVALID_HANDLE_VALUE) { post("** ERROR ** could not open device %s:\n failure(%d): %s\n", sys_com_port[com_nr],errno,strerror(errno)); return INVALID_HANDLE_VALUE; }
/* Save the Current Port Configuration */
if (!GetCommState(fd, &(x->dcb_old))){ post("** ERROR ** could not get old dcb of device %s\n", sys_com_port[com_nr]);
CloseHandle(fd);
return INVALID_HANDLE_VALUE;
}
memset(&(x->dcb), sizeof(DCB), 0);
if (!GetCommState(fd, &(x->dcb))){ post("** ERROR ** could not get new dcb of device %s\n", sys_com_port[com_nr]);
CloseHandle(fd);
return INVALID_HANDLE_VALUE;
}
x->dcb.fBinary = TRUE; // binary mode, no EOF check
// x->dcb.fOutxDsrFlow = FALSE; // DSR output flow control // x->dcb.fDtrControl = DTR_CONTROL_DISABLE; // DTR flow control type
// x->dcb.fDsrSensitivity = FALSE; // DSR sensitivity
x->dcb.fErrorChar = FALSE; // enable error replacement // x->dcb.fNull = FALSE; // enable null stripping
// DWORD x->dcb.fAbortOnError:1; // abort reads/writes on error
// char x->dcb.XonChar; // Tx and Rx XON character // char x->dcb.XoffChar; // Tx and Rx XOFF character // char x->dcb.ErrorChar; // error replacement character // char x->dcb.EofChar; // end of input character // char x->dcb.EvtChar; // received event character
set_bits(x,8); /* CS8 */ set_stopflag(x,0); /* ~CSTOPB */ set_ctsrts(x,0); /* ~CRTSCTS;*/ set_xonxoff(x,1); /* (IXON | IXOFF | IXANY) */ set_baudrate(x,*baud);
x->comhandle = fd;
if(set_serial(x)) { post("Opened serial line device %s\n",sys_com_port[com_nr]); } else { post("** ERROR ** could not set params to control dcb of device %s\n", sys_com_port[com_nr]); CloseHandle(fd); return INVALID_HANDLE_VALUE; }
if (!GetCommTimeouts(fd, &(x->old_timeouts))){ post("Couldnt get old timeouts for serial device"); };
//setting new timeouts for read to immidiatly return timeouts.ReadIntervalTimeout = MAXDWORD; timeouts.ReadTotalTimeoutMultiplier = 0; timeouts.ReadTotalTimeoutConstant = 0; timeouts.WriteTotalTimeoutMultiplier = 0; timeouts.WriteTotalTimeoutConstant = 0;
if (!SetCommTimeouts(fd, &timeouts)){ post("Couldnt set timeouts for serial device"); return INVALID_HANDLE_VALUE; };
return fd; }
static HANDLE close_serial(t_comport *x) { if(x->comhandle != INVALID_HANDLE_VALUE){
if (!SetCommState(x->comhandle, &(x->dcb_old)) )
{
post("** ERROR ** could not reset params to DCB of device %s\n",
sys_com_port[x->comport]);
}
if (!SetCommTimeouts(x->comhandle, &(x->old_timeouts))){
post("Couldnt reset old_timeouts for serial device");
};
CloseHandle(x->comhandle);
}
return INVALID_HANDLE_VALUE; }
static int write_serial(t_comport *x, unsigned char chr) { OVERLAPPED osWrite = {0}; DWORD dwWritten; DWORD dwRes;
/* post("open send %d",chr); */
if (!WriteFile(x->comhandle, &chr, 1, &dwWritten, &osWrite)) {
if (GetLastError() != ERROR_IO_PENDING)
post("WriteFile failed, but isn't delayed on serialdevice");
return 0;
}
return 1;
}
#else /* NT */ /* ----------------- POSIX - UNIX ------------------------------ */
static float set_baudrate(t_comport *x,t_float baud) { struct termios *tio = &(x->com_termio);
long baudbits = get_baud_ratebits(&baud);
cfsetispeed(tio, baudbits); cfsetospeed(tio, baudbits);
return baud; }
/* bits are 5,6,7,8(default) */
static float set_bits(t_comport *x, int nr) { struct termios *tio = &(x->com_termio); tio->c_cflag &= ~CSIZE; switch(nr){ case 5: tio->c_cflag |= CS5; return 5; case 6: tio->c_cflag |= CS6; return 6; case 7: tio->c_cflag |= CS7; return 7; default: tio->c_cflag |= CS8; } return 8; }
/* 1 ... Parity even, -1 parity odd , 0 (default) no parity */ static float set_parity(t_comport *x,int n) { struct termios *tio = &(x->com_termio);
switch(n){ case 1: tio->c_cflag |= PARENB; tio->c_cflag &= ~PARODD; return 1; case -1: tio->c_cflag |= PARENB | PARODD; return -1; default: tio->c_cflag &= ~PARENB; } return 0; }
/* aktivate second stop bit with 1, 0(default)*/ static float set_stopflag(t_comport *x, int nr) { struct termios *tio = &(x->com_termio);
if(nr == 1){ tio->c_cflag |= CSTOPB; return 1; } else tio->c_cflag &= ~CSTOPB; return 0; }
/* never testet */ static int set_ctsrts(t_comport *x, int nr) { struct termios *tio = &(x->com_termio);
if(nr == 1){ tio->c_cflag |= CRTSCTS; return 1; } tio->c_cflag &= ~CRTSCTS; return 0; }
static int set_xonxoff(t_comport *x, int nr) { struct termios *tio = &(x->com_termio);
if(nr == 1){ tio->c_iflag |= (IXON | IXOFF | IXANY); return 1; }
tio->c_iflag &= ~IXON & ~IXOFF & ~IXANY; return 0; }
static int open_serial(int com_nr, t_comport *x) { HANDLE fd; struct termios *old = &(x->oldcom_termio); struct termios *new = &(x->com_termio); float *baud = &(x->baud);
if(com_nr < 0 || com_nr >= COMPORT_MAX) { post("comport open %d, baud %d not valid (args: [portnum] [baud])"); return INVALID_HANDLE_VALUE; }
if((fd = open(sys_com_port[com_nr], OPENPARAMS)) == INVALID_HANDLE_VALUE) { post("** ERROR ** could not open device %s:\n failure(%d): %s\n", sys_com_port[com_nr],errno,strerror(errno)); return INVALID_HANDLE_VALUE; }
/* set no wait on any operation */ fcntl(fd, F_SETFL, FNDELAY);
/* Save the Current Port Configuration */ if(tcgetattr(fd, old) == -1 || tcgetattr(fd, new) == -1){ post("** ERROR ** could not get termios-structure of device %s\n", sys_com_port[com_nr]); close(fd); return INVALID_HANDLE_VALUE; }
/* Setupt the new port configuration...NON-CANONICAL INPUT MODE .. as defined in termios.h */
/* enable input and ignore modem controls */ new->c_cflag |= (CREAD | CLOCAL);
/* always nocanonical, this means raw i/o no terminal */ new->c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
/* no post processing */ new->c_oflag &= ~OPOST;
/* setup to return after 0 seconds
..if no characters are received
TIME units are assumed to be 0.1 secs */
/* not needed anymore ??? in new termios in linux
new->c_cc[VMIN] = 0;
new->c_cc[VTIME] = 0;
*/
/* defaults, see input */
set_bits(x,8); /* CS8 */ set_stopflag(x,0); /* ~CSTOPB */ set_ctsrts(x,0); /* ~CRTSCTS;*/ set_xonxoff(x,1); /* (IXON | IXOFF | IXANY) */ set_baudrate(x,*baud);
if(tcsetattr(fd, TCSAFLUSH, new) != -1) { post("Opened serial line device %s\n",sys_com_port[com_nr]); } else { post("** ERROR ** could not set params to ioctl of device %s\n", sys_com_port[com_nr]); close(fd); return INVALID_HANDLE_VALUE; }
return fd; }
static int close_serial(t_comport *x) { struct termios *tios = &(x->com_termio); HANDLE fd = x->comhandle;
if(fd != INVALID_HANDLE_VALUE){ tcsetattr(fd, TCSANOW, tios); close(fd); } return INVALID_HANDLE_VALUE; }
static int set_serial(t_comport *x) { if(tcsetattr(x->comhandle, TCSAFLUSH, &(x->com_termio)) == -1) return 0; return 1; }
static int write_serial(t_comport *x, unsigned char chr) {
return write(x->comhandle,(char *) &chr,1);
/* flush pending I/O chars */
/* but nowadays discards them ;-(
else{
ioctl(x->comhandle,TCFLSH,TCOFLUSH);
}
*/
}
#endif /* else NT */
/* ------------------- serial pd methods --------------------------- */ static void comport_pollintervall(t_comport *x, t_floatarg g) { if (g < 1) g = 1; x->x_deltime = g; }
static void comport_tick(t_comport *x) { unsigned char chr; int err; HANDLE fd = x->comhandle;
x->x_hit = 0;
if(fd == INVALID_HANDLE_VALUE) return;
/* while there are bytes, read them and send them out, ignore errors */ #ifdef NT { DWORD dwCommEvent; DWORD dwRead;
err = 0;
// if (!SetCommMask(x->comhandle, EV_RXCHAR)) // post(" Error setting communications event mask for serial device");
// for ( ; ; ) { // if (WaitCommEvent(x->comhandle, &dwCommEvent,NULL)) { do {
if(ReadFile(x->comhandle, &chr, 1, &dwRead, NULL))
if(dwRead > 0)
outlet_float(x->x_obj.ob_outlet, (t_float) chr);
else{
err = -1;
break;
}
} while (dwRead);
// } // else{ // post("serial dev: Error in WaitCommEvent"); // break; // } //} } #else { fd_set com_rfds; FD_ZERO(&com_rfds); FD_SET(fd,&com_rfds);
while((err=select(fd+1,&com_rfds,NULL,NULL,&null_tv)) > 0) {
err = read(fd,(char *) &chr,1);
/* while( (err = read(fd,(char *) &chr,1)) > 0){ */
outlet_float(x->x_obj.ob_outlet, (t_float) chr);
};
} #endif
if(err < 0){ /* if an readerror detected */ if(x->rxerrors == 0) /* post it once */ post("RXERRORS on serial line\n"); x->rxerrors = 1; /* remember */ }
if (!x->x_hit) clock_delay(x->x_clock, 1); }
static void comport_float(t_comport *x,t_float f) { unsigned char chr = ((int) f) & 0xFF; /* brutal conv */
if (write_serial(x,chr) != 1) { post("Write error, maybe TX-OVERRUNS on serial line"); } }
static void *comport_new(t_floatarg comnr, t_floatarg fbaud) {
t_comport test; t_comport *x; int com_nr = comnr; HANDLE fd;
/* Open the Comport for RD and WR and get a handle */ test.baud = fbaud; fd = open_serial(com_nr,&test);
if(fd == INVALID_HANDLE_VALUE ){ /* postings in open routine */ return 0; }
/* Now nothing really bad could happen so we create the class */
x = (t_comport *)pd_new(comport_class);
x->comport = com_nr; x->baud = test.baud; x->comhandle = fd; /* holds the comport handle */
#ifdef NT
memcpy(&(test.dcb_old),&(x->dcb_old),sizeof(DCB)); // save the old com config memcpy(&(test.dcb),&(x->dcb),sizeof(DCB)); // for the new com config
#else
/* save the old com and new com config */
bcopy(&(test.oldcom_termio),&(x->oldcom_termio),sizeof(struct termios));
bcopy(&(test.com_termio),&(x->com_termio),sizeof(struct termios));
#endif
x->rxerrors = 0; /* holds the rx line errors */
outlet_new(&x->x_obj, &s_float);
x->x_hit = 0; x->x_deltime = 1; x->x_clock = clock_new(x, (t_method)comport_tick);
clock_delay(x->x_clock, x->x_deltime);
return x; }
static void comport_free(t_comport *x) { post("close serial...");
clock_unset(x->x_clock); clock_free(x->x_clock); x->comhandle = close_serial(x); }
/* ---------------- use serial settings ------------- */
static void comport_baud(t_comport *x,t_floatarg f) { if(f == x->baud){ post("baudrate already %f\n",x->baud); return; }
x->baud = set_baudrate(x,f);
if(x->comhandle == INVALID_HANDLE_VALUE)return;
if(set_serial(x) == 0){ post("** ERROR ** could not set baudrate of device %s\n", sys_com_port[x->comport]); } else post("set baudrate of %s to %f\n",sys_com_port[x->comport],x->baud); }
static void comport_bits(t_comport *x,t_floatarg f) { f = set_bits(x,f);
if(x->comhandle == INVALID_HANDLE_VALUE)return;
if(set_serial(x) == 0){ post("** ERROR ** could not set bits of device %s\n", sys_com_port[x->comport]); } else post("set bits of %s to %f\n",sys_com_port[x->comport],f); }
static void comport_parity(t_comport *x,t_floatarg f) { f = set_parity(x,f);
if(x->comhandle == INVALID_HANDLE_VALUE)return;
if(set_serial(x) == 0){ post("** ERROR ** could not set extra paritybit of device %s\n", sys_com_port[x->comport]); } else post("set extra paritybit of %s to %f\n",sys_com_port[x->comport],f); }
static void comport_stopbit(t_comport *x,t_floatarg f) { f = set_stopflag(x,f);
if(x->comhandle == INVALID_HANDLE_VALUE)return;
if(set_serial(x) == 0){ post("** ERROR ** could not set extra stopbit of device %s\n", sys_com_port[x->comport]); } else post("set extra stopbit of %s to %f\n",sys_com_port[x->comport],f); }
static void comport_rtscts(t_comport *x,t_floatarg f) { f = set_ctsrts(x,f);
if(x->comhandle == INVALID_HANDLE_VALUE)return;
if(set_serial(x) == 0){ post("** ERROR ** could not set rts_cts of device %s\n", sys_com_port[x->comport]); } else post("set rts-cts of %s to %f\n",sys_com_port[x->comport],f); }
static void comport_xonxoff(t_comport *x,t_floatarg f) { f = set_xonxoff(x,f);
if(x->comhandle == INVALID_HANDLE_VALUE)return;
if(set_serial(x) == 0){ post("** ERROR ** could not set xonxoff of device %s\n", sys_com_port[x->comport]); } else post("set xonxoff of %s to %f\n",sys_com_port[x->comport],f); }
static void comport_close(t_comport *x) { clock_unset(x->x_clock); x->x_hit = 1; x->comhandle = close_serial(x); }
static void comport_open(t_comport *x, t_floatarg f) { if(x->comhandle != INVALID_HANDLE_VALUE) comport_close(x);
x->comhandle = open_serial(f,x);
clock_delay(x->x_clock, x->x_deltime); }
/* dangerous but if you really have some stupid devicename ... you can open any file on systems if suid is set on pd be careful */
static void comport_devicename(t_comport *x, t_symbol *s)
{
if(x->comport >= 0 && x->comport < COMPORT_MAX){
sys_com_port[x->comport] = s->s_name;
}
}
static void comport_print(t_comport *x, t_symbol *s, int argc, t_atom *argv) { static char buf[256]; while(argc--) { atom_string(argv++, buf, 255); char *pch = buf; while(*pch != 0) { write_serial(x, *pch++); } if(argc > 0) { write_serial(x, ' '); } } } /* ---------------- SETUP OBJECTS ------------------ */
void comport_setup(void) { comport_class = class_new(gensym("comport"), (t_newmethod)comport_new, (t_method)comport_free, sizeof(t_comport), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(comport_class, (t_method)comport_float);
/* class_addbang(comport_class, comport_bang */
class_addmethod(comport_class, (t_method)comport_baud, gensym("baud"), A_FLOAT, 0);
class_addmethod(comport_class, (t_method)comport_bits, gensym("bits"), A_FLOAT, 0); class_addmethod(comport_class, (t_method)comport_stopbit, gensym("stopbit"), A_FLOAT, 0); class_addmethod(comport_class, (t_method)comport_rtscts, gensym("rtscts"), A_FLOAT, 0); class_addmethod(comport_class, (t_method)comport_parity, gensym("parity"), A_FLOAT, 0); class_addmethod(comport_class, (t_method)comport_xonxoff, gensym("xonxoff"), A_FLOAT, 0); class_addmethod(comport_class, (t_method)comport_close, gensym("close"), 0); class_addmethod(comport_class, (t_method)comport_open, gensym("open"), A_FLOAT, 0); class_addmethod(comport_class, (t_method)comport_devicename, gensym("devicename"), A_SYMBOL, 0); class_addmethod(comport_class, (t_method)comport_print, gensym("print"), A_GIMME, 0);
class_addmethod(comport_class, (t_method)comport_pollintervall, gensym("pollintervall"), A_FLOAT, 0); #ifndef NT null_tv.tv_sec = 0; /* no wait */ null_tv.tv_usec = 0; #endif }
-
Marc Boon