serialport.types source code

1 /// Definitions of using types
2 module serialport.types;
3 
4 ///
5 enum Parity
6 {
7     none, ///
8     odd,  ///
9     even  ///
10 }
11 
12 ///
13 enum DataBits : uint
14 {
15    data8 = 8, ///
16    data7 = 7, ///
17    data6 = 6, ///
18    data5 = 5, ///
19 }
20 
21 ///
22 enum StopBits
23 {
24    one, ///
25    onePointFive, ///
26    two ///
27 }
28 
29 package
30 {
31     version(Posix)
32     {
33         import core.sys.posix.unistd;
34         version(linux)
35             import core.sys.linux.termios;
36         else
37             import core.sys.posix.termios;
38 
39         import core.sys.posix.fcntl;
40         import core.sys.posix.sys.select;
41         import core.sys.posix.sys.ioctl;
42         import core.stdc.errno;
43         import std.algorithm;
44         import std.file;
45 
46         alias posixRead = core.sys.posix.unistd.read;
47         alias posixWrite = core.sys.posix.unistd.write;
48         alias posixClose = core.sys.posix.unistd.close;
49     }
50     version(Windows)
51     {
52         import core.sys.windows.windows;
53         import std.bitmanip;
54 
55         enum NOPARITY    = 0x0;
56         enum EVENPARITY  = 0x2;
57         enum MARKPARITY  = 0x3;
58         enum ODDPARITY   = 0x1;
59         enum SPACEPARITY = 0x4;
60 
61         enum ONESTOPBIT   = 0x0;
62         enum ONE5STOPBITS = 0x1;
63         enum TWOSTOPBITS  = 0x2;
64 
65         struct DCB
66         {
67             DWORD DCBlength;
68             DWORD BaudRate;
69 
70             mixin(bitfields!(
71             DWORD, "fBinary",           1,
72             DWORD, "fParity",           1,
73             DWORD, "fOutxCtsFlow",      1,
74             DWORD, "fOutxDsrFlow",      1,
75             DWORD, "fDtrControl",       2,
76             DWORD, "fDsrSensitivity",   1,
77             DWORD, "fTXContinueOnXoff", 1,
78             DWORD, "fOutX",             1,
79             DWORD, "fInX",              1,
80             DWORD, "fErrorChar",        1,
81             DWORD, "fNull",             1,
82             DWORD, "fRtsControl",       2,
83             DWORD, "fAbortOnError",     1,
84             DWORD, "fDummy2",           17));
85 
86             WORD  wReserved;
87             WORD  XonLim;
88             WORD  XoffLim;
89             BYTE  ByteSize;
90             BYTE  Parity;
91             BYTE  StopBits;
92             ubyte  XonChar;
93             ubyte  XoffChar;
94             ubyte  ErrorChar;
95             ubyte  EofChar;
96             ubyte  EvtChar;
97             WORD  wReserved1;
98         }
99 
100         struct COMMTIMEOUTS
101         {
102             DWORD ReadIntervalTimeout;
103             DWORD ReadTotalTimeoutMultiplier;
104             DWORD ReadTotalTimeoutConstant;
105             DWORD WriteTotalTimeoutMultiplier;
106             DWORD WriteTotalTimeoutConstant;
107         }
108 
109         extern(Windows)
110         {
111             bool GetCommState(HANDLE hFile, DCB* lpDCB);
112             bool SetCommState(HANDLE hFile, DCB* lpDCB);
113             bool SetCommTimeouts(HANDLE hFile, COMMTIMEOUTS* lpCommTimeouts);
114         }
115     }
116 }
117 
118 version (Posix)
119 {
120     enum unixBaudList = [ 0: B0, 50: B50, 75: B75, 110: B110, 134: B134,
121                         150: B150, 200: B200, 300: B300, 600: B600,
122                         1200: B1200, 1800: B1800, 2400: B2400,
123                         4800: B4800, 9600: B9600, 19200: B19200,
124                         38400: B38400, 57600: B57600, 115200: B115200,
125                         230400: B230400 ];
126 
127     enum unixUintBaudList = invert(unixBaudList);
128 
129     private auto invert(T)(T list)
130     {
131         static if (is(T == V[K], V, K))
132         {
133             K[V] ret;
134             foreach (key; list.keys)
135                 ret[list[key]] = key;
136             return ret;
137         }
138         else static assert(0, "unsupported type");
139     }
140 }