HG_REPOSITORIES/LPP/INSTRUMENTATION/lppserial Commit - r33:36f4e246ea65

Satrted Port enumeration feature.

jeandet@pc-de-jeandet3.LAB-LPP.LOCAL -

r33:36f4e246ea65 alexis

parent child

Context file:

r33:36f4e246ea65

Collapse all files

src/RS232.h +14 0

             // SOPSUYSI_RS232.h
             #ifndef RS232_H
             #define RS232_H
             #define debug
             #define badPortValue -1
             #define rs232noerr 0
             typedef int  rs232port_t;
             typedef int  rs232speed_t;
             typedef enum {rs232OneStop,rs232One5Stop,rs232TwoStop}rs232stop;
             typedef enum {rs232parityNo,rs232parityOdd,rs232parityEven}rs232parity;
+            #ifdef __cplusplus
+            extern "C" {
+            #endif
+            typedef struct rs232portslist_t
+            {
+            	char* name;
+            	struct rs232portslist_t* next;
+            }rs232portslist_t;
+            #ifdef __cplusplus
+            }
+            #endif
             #ifdef __cplusplus
                 #define rs232extern extern "C"
             #else
                 #define rs232extern extern
             #endif
             rs232extern rs232port_t rs232open(char* psPortName);
+            rs232extern rs232portslist_t* rs232getportlist();
+            rs232extern void rs232deleteportlist(rs232portslist_t* list);
             rs232extern int rs232close(rs232port_t fd);
             rs232extern int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop);
             rs232extern int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize);
             rs232extern int rs232read(rs232port_t fd,char *psRead, int ReadBufferSize);
             rs232extern int rs232setparity(rs232port_t fd, rs232parity Parity);
             rs232extern int rs232setnbstop(rs232port_t fd, rs232stop NbStop);
             rs232extern int rs232setcsize(rs232port_t fd, int ChSize);
             rs232extern int rs232setbaudrate(rs232port_t fd, int baudrate);
             rs232extern int rs232setRTS(rs232port_t fd);
             rs232extern int rs232clearRTS(rs232port_t fd);
             rs232extern int rs232setDTR(rs232port_t fd);
             rs232extern int rs232clearDTR(rs232port_t fd);
             rs232extern int rs232saferead(rs232port_t fd,char* data,int count );
             rs232extern int rs232safewrite(rs232port_t fd,char* data,int count);
             #endif

src/RS232_unix.c +11 0

             #include <stdio.h>
             #include <unistd.h>
             #include <fcntl.h>
             #include <string.h>
             #include <errno.h>
+            #include <malloc.h>
             #include "rs232config.h"
             #ifdef HAVE_TERMIOS_H
                    #include <termios.h>
             #endif
             #ifdef HAVE_TERMIO_H
                    #include <termio.h>
             #endif
             #include "RS232.h"
             #ifdef HAVE_WINDOWS_H
             #else
             #ifdef HAVE_TERMIOS_H
             rs232speed_t rs232cfspeed(unsigned int BaudeRate);
             rs232port_t rs232open(char* psPortName)
             {
                     rs232port_t fd;
             	fd = (rs232port_t)open(psPortName, O_RDWR | O_NOCTTY | O_NDELAY);
             	fcntl((int)fd, F_SETFL, 0);
             	//fd = open(psPortName, O_RDWR | O_NOCTTY);
             	#ifdef debug
             		if(fd==-1)printf("can't open Port\n");
             	#endif
             	return fd;
             }
             int rs232close(rs232port_t fd)
             {
             	if ((int)fd == -1)
             	{
             		return -1;
             	}
             	else
             	{
             		close(fd);
             		return 0;
             	}
             }
+            rs232portslist_t* rs232getportlist()
+            {
+            }
+            void rs232deleteportlist(rs232portslist_t* list)
+            {
+            }
             int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop)
             {
               if ((int)fd == -1)
             	{
             		return -1;
             	}
             	else
             	{
             		struct termios terminos;
             		tcgetattr(fd, &terminos);
             		cfsetispeed(&terminos, rs232cfspeed(BaudeRate));
             		cfsetospeed(&terminos, rs232cfspeed(BaudeRate));
             		terminos.c_cflag |= (CLOCAL | CREAD);
             		rs232cfparity((int)fd, &terminos, Parity);
             		rs232cfnbstop((int)fd, &terminos, NbStop);
             		rs232cfcsize((int)fd, &terminos, ChSize);
             		terminos.c_cc[VMIN]=0;
                     	terminos.c_cc[VTIME]=1;
                     	tcflush(fd, TCIFLUSH);
             		#ifdef debug
             			if(tcsetattr(fd, TCSANOW, &terminos)!=0)printf("bad setup\n");
             		#else
             			tcsetattr(fd, TCSANOW, &terminos);
             		#endif
             		return 0;
             	}
             }
             int rs232setbaudrate(rs232port_t fd, int baudrate)
             {
               	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
                             struct termios terminos;
             		tcgetattr((int)fd, &terminos);
                             cfsetispeed(&terminos, rs232cfspeed(baudrate));
             		cfsetospeed(&terminos, rs232cfspeed(baudrate));
                             tcsetattr((int)fd, TCSANOW, &terminos);
             		return 0;
             	}
             }
             int rs232setparity(rs232port_t fd, rs232parity Parity)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
                             struct termios terminos;
             		tcgetattr((int)fd, &terminos);
             		terminos.c_cflag &= ~PARENB;
             		terminos.c_cflag &= ~PARODD;
             		switch(Parity)
             		{
             			case rs232parityNo:
             				terminos.c_cflag &= ~PARENB;
             				break;
             			case rs232parityOdd:
             				terminos.c_cflag |= PARENB;
             				terminos.c_cflag |= PARODD;
             				break;
             			case rs232parityEven:
             				terminos.c_cflag |= PARENB;
             				terminos.c_cflag &= ~PARODD;
             				break;
             			default:
             				terminos.c_cflag &= ~PARENB;
             				break;
             		}
                             tcsetattr((int)fd, TCSANOW, &terminos);
             		return 0;
             	}
             }
             int rs232setnbstop(rs232port_t fd, rs232stop NbStop)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
                             struct termios terminos;
             		tcgetattr((int)fd, &terminos);
             		switch(NbStop)
             		{
             			case rs232OneStop:
             			     terminos.c_cflag &= ~CSTOPB;
             			     break;
                                     case rs232One5Stop:
             				terminos.c_cflag |= CSTOPB;
                                             break;
             			case rs232TwoStop:
             				terminos.c_cflag |= CSTOPB;
                                             break;
             			default:
             				terminos.c_cflag &= ~CSTOPB;
                                             break;
             		}
             		tcsetattr((int)fd, TCSANOW, &terminos);
             		return 0;
             	}
             }
             int rs232setcsize(rs232port_t fd, int ChSize)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
                             struct termios terminos;
             		tcgetattr((int)fd, &terminos);
             		terminos.c_cflag &= ~CSIZE;
             		switch(ChSize)
             		{
             			case 5:
             				terminos.c_cflag |= CS5;
             			break;
             			case 6:
             				terminos.c_cflag |= CS6;
             			break;
             			case 7:
             				terminos.c_cflag |= CS7;
             			break;
             			default:
             				terminos.c_cflag |= CS8;
             			break;
             		}
             		tcsetattr((int)fd, TCSANOW, &terminos);
             		return 0;
             	}
             }
             rs232speed_t rs232cfspeed(unsigned int BaudeRate)
             {
             	if(BaudeRate<25)
             		return B0;
             	if(BaudeRate<67)
             		return B50;
             	if(BaudeRate<93)
             		return B75;
             	if(BaudeRate<123)
             		return B110;
             	if(BaudeRate<142)
             		return B134;
             	if(BaudeRate<175)
             		return B150;
             	if(BaudeRate<250)
             		return B200;
             	if(BaudeRate<450)
             		return B300;
             	if(BaudeRate<900)
             		return B600;
             	if(BaudeRate<1500)
             		return B1200;
             	if(BaudeRate<2100)
             		return B1800;
             	if(BaudeRate<3600)
             		return B2400;
             	if(BaudeRate<7200)
             		return B4800;
             	if(BaudeRate<1400)
             		return B9600;
             	if(BaudeRate<28800)
             		return B19200;
             	if(BaudeRate<48000)
             		return B38400;
             	if(BaudeRate<86400)
             		return B57600;
             	if(BaudeRate<172800)
             		return B115200;
             	else
             		return B230400;
             }
             int rs232cfparity(int fd, struct termios *terminos, rs232parity Parity)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
             		terminos->c_cflag &= ~PARENB;
             		terminos->c_cflag &= ~PARODD;
                             switch(Parity)
             		{
             			case rs232parityNo:
             				terminos->c_cflag &= ~PARENB;
             				terminos->c_cflag &= ~PARODD;
             				break;
             			case rs232parityOdd:
             				terminos->c_cflag |= PARENB;
             				terminos->c_cflag |= PARODD;
             				break;
             			case rs232parityEven:
             				terminos->c_cflag |= PARENB;
             				terminos->c_cflag &= ~PARODD;
             				break;
             			default:
             				terminos->c_cflag &= ~PARENB;
             				terminos->c_cflag &= ~PARODD;
             				break;
             		}
             		return 0;
             	}
             }
             int rs232cfnbstop(int fd, struct termios *terminos, rs232stop NbStop)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
             		switch(NbStop)
             		{
             			case 2:
             				terminos->c_cflag |= CSTOPB;
             			break;
             			default:
             				terminos->c_cflag &= ~CSTOPB;
             			break;
             		}
             		return 0;
             	}
             }
             int rs232cfcsize(int fd, struct termios *terminos, int ChSize)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
             		terminos->c_cflag &= ~CSIZE;
             		switch(ChSize)
             		{
             			case 5:
             				terminos->c_cflag |= CS5;
             			break;
             			case 6:
             				terminos->c_cflag |= CS6;
             			break;
             			case 7:
             				terminos->c_cflag |= CS7;
             			break;
             			default:
             				terminos->c_cflag |= CS8;
             			break;
             		}
             		return 0;
             	}
             }
             int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize)
             {
             	if ((int)fd == -1)
             	{
             		return -1;
             	}
             	else
             	{
             		return write((int)fd, psWrite, WriteBufferSize);
             	}
             }
             int rs232read(rs232port_t fd,char *psReadHex, int ReadBufferSize)
             {
             	if ((int)fd == -1)
             	{
             		return -1;
             	}
             	else
             	{
             		return read((int)fd, psReadHex, ReadBufferSize);
             	}
             }
             int rs232setRTS(rs232port_t fd)
             {
              int status;
              ioctl((int)fd, TIOCMGET, &status);
              status &= ~TIOCM_RTS;
              if (ioctl((int)fd, TIOCMSET, &status))
              {
                return -1;
              }
              return 0;
             }
             int rs232clearRTS(rs232port_t fd)
             {
              int status;
              ioctl((int)fd, TIOCMGET, &status);
              status |= TIOCM_RTS;
              if (ioctl((int)fd, TIOCMSET, &status))
              {
                return -1;
              }
              return 0;
             }
             int rs232setDTR(rs232port_t fd)
             {
              int status;
              ioctl((int)fd, TIOCMGET, &status);
              status &= ~TIOCM_DTR;
              if (ioctl((int)fd, TIOCMSET, &status))
              {
                return -1;
              }
              return 0;
             }
             int rs232clearDTR(rs232port_t fd)
             {
              int status;
              ioctl((int)fd, TIOCMGET, &status);
              status |= TIOCM_DTR;
              if (ioctl((int)fd, TIOCMSET, &status))
              {
                return -1;
              }
              return 0;
             }
             int rs232saferead(rs232port_t fd,char* data,int count )
             {
             	int read=0;
             	int i=0;
             	for(i=0;i<100;i++)
             	{
             		read = rs232read((int)fd,data,count);
             		count -=read;
             		data+=read;
             		if(count==0)
             			return 0;
             	}
             	return -1;
             }
             int rs232safewrite(rs232port_t fd,char* data,int count)
             {
             	int written=0;
             	int i=0;
             	for(i=0;i<1000;i++)
             	{
             		written = rs232write((int)fd,data+written,count);
             		count-=written;
             		data+=written;
             		if(count==0)
             			return 0;
             	}
             	return -1;
             }
             #endif
             #endif //#ifdef HAVE_TERMIOS_H

src/RS232_win.c +12 0

             #include "rs232config.h"
             #include <stdio.h>
             #include <unistd.h>
             #include <fcntl.h>
             #include <string.h>
             #include <errno.h>
+            #include <malloc.h>
             #ifdef HAVE_WINDOWS_H
                    #include <windows.h>
             #endif
             #include "RS232.h"
             #ifdef HAVE_WINDOWS_H
             int privatedecodeparity(rs232parity Parity )
             {
             	switch(Parity)
             	{
             		case rs232parityNo:
             			return NOPARITY;
             			break;
             		case rs232parityOdd:
             			return ODDPARITY;
             			break;
             		case rs232parityEven:
             			return EVENPARITY;
             			break;
             		default:
             			return NOPARITY;
             			break;
             	}
             }
             int privatedecodestop(rs232stop NbStop)
             {
             	switch(NbStop)
             	{
             		case rs232OneStop:
             			return ONESTOPBIT;
             			break;
             		case rs232One5Stop:
             			return ONE5STOPBITS;
             			break;
             		case rs232TwoStop:
             			return TWOSTOPBITS;
             			break;
             		default:
             			return ONESTOPBIT;
             			break;
             	}
             }
             rs232speed_t rs232cfspeed(unsigned int BaudeRate)
             {
             	if(BaudeRate<123)
             		return (rs232speed_t)CBR_110;
             	if(BaudeRate<450)
             		return (rs232speed_t)CBR_300;
             	if(BaudeRate<900)
             		return (rs232speed_t)CBR_600;
             	if(BaudeRate<1500)
             		return (rs232speed_t)CBR_1200;
             	if(BaudeRate<3600)
             		return (rs232speed_t)CBR_2400;
             	if(BaudeRate<7200)
             		return (rs232speed_t)CBR_4800;
             	if(BaudeRate<14000)
             		return (rs232speed_t)CBR_9600;
             	if(BaudeRate<16800)
             		return (rs232speed_t)CBR_14400;
             	if(BaudeRate<28800)
             		return (rs232speed_t)CBR_19200;
             	if(BaudeRate<48000)
             		return (rs232speed_t)CBR_38400;
             	if(BaudeRate<86400)
             		return (rs232speed_t)CBR_57600;
             	if(BaudeRate<172800)
             		return (rs232speed_t)CBR_115200;
             	else
             		return (rs232speed_t)CBR_256000;
             }
             rs232port_t rs232open(char* psPortName)
             {
                     rs232port_t fd;
                     fd = (rs232port_t)CreateFile(psPortName,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
                     #ifdef debug
             		if(fd==(rs232port_t)INVALID_HANDLE_VALUE)
             		{
             			printf("can't open Port\n");
             			return (rs232port_t)badPortValue;
             		}
             	#endif
             	return fd;
             }
             int rs232close(rs232port_t fd)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             CloseHandle((HANDLE)fd);
             		return rs232noerr;
             	}
             }
+            rs232portslist_t* rs232getportlist()
+            {
+            }
+            void rs232deleteportlist(rs232portslist_t* list)
+            {
+            }
             int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
                             dcbSerialParams.BaudRate=rs232cfspeed(BaudeRate);
                             dcbSerialParams.ByteSize=ChSize;
                             dcbSerialParams.StopBits=privatedecodestop(NbStop);
                             dcbSerialParams.Parity=privatedecodeparity(Parity);
                             SetCommState((HANDLE)fd, &dcbSerialParams);
                             COMMTIMEOUTS timeouts={0};
                             timeouts.ReadIntervalTimeout=100;
                             timeouts.ReadTotalTimeoutConstant=100;
                             timeouts.ReadTotalTimeoutMultiplier=1;
                             timeouts.WriteTotalTimeoutConstant=100;
                             timeouts.WriteTotalTimeoutMultiplier=10;
                             SetCommTimeouts((HANDLE)fd, &timeouts);
             		return rs232noerr;
             	}
             }
             int rs232setbaudrate(rs232port_t fd, int baudrate)
             {
               	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
                             dcbSerialParams.BaudRate=rs232cfspeed(baudrate);
                             SetCommState((HANDLE)fd, &dcbSerialParams);
             		return rs232noerr;
             	}
             }
             int rs232setparity(rs232port_t fd, rs232parity Parity)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
                             dcbSerialParams.Parity = privatedecodeparity(Parity);
                             SetCommState((HANDLE)fd, &dcbSerialParams);
             		return rs232noerr;
             	}
             }
             int rs232setnbstop(rs232port_t fd, rs232stop NbStop)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
                             dcbSerialParams.StopBits = privatedecodestop(NbStop);
             		SetCommState((HANDLE)fd, &dcbSerialParams);
             		return rs232noerr;
             	}
             }
             int rs232setcsize(rs232port_t fd, int ChSize)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
             		dcbSerialParams.ByteSize = ChSize;
             		SetCommState((HANDLE)fd, &dcbSerialParams);
             		return rs232noerr;
             	}
             }
             int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
             		DWORD dwBytesWriten = 0;
                             WriteFile((HANDLE)fd, psWrite, WriteBufferSize, &dwBytesWriten, NULL);
                             return  dwBytesWriten;
             	}
             }
             int rs232read(rs232port_t fd,char *psRead, int ReadBufferSize)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DWORD dwBytesRead = 0;
                             ReadFile((HANDLE)fd, psRead, ReadBufferSize, &dwBytesRead, NULL);
                             return  dwBytesRead;
             	}
             }
             int rs232saferead(rs232port_t fd,char* data,int count )
             {
             	int read=0;
             	int i=0;
             	for(i=0;i<100;i++)
             	{
             		read = rs232read(fd,data,count);
             		count -=read;
             		data+=read;
             		if(count==0)
             			return rs232noerr;
             	}
             	return -1;
             }
             int rs232safewrite(rs232port_t fd,char* data,int count)
             {
             	int written=0;
             	int i=0;
             	for(i=0;i<1000;i++)
             	{
             		written = rs232write(fd,data+written,count);
             		count-=written;
             		data+=written;
             		if(count==0)
             			return rs232noerr;
             	}
             	return -1;
             }
             int rs232setRTS(rs232port_t fd)
             {
               if(EscapeCommFunction((HANDLE)fd, CLRRTS))
               	return rs232noerr;
               return -1;
             }
             int rs232clearRTS(rs232port_t fd)
             {
              if(EscapeCommFunction((HANDLE)fd, SETRTS))
               	return rs232noerr;
               return -1;
             }
             int rs232setDTR(rs232port_t fd)
             {
              if(EscapeCommFunction((HANDLE)fd, CLRDTR))
               	return rs232noerr;
               return -1;
             }
             int rs232clearDTR(rs232port_t fd)
             {
              if(EscapeCommFunction((HANDLE)fd, SETDTR))
               	return rs232noerr;
               return -1;
             }
             #endif //#ifdef HAVE_WINDOWS_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages