Java tutorial
/* * Copyright 2013-14 Fraunhofer ISE * * This file is part of j62056. * For more information visit http://www.openmuc.org * * j62056 is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 2.1 of the License, or * (at your option) any later version. * * j62056 is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with j62056. If not, see <http://www.gnu.org/licenses/>. * */ package org.openmuc.j62056; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.concurrent.TimeoutException; import gnu.io.CommPortIdentifier; import gnu.io.NoSuchPortException; import gnu.io.PortInUseException; import gnu.io.RXTXPort; import gnu.io.SerialPort; import gnu.io.UnsupportedCommOperationException; import org.apache.commons.codec.binary.Hex; public class Connection { private final String serialPortName; private SerialPort serialPort; private final byte[] initMessage; private final boolean handleEcho; private final int baudRateChangeDelay; private int timeout = 5000; private DataOutputStream os; private DataInputStream is; private static char[] hexArray = "0123456789ABCDEF".toCharArray(); private static int[] baudRates = new int[] { 300, 600, 1200, 2400, 4800, 9600, 19200 }; private static final byte[] REQUEST_MESSAGE = new byte[] { (byte) 0x2F, (byte) 0x3F, (byte) 0x21, (byte) 0x0D, (byte) 0x0A }; private static final byte[] ACKNOWLEDGE = new byte[] { (byte) 0x06, (byte) 0x30, (byte) 0x30, (byte) 0x30, (byte) 0x0D, (byte) 0x0A }; private static final int INPUT_BUFFER_LENGTH = 1024; private byte[] buffer = new byte[INPUT_BUFFER_LENGTH]; private static final Charset charset = Charset.forName("US-ASCII"); private static final int SLEEP_INTERVAL = 100; /** * Creates a Connection object. You must call <code>open()</code> before * calling <code>read()</code> in order to read data. The timeout is set by * default to 5s. * * @param serialPort * examples for serial port identifiers are on Linux "/dev/ttyS0" * or "/dev/ttyUSB0" and on Windows "COM1" * @param initMessage * extra pre init bytes * @param handleEcho * tells the connection to throw away echos of outgoing messages. * Echos are caused by some optical transceivers. * @param baudRateChangeDelay * tells the connection the time in ms to wait before changing * the baud rate during message exchange. This parameter can * usually be set to zero for regular serial ports. If a USB to * serial converter is used, you might have to use a delay of * around 250ms because otherwise the baud rate is changed before * the previous message (i.e. the acknowledgment) has been * completely sent. */ public Connection(String serialPort, byte[] initMessage, boolean handleEcho, int baudRateChangeDelay) { if (serialPort == null) { throw new IllegalArgumentException("serialPort may not be NULL"); } serialPortName = serialPort; this.initMessage = initMessage; this.handleEcho = handleEcho; this.baudRateChangeDelay = baudRateChangeDelay; } /** * Creates a Connection object. The option handleEcho is set to false and * the baudRateChangeDelay is set to 0. * * @param serialPort * examples for serial port identifiers on Linux are "/dev/ttyS0" * or "/dev/ttyUSB0" and on Windows "COM1" */ public Connection(String serialPort) { this(serialPort, null, false, 0); } /** * Sets the maximum time in ms to wait for new data from the remote device. * A timeout of zero is interpreted as an infinite timeout. * * @param timeout * the maximum time in ms to wait for new data. */ public void setTimeout(int timeout) { this.timeout = timeout; } /** * Returns the timeout in ms. * * @return the timeout in ms. */ public int getTimeout() { return timeout; } /** * Opens the serial port associated with this connection. * * @throws IOException * if any kind of error occurs opening the serial port. */ public void open() throws IOException { CommPortIdentifier portIdentifier; try { portIdentifier = CommPortIdentifier.getPortIdentifier(serialPortName); } catch (NoSuchPortException e) { throw new IOException("Serial port with given name does not exist", e); } if (portIdentifier.isCurrentlyOwned()) { throw new IOException("Serial port is currently in use."); } // fixed issue as rxtx library originally used in j62056 does use // different version of rxtx // com port in their version is using gnu.io.CommPort RXTXPort commPort; try { commPort = portIdentifier.open(this.getClass().getName(), 2000); } catch (PortInUseException e) { throw new IOException("Serial port is currently in use.", e); } if (!(commPort instanceof SerialPort)) { commPort.close(); throw new IOException("The specified CommPort is not a serial port"); } serialPort = commPort; try { os = new DataOutputStream(serialPort.getOutputStream()); is = new DataInputStream(serialPort.getInputStream()); } catch (IOException e) { serialPort.close(); serialPort = null; throw new IOException("Error getting input or output or input stream from serial port", e); } } /** * Closes the serial port. */ public void close() { if (serialPort == null) { return; } serialPort.close(); serialPort = null; } /** * Requests a data message from the remote device using IEC 62056-21 Mode C. * The data message received is parsed and a list of data sets is returned. * * @return A list of data sets contained in the data message response from * the remote device. The first data set will contain the * "identification" of the meter as the id and empty strings for * value and unit. * @throws IOException * if any kind of error other than timeout occurs while trying * to read the remote device. Note that the connection is not * closed when an IOException is thrown. * @throws TimeoutException * if no response at all (not even a single byte) was received * from the meter within the timeout span. */ public List<DataSet> read() throws IOException, TimeoutException { if (serialPort == null) { throw new IllegalStateException("Connection is not open."); } try { serialPort.setSerialPortParams(300, SerialPort.DATABITS_7, SerialPort.STOPBITS_1, SerialPort.PARITY_EVEN); } catch (UnsupportedCommOperationException e) { throw new IOException("Unable to set the given serial comm parameters", e); } if (initMessage != null) { os.write(initMessage); os.flush(); } os.write(REQUEST_MESSAGE); os.flush(); int baudRateSetting; char protocolMode; int baudRate; boolean readSuccessful = false; int timeval = 0; int numBytesReadTotal = 0; while (timeout == 0 || timeval < timeout) { if (is.available() > 0) { int numBytesRead = is.read(buffer, numBytesReadTotal, INPUT_BUFFER_LENGTH - numBytesReadTotal); numBytesReadTotal += numBytesRead; if (numBytesRead > 0) { timeval = 0; } if (((handleEcho && numBytesReadTotal > 11) || (!handleEcho && numBytesReadTotal > 6)) && buffer[numBytesReadTotal - 2] == 0x0D && buffer[numBytesReadTotal - 1] == 0x0A) { readSuccessful = true; break; } } try { Thread.sleep(SLEEP_INTERVAL); } catch (InterruptedException e) { } timeval += SLEEP_INTERVAL; } int offset = 0; if (handleEcho) { offset = 5; } if (numBytesReadTotal == offset) { throw new TimeoutException(); } if (!readSuccessful) { throw new IOException("Timeout while listening for Identification Message"); } // System.out // .println("Got the following identification message: " + // getByteArrayString(buffer, numBytesReadTotal)); int startPosition = 0; while (startPosition < numBytesReadTotal) { if (buffer[startPosition] == (byte) 0x2F) { if (buffer[startPosition + 1] == (byte) 0x00 | buffer[startPosition + 1] == (byte) 0x7F) { startPosition++; } else { break; } continue; } startPosition++; } byte[] bytes = new byte[numBytesReadTotal - startPosition]; System.arraycopy(buffer, startPosition, bytes, 0, numBytesReadTotal - startPosition); /* baudrate identification http://manuals.lian98.biz/doc.en/html/u_iec62056_struct.htm * Protocol mode A : no baudrate change * Protocol mode B : char from A to I; no acknowledgement * Protocol mode C : char from 0 to 9; with acknowledgement */ baudRateSetting = bytes[offset + 4]; if (baudRateSetting >= 0x41 && baudRateSetting <= 0x49) { protocolMode = 'B';//Mode B baudRate = baudRates[baudRateSetting - 0x40];//search with index (start with baudrate 600) } else if (baudRateSetting >= 0x30 && baudRateSetting <= 0x39) { protocolMode = 'C';//Mode C or E baudRate = baudRates[baudRateSetting - 0x30];//search with index } else if (baudRateSetting >= 0x32) { protocolMode = 'D';//Mode D no baudrate change baudRate = -1; } else { protocolMode = 'A';//Mode A no baudrate change baudRate = -1; } String identification = new String(buffer, offset + 5, numBytesReadTotal - offset - 7, charset); if (protocolMode == 'B' || protocolMode == 'C') { if (baudRate == -1) { throw new IOException( "Syntax error in identification message received: unknown baud rate received: (hex: " + Hex.encodeHexString(bytes) + ")"); } } if (protocolMode == 'C') { ACKNOWLEDGE[2] = (byte) baudRateSetting; os.write(ACKNOWLEDGE); os.flush(); } if (handleEcho) { readSuccessful = false; numBytesReadTotal = 0; while (timeout == 0 || timeval < timeout) { if (is.available() > 0) { int numBytesRead = is.read(buffer, numBytesReadTotal, ACKNOWLEDGE.length - numBytesReadTotal); numBytesReadTotal += numBytesRead; if (numBytesRead > 0) { timeval = 0; } if (numBytesReadTotal == ACKNOWLEDGE.length) { readSuccessful = true; break; } } try { Thread.sleep(SLEEP_INTERVAL); } catch (InterruptedException e) { } timeval += SLEEP_INTERVAL; } // if (readSuccessful) { // System.out.println("Received the following echo of the acknowledge successfully : " // + getByteArrayString(buffer, numBytesReadTotal)); // } // else { // System.out.println("Receiving full echo failed."); // } } if (baudRateChangeDelay > 0) { try { Thread.sleep(baudRateChangeDelay); } catch (InterruptedException e1) { } } try { serialPort.setSerialPortParams(baudRate, SerialPort.DATABITS_7, SerialPort.STOPBITS_1, SerialPort.PARITY_EVEN); } catch (UnsupportedCommOperationException e) { throw new IOException("Serial Port does not support " + baudRate + "bd 7E1"); } readSuccessful = false; numBytesReadTotal = 0; int etxIndex = -1; while (timeout == 0 || timeval < timeout) { int available = is.available(); if (available > 0) { if (buffer.length < (numBytesReadTotal + available)) { //grow buffer buffer = Arrays.copyOf(buffer, numBytesReadTotal + available); } int numBytesRead = is.read(buffer, numBytesReadTotal, available); numBytesReadTotal += numBytesRead; if (numBytesRead > 0) { timeval = 0; } if ((etxIndex = findEtx(buffer, numBytesRead, numBytesReadTotal)) != -1 || (numBytesReadTotal > 4 && buffer[numBytesReadTotal - 3] == 0x21) || (numBytesReadTotal > 7 && buffer[numBytesReadTotal - 5] == 0x21)) { readSuccessful = true; break; } } try { Thread.sleep(SLEEP_INTERVAL); } catch (InterruptedException e) { } timeval += SLEEP_INTERVAL; } if (!readSuccessful) { throw new IOException("Timeout while listening for Data Message"); } // System.out.println("Got the following data message: " + // getByteArrayString(buffer, numBytesReadTotal)); int index; int endIndex; // if 2nd last character is ETX if (etxIndex != -1) { if (numBytesReadTotal < 8) { throw new IOException("Data message does not have minimum length of 8."); } index = 1; endIndex = etxIndex - 3; if (buffer[0] != 0x02) { startPosition = 0; while (startPosition < numBytesReadTotal) { if (buffer[startPosition] == (byte) 0x02) { break; } else { if (startPosition < numBytesReadTotal - 2) { startPosition++; } else { throw new IOException( "STX (0x02) character is expected but not received as first byte of data message. (hex: " + Hex.encodeHexString(buffer) + ")"); } } } } } else { if (numBytesReadTotal < 5) { throw new IOException("Data message does not have minimum length of 5."); } index = 0; endIndex = numBytesReadTotal - 3; } if (buffer[endIndex + 1] != 0x0D) { throw new IOException( "CR (0x0D) character is expected but not received after data block of data message. (hex: " + Hex.encodeHexString(buffer) + ")"); } if (buffer[endIndex + 2] != 0x0A) { throw new IOException( "LF (0x0A) character is expected but not received after data block of data message. (hex: " + Hex.encodeHexString(buffer) + ")"); } List<DataSet> dataSets = new ArrayList<DataSet>(); dataSets.add(new DataSet(identification, "", "")); while (index != endIndex) { String id = null; for (int i = index; i < endIndex - 1; i++) { if (buffer[i] == 0x28) { // found '(' id = new String(buffer, index, i - index, charset); index = i + 1; break; } } if (id == null) { throw new IOException( "'(' (0x28) character is expected but not received inside data block of data message. (hex: " + Hex.encodeHexString(buffer) + ")"); } String value = ""; String unit = ""; for (int i = index; i < endIndex; i++) { if (buffer[i] == 0x2A) { // found '*' if (i > index) { value = new String(buffer, index, i - index, charset); } index = i + 1; for (int j = index; j < endIndex; j++) { if (buffer[j] == 0x29) { // found ')' unit = new String(buffer, index, j - index, charset); index = j + 1; break; } } break; } else if (buffer[i] == 0x29) { // found ')' if (i > index) { value = new String(buffer, index, i - index, charset); } index = i + 1; break; } } if (buffer[index - 1] != 0x29) { throw new IOException( "')' (0x29) character is expected but not received inside data block of data message. (hex: " + Hex.encodeHexString(buffer) + ")"); } dataSets.add(new DataSet(id, value, unit)); if (buffer[index] == 0x0d && buffer[index + 1] == 0x0a) { index += 2; } } return dataSets; } /** * Returns the baud rate chosen by the server for this communication * * @param baudCharacter * Encoded baud rate (see 6.3.14 item 13c) * @return The chosen baud rate or -1 on error */ private int getBaudRate(int baudCharacter) { int result = -1; switch (baudCharacter) { case 0x30: result = 300; break; case 0x31: result = 600; break; case 0x32: result = 1200; break; case 0x33: result = 2400; break; case 0x34: result = 4800; break; case 0x35: result = 9600; break; case 0x36: result = 19200; break; } return result; } private int findEtx(byte[] buffer, int numBytesRead, int numBytesReadTotal) { for (int i = numBytesReadTotal - 1; i > numBytesRead; i--) { if (buffer[i] == 0x03) { return i; } } return -1; } }