1 /*
2 * Copyright 2013 The Netty Project
3 *
4 * The Netty Project licenses this file to you under the Apache License,
5 * version 2.0 (the "License"); you may not use this file except in compliance
6 * with the License. You may obtain a copy of the License at:
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations
14 * under the License.
15 */
16 package io.netty.channel.rxtx;
17
18 import gnu.io.SerialPort;
19 import io.netty.buffer.ByteBufAllocator;
20 import io.netty.channel.ChannelConfig;
21 import io.netty.channel.MessageSizeEstimator;
22 import io.netty.channel.RecvByteBufAllocator;
23
24 /**
25 * A configuration class for RXTX device connections.
26 *
27 * <h3>Available options</h3>
28 *
29 * In addition to the options provided by {@link ChannelConfig},
30 * {@link DefaultRxtxChannelConfig} allows the following options in the option map:
31 *
32 * <table border="1" cellspacing="0" cellpadding="6">
33 * <tr>
34 * <th>Name</th><th>Associated setter method</th>
35 * </tr><tr>
36 * <td>{@link RxtxChannelOption#BAUD_RATE}</td><td>{@link #setBaudrate(int)}</td>
37 * </tr><tr>
38 * <td>{@link RxtxChannelOption#DTR}</td><td>{@link #setDtr(boolean)}</td>
39 * </tr><tr>
40 * <td>{@link RxtxChannelOption#RTS}</td><td>{@link #setRts(boolean)}</td>
41 * </tr><tr>
42 * <td>{@link RxtxChannelOption#STOP_BITS}</td><td>{@link #setStopbits(Stopbits)}</td>
43 * </tr><tr>
44 * <td>{@link RxtxChannelOption#DATA_BITS}</td><td>{@link #setDatabits(Databits)}</td>
45 * </tr><tr>
46 * <td>{@link RxtxChannelOption#PARITY_BIT}</td><td>{@link #setParitybit(Paritybit)}</td>
47 * </tr><tr>
48 * <td>{@link RxtxChannelOption#WAIT_TIME}</td><td>{@link #setWaitTimeMillis(int)}</td>
49 * </tr>
50 * </table>
51 *
52 * @deprecated this transport will be removed in the next major version.
53 */
54 @Deprecated
55 public interface RxtxChannelConfig extends ChannelConfig {
56 enum Stopbits {
57 /**
58 * 1 stop bit will be sent at the end of every character
59 */
60 STOPBITS_1(SerialPort.STOPBITS_1),
61 /**
62 * 2 stop bits will be sent at the end of every character
63 */
64 STOPBITS_2(SerialPort.STOPBITS_2),
65 /**
66 * 1.5 stop bits will be sent at the end of every character
67 */
68 STOPBITS_1_5(SerialPort.STOPBITS_1_5);
69
70 private final int value;
71
72 Stopbits(int value) {
73 this.value = value;
74 }
75
76 public int value() {
77 return value;
78 }
79
80 public static Stopbits valueOf(int value) {
81 for (Stopbits stopbit : Stopbits.values()) {
82 if (stopbit.value == value) {
83 return stopbit;
84 }
85 }
86 throw new IllegalArgumentException("unknown " + Stopbits.class.getSimpleName() + " value: " + value);
87 }
88 }
89
90 enum Databits {
91 /**
92 * 5 data bits will be used for each character (ie. Baudot code)
93 */
94 DATABITS_5(SerialPort.DATABITS_5),
95 /**
96 * 6 data bits will be used for each character
97 */
98 DATABITS_6(SerialPort.DATABITS_6),
99 /**
100 * 7 data bits will be used for each character (ie. ASCII)
101 */
102 DATABITS_7(SerialPort.DATABITS_7),
103 /**
104 * 8 data bits will be used for each character (ie. binary data)
105 */
106 DATABITS_8(SerialPort.DATABITS_8);
107
108 private final int value;
109
110 Databits(int value) {
111 this.value = value;
112 }
113
114 public int value() {
115 return value;
116 }
117
118 public static Databits valueOf(int value) {
119 for (Databits databit : Databits.values()) {
120 if (databit.value == value) {
121 return databit;
122 }
123 }
124 throw new IllegalArgumentException("unknown " + Databits.class.getSimpleName() + " value: " + value);
125 }
126 }
127
128 enum Paritybit {
129 /**
130 * No parity bit will be sent with each data character at all
131 */
132 NONE(SerialPort.PARITY_NONE),
133 /**
134 * An odd parity bit will be sent with each data character, ie. will be set
135 * to 1 if the data character contains an even number of bits set to 1.
136 */
137 ODD(SerialPort.PARITY_ODD),
138 /**
139 * An even parity bit will be sent with each data character, ie. will be set
140 * to 1 if the data character contains an odd number of bits set to 1.
141 */
142 EVEN(SerialPort.PARITY_EVEN),
143 /**
144 * A mark parity bit (ie. always 1) will be sent with each data character
145 */
146 MARK(SerialPort.PARITY_MARK),
147 /**
148 * A space parity bit (ie. always 0) will be sent with each data character
149 */
150 SPACE(SerialPort.PARITY_SPACE);
151
152 private final int value;
153
154 Paritybit(int value) {
155 this.value = value;
156 }
157
158 public int value() {
159 return value;
160 }
161
162 public static Paritybit valueOf(int value) {
163 for (Paritybit paritybit : Paritybit.values()) {
164 if (paritybit.value == value) {
165 return paritybit;
166 }
167 }
168 throw new IllegalArgumentException("unknown " + Paritybit.class.getSimpleName() + " value: " + value);
169 }
170 }
171 /**
172 * Sets the baud rate (ie. bits per second) for communication with the serial device.
173 * The baud rate will include bits for framing (in the form of stop bits and parity),
174 * such that the effective data rate will be lower than this value.
175 *
176 * @param baudrate The baud rate (in bits per second)
177 */
178 RxtxChannelConfig setBaudrate(int baudrate);
179
180 /**
181 * Sets the number of stop bits to include at the end of every character to aid the
182 * serial device in synchronising with the data.
183 *
184 * @param stopbits The number of stop bits to use
185 */
186 RxtxChannelConfig setStopbits(Stopbits stopbits);
187
188 /**
189 * Sets the number of data bits to use to make up each character sent to the serial
190 * device.
191 *
192 * @param databits The number of data bits to use
193 */
194 RxtxChannelConfig setDatabits(Databits databits);
195
196 /**
197 * Sets the type of parity bit to be used when communicating with the serial device.
198 *
199 * @param paritybit The type of parity bit to be used
200 */
201 RxtxChannelConfig setParitybit(Paritybit paritybit);
202
203 /**
204 * @return The configured baud rate, defaulting to 115200 if unset
205 */
206 int getBaudrate();
207
208 /**
209 * @return The configured stop bits, defaulting to {@link Stopbits#STOPBITS_1} if unset
210 */
211 Stopbits getStopbits();
212
213 /**
214 * @return The configured data bits, defaulting to {@link Databits#DATABITS_8} if unset
215 */
216 Databits getDatabits();
217
218 /**
219 * @return The configured parity bit, defaulting to {@link Paritybit#NONE} if unset
220 */
221 Paritybit getParitybit();
222
223 /**
224 * @return true if the serial device should support the Data Terminal Ready signal
225 */
226 boolean isDtr();
227
228 /**
229 * Sets whether the serial device supports the Data Terminal Ready signal, used for
230 * flow control
231 *
232 * @param dtr true if DTR is supported, false otherwise
233 */
234 RxtxChannelConfig setDtr(boolean dtr);
235
236 /**
237 * @return true if the serial device should support the Ready to Send signal
238 */
239 boolean isRts();
240
241 /**
242 * Sets whether the serial device supports the Request To Send signal, used for flow
243 * control
244 *
245 * @param rts true if RTS is supported, false otherwise
246 */
247 RxtxChannelConfig setRts(boolean rts);
248
249 /**
250 * @return The number of milliseconds to wait between opening the serial port and
251 * initialising.
252 */
253 int getWaitTimeMillis();
254
255 /**
256 * Sets the time to wait after opening the serial port and before sending it any
257 * configuration information or data. A value of 0 indicates that no waiting should
258 * occur.
259 *
260 * @param waitTimeMillis The number of milliseconds to wait, defaulting to 0 (no
261 * wait) if unset
262 * @throws IllegalArgumentException if the supplied value is < 0
263 */
264 RxtxChannelConfig setWaitTimeMillis(int waitTimeMillis);
265
266 /**
267 * Sets the maximal time (in ms) to block while try to read from the serial port. Default is 1000ms
268 */
269 RxtxChannelConfig setReadTimeout(int readTimeout);
270
271 /**
272 * Return the maximal time (in ms) to block and wait for something to be ready to read.
273 */
274 int getReadTimeout();
275
276 @Override
277 RxtxChannelConfig setConnectTimeoutMillis(int connectTimeoutMillis);
278
279 @Override
280 RxtxChannelConfig setMaxMessagesPerRead(int maxMessagesPerRead);
281
282 @Override
283 RxtxChannelConfig setWriteSpinCount(int writeSpinCount);
284
285 @Override
286 RxtxChannelConfig setAllocator(ByteBufAllocator allocator);
287
288 @Override
289 RxtxChannelConfig setRecvByteBufAllocator(RecvByteBufAllocator allocator);
290
291 @Override
292 RxtxChannelConfig setAutoRead(boolean autoRead);
293
294 @Override
295 RxtxChannelConfig setAutoClose(boolean autoClose);
296
297 @Override
298 RxtxChannelConfig setWriteBufferHighWaterMark(int writeBufferHighWaterMark);
299
300 @Override
301 RxtxChannelConfig setWriteBufferLowWaterMark(int writeBufferLowWaterMark);
302
303 @Override
304 RxtxChannelConfig setMessageSizeEstimator(MessageSizeEstimator estimator);
305 }