protected void onSerialPortEvent(SerialPortEvent event) {
if (event.isRXCHAR()) {
int count = event.getEventValue();
if (count == 0) return;
byte[] characters;
try {
characters = serialPort.readBytes(count);
for (byte character : characters) {
// System.out.println(Integer.toHexString(character) + "\t:\t" + (int) character + "\t:\t"
// + (char) character);
onReceiveChar((char) character);
}
} catch (SerialPortException e) {
showErrorMessage("No se pudo leer un byte");
e.printStackTrace();
}
}
}
public synchronized void serialEvent(SerialPortEvent serialEvent) {
if (serialEvent.isRXCHAR()) {
try {
byte[] buf = port.readBytes(serialEvent.getEventValue());
if (buf.length > 0) {
String msg = new String(buf);
char[] chars = msg.toCharArray();
message(chars, chars.length);
}
} catch (SerialPortException e) {
errorMessage("serialEvent", e);
}
}
}
public void serialEvent(SerialPortEvent event) {
try {
if (event.isRXCHAR() && !getIgnoreMessage()) {
int numberOfBytes = event.getEventValue();
if (numberOfBytes > 0) {
byte[] bufferOriginal = serialPort.readBytes(numberOfBytes);
ByteArrayObject frame = new ByteArrayObject(bufferOriginal, numberOfBytes);
_caller.getDataLayer().notifyFrame(frame);
}
}
} catch (Exception e) {
LOG.error("Error on read from serial data:" + e.getMessage());
}
}
/**
* @generate serialEvent.xml
* @webref serial:events
* @usage web_application
* @param event the port where new data is available
*/
public void serialEvent(SerialPortEvent event) {
if (event.getEventType() == SerialPortEvent.RXCHAR) {
int toRead;
try {
while (0 < (toRead = port.getInputBufferBytesCount())) {
// this method can be called from the context of another thread
synchronized (buffer) {
// read one byte at a time if the sketch is using serialEvent
if (serialEventMethod != null) {
toRead = 1;
}
// enlarge buffer if necessary
if (buffer.length < inBuffer + toRead) {
byte temp[] = new byte[buffer.length << 1];
System.arraycopy(buffer, 0, temp, 0, inBuffer);
buffer = temp;
}
// read an array of bytes and copy it into our buffer
byte[] read = port.readBytes(toRead);
System.arraycopy(read, 0, buffer, inBuffer, read.length);
inBuffer += read.length;
}
if (serialEventMethod != null) {
if ((0 < bufferUntilSize && bufferUntilSize <= inBuffer - readOffset)
|| (0 == bufferUntilSize && bufferUntilByte == buffer[inBuffer - 1])) {
try {
// serialEvent() is invoked in the context of the current (serial) thread
// which means that serialization and atomic variables need to be used to
// guarantee reliable operation (and better not draw() etc..)
// serialAvailable() does not provide any real benefits over using
// available() and read() inside draw - but this function has no
// thread-safety issues since it's being invoked during pre in the context
// of the Processing applet
serialEventMethod.invoke(parent, this);
} catch (Exception e) {
System.err.println("Error, disabling serialEvent() for " + port.getPortName());
System.err.println(e.getLocalizedMessage());
serialEventMethod = null;
}
}
}
invokeSerialAvailable = true;
}
} catch (SerialPortException e) {
throw new RuntimeException(
"Error reading from serial port " + e.getPortName() + ": " + e.getExceptionType());
}
}
}
public void serialEvent(SerialPortEvent event) {
final String mn = "serialEvent";
// logger.logp(Level.INFO, this.getClass().getName(), mn, "> " + event);
try {
if (event.isRXCHAR()) { // If data is available
String str = serialPort.readString();
// System.out.println("serialEvent '" + str + "'");
buildLine(str);
} else {
logger.logp(
Level.WARNING,
this.getClass().getName(),
mn,
"Unknown event " + event.getEventType() + ", " + event.getEventValue());
}
} catch (Throwable t) {
// This Thread should never fail
String msg = t.getMessage();
logger.logp(Level.WARNING, this.getClass().getName(), mn, msg);
setErrorMessage(msg);
t.printStackTrace();
}
// logger.logp(Level.INFO, this.getClass().getName(), mn, "<");
}
@Override
public synchronized void serialEvent(SerialPortEvent event) {
if (log.isTraceEnabled()) {
log.trace("SerialEvent '" + event.getEventType() + "' on [" + event.getPortName() + "]");
}
if (event.isRXCHAR() && hasListeners()) { // If data is available
byte[] data;
try {
data = serialPort.readBytes(event.getEventValue());
getStreamReader().processPacketRead(data, data.length);
} catch (SerialPortException e) {
log.error(e.getMessage(), e);
throw new RuntimeException(e);
}
} else if (event.isCTS()) { // If CTS line has changed state
if (event.getEventValue() == 1) { // If line is ON
log.debug("SerialEvent - CTS = ON");
} else {
log.debug("SerialEvent - CTS = OFF");
}
} else if (event.isBREAK()) { // /If DSR line has changed state
log.debug("SerialEvent - isBREAK");
} else if (event.isERR()) { // /If DSR line has changed state
log.debug("SerialEvent - isERR");
try {
disconnect();
} catch (ConnectionException ex) {
log.error(ex.getMessage(), ex);
}
} else if (event.isRING()) { // /If DSR line has changed state
log.debug("SerialEvent - isRING");
}
}
@Override
public void serialEvent(SerialPortEvent serialPortEvent) {
int val = serialPortEvent.getEventValue();
if (serialPortEvent.isRXCHAR() && val > 0) {
if (SerialConnection.DEBUG_SERIAL) {
System.out.println("Received " + val + " bytes");
}
try {
byte[] preambleData = new byte[0];
byte[] payloadData = new byte[0];
preambleData = mPort.readBytes(PREAMBLE_SIZE, 500);
if (SerialConnection.DEBUG_SERIAL) {
System.out.println(
"Preamble: "
+ ByteArrayHelpers.getByteArrayString(preambleData)
+ "("
+ new String(preambleData)
+ ")");
}
if (preambleData.length == PREAMBLE_SIZE) {
dataSize = preambleData[2];
if (dataSize > 0) {
payloadData = mPort.readBytes(dataSize, 500);
if (SerialConnection.DEBUG_SERIAL) {
System.out.println(
"Data: "
+ ByteArrayHelpers.getByteArrayString(payloadData)
+ "("
+ new String(payloadData)
+ ")");
}
networkDelegate.handlePacket(ByteArrayHelpers.concat(preambleData, payloadData));
} else if (0 == dataSize) {
networkDelegate.handlePacket(preambleData);
}
} else {
if (SerialConnection.DEBUG_MSGS) {
System.out.println(
"preamble data length: "
+ preambleData.length
+ " does not match correct size: "
+ PREAMBLE_SIZE);
}
}
// switch (state) {
// case PREAMBLE:
// preambleData = mPort.readBytes(PREAMBLE_SIZE);
//
// if (SerialConnection.DEBUG_SERIAL) {
// System.out.println("Preamble: " + ByteArrayHelpers.getByteArrayString(preambleData)
// + "(" + new String(payloadData) + ")");
// }
//
// if (preambleData.length == PREAMBLE_SIZE)
// {
// dataSize = preambleData[PREAMBLE_SIZE - 1];
// if (dataSize > 0)
// {
// state = ListenerState.DATA;
// payloadData = mPort.readBytes(dataSize, 50);
//
// if (SerialConnection.DEBUG_SERIAL) {
// System.out.println("Data: " + ByteArrayHelpers.getByteArrayString(payloadData) +
// "(" + new String(payloadData) + ")");
// }
// state = ListenerState.PREAMBLE;
//
// } else if (0 == dataSize)
// {
// networkDelegate.handlePacket(preambleData);
// }
// } else
// {
// if (SerialConnection.DEBUG_MSGS)
// {
// System.out.println("preamble data length: " + preambleData.length + " does not
// match correct size: " + PREAMBLE_SIZE);
// }
// }
// break;
//
// case DATA:
// payloadData = mPort.readBytes(dataSize);
//
// if (SerialConnection.DEBUG_SERIAL) {
// System.out.println("Data: " + ByteArrayHelpers.getByteArrayString(payloadData));
// }
//
// if (dataSize == payloadData.length)
// {
// byte[] concatData = ByteArrayHelpers.concat(preambleData, payloadData);
// networkDelegate.handlePacket(concatData);
// }
// state = ListenerState.PREAMBLE;
// break;
//
// default:
// break;
// }
} catch (SerialPortException e) {
if (SerialConnection.DEBUG_MSGS) {
e.printStackTrace();
}
} catch (SerialPortTimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
