8c8779669e
Motivation: transport-rxtx has no tests and there is really no easy way to add some. Beside this this transport is not really well maintained. Modifications: Mark transport-rxtx as @deprecated so we can drop it in next major version. Result: Notify users of plan to drop the transport.
311 lines
9.6 KiB
Java
311 lines
9.6 KiB
Java
/*
|
|
* Copyright 2013 The Netty Project
|
|
*
|
|
* The Netty Project licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
package io.netty.channel.rxtx;
|
|
|
|
import gnu.io.SerialPort;
|
|
import io.netty.buffer.ByteBufAllocator;
|
|
import io.netty.channel.ChannelConfig;
|
|
import io.netty.channel.MessageSizeEstimator;
|
|
import io.netty.channel.RecvByteBufAllocator;
|
|
import io.netty.channel.WriteBufferWaterMark;
|
|
|
|
/**
|
|
* A configuration class for RXTX device connections.
|
|
*
|
|
* <h3>Available options</h3>
|
|
*
|
|
* In addition to the options provided by {@link ChannelConfig},
|
|
* {@link DefaultRxtxChannelConfig} allows the following options in the option map:
|
|
*
|
|
* <table border="1" cellspacing="0" cellpadding="6">
|
|
* <tr>
|
|
* <th>Name</th><th>Associated setter method</th>
|
|
* </tr><tr>
|
|
* <td>{@link RxtxChannelOption#BAUD_RATE}</td><td>{@link #setBaudrate(int)}</td>
|
|
* </tr><tr>
|
|
* <td>{@link RxtxChannelOption#DTR}</td><td>{@link #setDtr(boolean)}</td>
|
|
* </tr><tr>
|
|
* <td>{@link RxtxChannelOption#RTS}</td><td>{@link #setRts(boolean)}</td>
|
|
* </tr><tr>
|
|
* <td>{@link RxtxChannelOption#STOP_BITS}</td><td>{@link #setStopbits(Stopbits)}</td>
|
|
* </tr><tr>
|
|
* <td>{@link RxtxChannelOption#DATA_BITS}</td><td>{@link #setDatabits(Databits)}</td>
|
|
* </tr><tr>
|
|
* <td>{@link RxtxChannelOption#PARITY_BIT}</td><td>{@link #setParitybit(Paritybit)}</td>
|
|
* </tr><tr>
|
|
* <td>{@link RxtxChannelOption#WAIT_TIME}</td><td>{@link #setWaitTimeMillis(int)}</td>
|
|
* </tr>
|
|
* </table>
|
|
*
|
|
* @deprecated this transport will be removed in the next major version.
|
|
*/
|
|
@Deprecated
|
|
public interface RxtxChannelConfig extends ChannelConfig {
|
|
enum Stopbits {
|
|
/**
|
|
* 1 stop bit will be sent at the end of every character
|
|
*/
|
|
STOPBITS_1(SerialPort.STOPBITS_1),
|
|
/**
|
|
* 2 stop bits will be sent at the end of every character
|
|
*/
|
|
STOPBITS_2(SerialPort.STOPBITS_2),
|
|
/**
|
|
* 1.5 stop bits will be sent at the end of every character
|
|
*/
|
|
STOPBITS_1_5(SerialPort.STOPBITS_1_5);
|
|
|
|
private final int value;
|
|
|
|
Stopbits(int value) {
|
|
this.value = value;
|
|
}
|
|
|
|
public int value() {
|
|
return value;
|
|
}
|
|
|
|
public static Stopbits valueOf(int value) {
|
|
for (Stopbits stopbit : Stopbits.values()) {
|
|
if (stopbit.value == value) {
|
|
return stopbit;
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("unknown " + Stopbits.class.getSimpleName() + " value: " + value);
|
|
}
|
|
}
|
|
|
|
enum Databits {
|
|
/**
|
|
* 5 data bits will be used for each character (ie. Baudot code)
|
|
*/
|
|
DATABITS_5(SerialPort.DATABITS_5),
|
|
/**
|
|
* 6 data bits will be used for each character
|
|
*/
|
|
DATABITS_6(SerialPort.DATABITS_6),
|
|
/**
|
|
* 7 data bits will be used for each character (ie. ASCII)
|
|
*/
|
|
DATABITS_7(SerialPort.DATABITS_7),
|
|
/**
|
|
* 8 data bits will be used for each character (ie. binary data)
|
|
*/
|
|
DATABITS_8(SerialPort.DATABITS_8);
|
|
|
|
private final int value;
|
|
|
|
Databits(int value) {
|
|
this.value = value;
|
|
}
|
|
|
|
public int value() {
|
|
return value;
|
|
}
|
|
|
|
public static Databits valueOf(int value) {
|
|
for (Databits databit : Databits.values()) {
|
|
if (databit.value == value) {
|
|
return databit;
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("unknown " + Databits.class.getSimpleName() + " value: " + value);
|
|
}
|
|
}
|
|
|
|
enum Paritybit {
|
|
/**
|
|
* No parity bit will be sent with each data character at all
|
|
*/
|
|
NONE(SerialPort.PARITY_NONE),
|
|
/**
|
|
* An odd parity bit will be sent with each data character, ie. will be set
|
|
* to 1 if the data character contains an even number of bits set to 1.
|
|
*/
|
|
ODD(SerialPort.PARITY_ODD),
|
|
/**
|
|
* An even parity bit will be sent with each data character, ie. will be set
|
|
* to 1 if the data character contains an odd number of bits set to 1.
|
|
*/
|
|
EVEN(SerialPort.PARITY_EVEN),
|
|
/**
|
|
* A mark parity bit (ie. always 1) will be sent with each data character
|
|
*/
|
|
MARK(SerialPort.PARITY_MARK),
|
|
/**
|
|
* A space parity bit (ie. always 0) will be sent with each data character
|
|
*/
|
|
SPACE(SerialPort.PARITY_SPACE);
|
|
|
|
private final int value;
|
|
|
|
Paritybit(int value) {
|
|
this.value = value;
|
|
}
|
|
|
|
public int value() {
|
|
return value;
|
|
}
|
|
|
|
public static Paritybit valueOf(int value) {
|
|
for (Paritybit paritybit : Paritybit.values()) {
|
|
if (paritybit.value == value) {
|
|
return paritybit;
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("unknown " + Paritybit.class.getSimpleName() + " value: " + value);
|
|
}
|
|
}
|
|
/**
|
|
* Sets the baud rate (ie. bits per second) for communication with the serial device.
|
|
* The baud rate will include bits for framing (in the form of stop bits and parity),
|
|
* such that the effective data rate will be lower than this value.
|
|
*
|
|
* @param baudrate The baud rate (in bits per second)
|
|
*/
|
|
RxtxChannelConfig setBaudrate(int baudrate);
|
|
|
|
/**
|
|
* Sets the number of stop bits to include at the end of every character to aid the
|
|
* serial device in synchronising with the data.
|
|
*
|
|
* @param stopbits The number of stop bits to use
|
|
*/
|
|
RxtxChannelConfig setStopbits(Stopbits stopbits);
|
|
|
|
/**
|
|
* Sets the number of data bits to use to make up each character sent to the serial
|
|
* device.
|
|
*
|
|
* @param databits The number of data bits to use
|
|
*/
|
|
RxtxChannelConfig setDatabits(Databits databits);
|
|
|
|
/**
|
|
* Sets the type of parity bit to be used when communicating with the serial device.
|
|
*
|
|
* @param paritybit The type of parity bit to be used
|
|
*/
|
|
RxtxChannelConfig setParitybit(Paritybit paritybit);
|
|
|
|
/**
|
|
* @return The configured baud rate, defaulting to 115200 if unset
|
|
*/
|
|
int getBaudrate();
|
|
|
|
/**
|
|
* @return The configured stop bits, defaulting to {@link Stopbits#STOPBITS_1} if unset
|
|
*/
|
|
Stopbits getStopbits();
|
|
|
|
/**
|
|
* @return The configured data bits, defaulting to {@link Databits#DATABITS_8} if unset
|
|
*/
|
|
Databits getDatabits();
|
|
|
|
/**
|
|
* @return The configured parity bit, defaulting to {@link Paritybit#NONE} if unset
|
|
*/
|
|
Paritybit getParitybit();
|
|
|
|
/**
|
|
* @return true if the serial device should support the Data Terminal Ready signal
|
|
*/
|
|
boolean isDtr();
|
|
|
|
/**
|
|
* Sets whether the serial device supports the Data Terminal Ready signal, used for
|
|
* flow control
|
|
*
|
|
* @param dtr true if DTR is supported, false otherwise
|
|
*/
|
|
RxtxChannelConfig setDtr(boolean dtr);
|
|
|
|
/**
|
|
* @return true if the serial device should support the Ready to Send signal
|
|
*/
|
|
boolean isRts();
|
|
|
|
/**
|
|
* Sets whether the serial device supports the Request To Send signal, used for flow
|
|
* control
|
|
*
|
|
* @param rts true if RTS is supported, false otherwise
|
|
*/
|
|
RxtxChannelConfig setRts(boolean rts);
|
|
|
|
/**
|
|
* @return The number of milliseconds to wait between opening the serial port and
|
|
* initialising.
|
|
*/
|
|
int getWaitTimeMillis();
|
|
|
|
/**
|
|
* Sets the time to wait after opening the serial port and before sending it any
|
|
* configuration information or data. A value of 0 indicates that no waiting should
|
|
* occur.
|
|
*
|
|
* @param waitTimeMillis The number of milliseconds to wait, defaulting to 0 (no
|
|
* wait) if unset
|
|
* @throws IllegalArgumentException if the supplied value is < 0
|
|
*/
|
|
RxtxChannelConfig setWaitTimeMillis(int waitTimeMillis);
|
|
|
|
/**
|
|
* Sets the maximal time (in ms) to block while try to read from the serial port. Default is 1000ms
|
|
*/
|
|
RxtxChannelConfig setReadTimeout(int readTimeout);
|
|
|
|
/**
|
|
* Return the maximal time (in ms) to block and wait for something to be ready to read.
|
|
*/
|
|
int getReadTimeout();
|
|
|
|
@Override
|
|
RxtxChannelConfig setConnectTimeoutMillis(int connectTimeoutMillis);
|
|
|
|
@Override
|
|
@Deprecated
|
|
RxtxChannelConfig setMaxMessagesPerRead(int maxMessagesPerRead);
|
|
|
|
@Override
|
|
RxtxChannelConfig setWriteSpinCount(int writeSpinCount);
|
|
|
|
@Override
|
|
RxtxChannelConfig setAllocator(ByteBufAllocator allocator);
|
|
|
|
@Override
|
|
RxtxChannelConfig setRecvByteBufAllocator(RecvByteBufAllocator allocator);
|
|
|
|
@Override
|
|
RxtxChannelConfig setAutoRead(boolean autoRead);
|
|
|
|
@Override
|
|
RxtxChannelConfig setAutoClose(boolean autoClose);
|
|
|
|
@Override
|
|
RxtxChannelConfig setWriteBufferHighWaterMark(int writeBufferHighWaterMark);
|
|
|
|
@Override
|
|
RxtxChannelConfig setWriteBufferLowWaterMark(int writeBufferLowWaterMark);
|
|
|
|
@Override
|
|
RxtxChannelConfig setWriteBufferWaterMark(WriteBufferWaterMark writeBufferWaterMark);
|
|
|
|
@Override
|
|
RxtxChannelConfig setMessageSizeEstimator(MessageSizeEstimator estimator);
|
|
}
|