From d6c3c4fc1d59c34840f6e77253a2bf1b06ae1908 Mon Sep 17 00:00:00 2001 From: Anton Tananaev Date: Wed, 30 Jan 2013 23:00:40 +1300 Subject: Added Navigil protocol (fix #127) --- default.cfg | 4 + src/org/traccar/ServerManager.java | 15 + src/org/traccar/protocol/NavigilFrameDecoder.java | 57 ++++ .../traccar/protocol/NavigilProtocolDecoder.java | 329 +++++++++++++++++++++ .../protocol/NavigilProtocolDecoderTest.java | 22 ++ 5 files changed, 427 insertions(+) create mode 100644 src/org/traccar/protocol/NavigilFrameDecoder.java create mode 100644 src/org/traccar/protocol/NavigilProtocolDecoder.java create mode 100644 test/org/traccar/protocol/NavigilProtocolDecoderTest.java diff --git a/default.cfg b/default.cfg index 7804ae008..5e95f2131 100644 --- a/default.cfg +++ b/default.cfg @@ -161,4 +161,8 @@ true 5024 + + true + 5025 + diff --git a/src/org/traccar/ServerManager.java b/src/org/traccar/ServerManager.java index aa30bab30..ca656af73 100644 --- a/src/org/traccar/ServerManager.java +++ b/src/org/traccar/ServerManager.java @@ -128,6 +128,7 @@ public class ServerManager { initGt02Server("gt02"); initGt06Server("gt06"); initMegastekServer("megastek"); + initNavigilServer("navigil"); // Initialize web server if (Boolean.valueOf(properties.getProperty("http.enable"))) { @@ -591,4 +592,18 @@ public class ServerManager { } } + private void initNavigilServer(String protocol) throws SQLException { + if (isProtocolEnabled(properties, protocol)) { + TrackerServer server = new TrackerServer(this, new ServerBootstrap(), protocol) { + @Override + protected void addSpecificHandlers(ChannelPipeline pipeline) { + pipeline.addLast("frameDecoder", new NavigilFrameDecoder()); + pipeline.addLast("objectDecoder", new NavigilProtocolDecoder(ServerManager.this)); + } + }; + server.setEndianness(ByteOrder.LITTLE_ENDIAN); + serverList.add(server); + } + } + } diff --git a/src/org/traccar/protocol/NavigilFrameDecoder.java b/src/org/traccar/protocol/NavigilFrameDecoder.java new file mode 100644 index 000000000..f806e138f --- /dev/null +++ b/src/org/traccar/protocol/NavigilFrameDecoder.java @@ -0,0 +1,57 @@ +/* + * Copyright 2013 Anton Tananaev (anton.tananaev@gmail.com) + * + * Licensed 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 org.traccar.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.channel.Channel; +import org.jboss.netty.channel.ChannelHandlerContext; +import org.jboss.netty.handler.codec.frame.FrameDecoder; + +public class NavigilFrameDecoder extends FrameDecoder { + + private static final int MESSAGE_HEADER = 20; + private static final long PREAMBLE = 0x2477F5F6; + + @Override + protected Object decode( + ChannelHandlerContext ctx, + Channel channel, + ChannelBuffer buf) throws Exception { + + // Check minimum length + if (buf.readableBytes() < MESSAGE_HEADER) { + return null; + } + + // Check for preamble + boolean hasPreamble = false; + if (buf.getUnsignedInt(buf.readerIndex()) == PREAMBLE) { + hasPreamble = true; + } + + // Check length and return buffer + int length = buf.getUnsignedShort(buf.readerIndex() + 6); + if (buf.readableBytes() >= length) { + if (hasPreamble) { + buf.readUnsignedInt(); + } + return buf.readBytes(length - 4); + } + + return null; + } + +} diff --git a/src/org/traccar/protocol/NavigilProtocolDecoder.java b/src/org/traccar/protocol/NavigilProtocolDecoder.java new file mode 100644 index 000000000..49e099523 --- /dev/null +++ b/src/org/traccar/protocol/NavigilProtocolDecoder.java @@ -0,0 +1,329 @@ +/* + * Copyright 2013 Anton Tananaev (anton.tananaev@gmail.com) + * + * Licensed 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 org.traccar.protocol; + +import java.nio.ByteOrder; +import java.util.Date; +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.jboss.netty.channel.Channel; +import org.jboss.netty.channel.ChannelHandlerContext; +import org.traccar.BaseProtocolDecoder; +import org.traccar.ServerManager; +import org.traccar.helper.Crc; +import org.traccar.helper.Log; +import org.traccar.model.Position; + +public class NavigilProtocolDecoder extends BaseProtocolDecoder { + + public NavigilProtocolDecoder(ServerManager serverManager) { + super(serverManager); + } + + private static final int LEAP_SECONDS_DELTA = 25; + + private static final int MESSAGE_ERROR = 2; + private static final int MESSAGE_INDICATION = 4; + private static final int MESSAGE_CONN_OPEN = 5; + private static final int MESSAGE_CONN_CLOSE = 6; + private static final int MESSAGE_SYSTEM_REPORT = 7; + private static final int MESSAGE_UNIT_REPORT = 8; + private static final int MESSAGE_GEOFENCE_ALARM = 10; + private static final int MESSAGE_INPUT_ALARM = 11; + private static final int MESSAGE_TG2_REPORT = 12; + private static final int MESSAGE_POSITION_REPORT = 13; + private static final int MESSAGE_POSITION_REPORT_2 = 15; + private static final int MESSAGE_SNAPSHOT4 = 17; + private static final int MESSAGE_TRACKING_DATA = 18; + private static final int MESSAGE_MOTION_ALARM = 19; + private static final int MESSAGE_ACKNOWLEDGEMENT = 255; + + private static Date convertTimestamp(long timestamp) { + return new Date(timestamp - LEAP_SECONDS_DELTA); + } + + private int senderSequenceNumber = 1; + + private void sendAcknowledgment(Channel channel, int sequenceNumber) { + ChannelBuffer data = ChannelBuffers.directBuffer(ByteOrder.LITTLE_ENDIAN, 4); + data.writeShort(sequenceNumber); + data.writeShort(0); // OK + + ChannelBuffer header = ChannelBuffers.directBuffer(ByteOrder.LITTLE_ENDIAN, 20); + header.writeByte(1); header.writeByte(1); + header.writeShort(senderSequenceNumber++); + header.writeShort(MESSAGE_ACKNOWLEDGEMENT); + header.writeShort(header.capacity() + data.capacity()); + header.writeShort(0); + header.writeShort(Crc.crc16X25Ccitt(data.toByteBuffer())); + header.writeInt(0); + header.writeInt((int) (new Date().getTime() / 1000) + LEAP_SECONDS_DELTA); + + if (channel != null) { + channel.write(ChannelBuffers.copiedBuffer(header, data)); + } + } + + private Position parseUnitReport(ChannelBuffer buf, long deviceId, int sequenceNumber) { + Position position = new Position(); + StringBuilder extendedInfo = new StringBuilder("navigil"); + + position.setValid(true); + position.setId((long) sequenceNumber); + position.setDeviceId(deviceId); + + buf.readUnsignedShort(); // report trigger + buf.readUnsignedShort(); // flags + + position.setLatitude(buf.readUnsignedInt() * 0.0000001); + position.setLongitude(buf.readUnsignedInt() * 0.0000001); + position.setAltitude((double) buf.readUnsignedShort()); + + buf.readUnsignedShort(); // satellites in fix + buf.readUnsignedShort(); // satellites in track + buf.readUnsignedShort(); // GPS antenna state + + position.setSpeed(buf.readUnsignedShort() * 0.194384); + position.setCourse((double) buf.readUnsignedShort()); + + buf.readUnsignedInt(); // distance + buf.readUnsignedInt(); // delta distance + + position.setPower(buf.readUnsignedShort() * 0.001); + + buf.readUnsignedShort(); // battery charger status + + position.setTime(convertTimestamp(buf.readUnsignedInt())); + + // TODO: a lot of other stuff + + position.setExtendedInfo(extendedInfo.toString()); + return position; + } + + private Position parseTg2Report(ChannelBuffer buf, long deviceId, int sequenceNumber) { + Position position = new Position(); + StringBuilder extendedInfo = new StringBuilder("navigil"); + + position.setValid(true); + position.setId((long) sequenceNumber); + position.setDeviceId(deviceId); + + buf.readUnsignedShort(); // report trigger + buf.readUnsignedByte(); // reserved + buf.readUnsignedByte(); // assisted GPS age + + position.setTime(convertTimestamp(buf.readUnsignedInt())); + + position.setLatitude(buf.readUnsignedInt() * 0.0000001); + position.setLongitude(buf.readUnsignedInt() * 0.0000001); + position.setAltitude((double) buf.readUnsignedShort()); + + buf.readUnsignedByte(); // satellites in fix + buf.readUnsignedByte(); // satellites in track + + position.setSpeed(buf.readUnsignedShort() * 0.194384); + position.setCourse((double) buf.readUnsignedShort()); + + buf.readUnsignedInt(); // distance + buf.readUnsignedShort(); // maximum speed + buf.readUnsignedShort(); // minimum speed + + buf.readUnsignedShort(); // VSAUT1 voltage + buf.readUnsignedShort(); // VSAUT2 voltage + buf.readUnsignedShort(); // solar voltage + position.setPower(buf.readUnsignedShort() * 0.001); // battery voltage + + // TODO: a lot of other stuff + + position.setExtendedInfo(extendedInfo.toString()); + return position; + } + + private Position parsePositionReport(ChannelBuffer buf, long deviceId, int sequenceNumber, long timestamp) { + Position position = new Position(); + StringBuilder extendedInfo = new StringBuilder("navigil"); + + position.setId((long) sequenceNumber); + position.setDeviceId(deviceId); + position.setTime(convertTimestamp(timestamp)); + + position.setLatitude(buf.readUnsignedMedium() * 0.00002); + position.setLongitude(buf.readUnsignedMedium() * 0.00002); + position.setAltitude(0.0); + + position.setSpeed(buf.readUnsignedByte() * 0.539957); + position.setCourse(buf.readUnsignedByte() * 2.0); + + short flags = buf.readUnsignedByte(); + position.setValid((flags & 0x80) == 0x80 && (flags & 0x40) == 0x40); + + buf.readUnsignedByte(); // reserved + + position.setExtendedInfo(extendedInfo.toString()); + return position; + } + + private Position parsePositionReport2(ChannelBuffer buf, long deviceId, int sequenceNumber, long timestamp) { + Position position = new Position(); + StringBuilder extendedInfo = new StringBuilder("navigil"); + + position.setId((long) sequenceNumber); + position.setDeviceId(deviceId); + position.setTime(convertTimestamp(timestamp)); + + position.setLatitude(buf.readUnsignedInt() * 0.0000001); + position.setLongitude(buf.readUnsignedInt() * 0.0000001); + position.setAltitude(0.0); + + buf.readUnsignedByte(); // report trigger + + position.setSpeed(buf.readUnsignedByte() * 0.539957); + position.setCourse(0.0); + + short flags = buf.readUnsignedByte(); + position.setValid((flags & 0x80) == 0x80 && (flags & 0x40) == 0x40); + + buf.readUnsignedByte(); // satellites in fix + buf.readUnsignedInt(); // distance + + position.setExtendedInfo(extendedInfo.toString()); + return position; + } + + private Position parseSnapshot4(ChannelBuffer buf, long deviceId, int sequenceNumber) { + Position position = new Position(); + StringBuilder extendedInfo = new StringBuilder("navigil"); + + position.setId((long) sequenceNumber); + position.setDeviceId(deviceId); + + buf.readUnsignedByte(); // report trigger + buf.readUnsignedByte(); // position fix source + buf.readUnsignedByte(); // GNSS fix quality + buf.readUnsignedByte(); // GNSS assistance age + + long flags = buf.readUnsignedInt(); + position.setValid((flags & 0x0400) == 0x0400); + + position.setTime(convertTimestamp(buf.readUnsignedInt())); + + position.setLatitude(buf.readUnsignedInt() * 0.0000001); + position.setLongitude(buf.readUnsignedInt() * 0.0000001); + position.setAltitude((double) buf.readUnsignedShort()); + + buf.readUnsignedByte(); // satellites in fix + buf.readUnsignedByte(); // satellites in track + + position.setSpeed(buf.readUnsignedShort() * 0.194384); + position.setCourse(buf.readUnsignedShort() * 0.1); + + buf.readUnsignedByte(); // maximum speed + buf.readUnsignedByte(); // minimum speed + buf.readUnsignedInt(); // distance + + buf.readUnsignedByte(); // supply voltage 1 + buf.readUnsignedByte(); // supply voltage 2 + position.setPower(buf.readUnsignedByte() * 0.01 + 2.5); // battery voltage + + // TODO: a lot of other stuff + + position.setExtendedInfo(extendedInfo.toString()); + return position; + } + + private Position parseTrackingData(ChannelBuffer buf, long deviceId, int sequenceNumber, long timestamp) { + Position position = new Position(); + StringBuilder extendedInfo = new StringBuilder("navigil"); + + position.setId((long) sequenceNumber); + position.setDeviceId(deviceId); + position.setTime(convertTimestamp(timestamp)); + + buf.readUnsignedByte(); // tracking mode + + short flags = buf.readUnsignedByte(); + position.setValid((flags & 0x01) == 0x01); + + buf.readUnsignedShort(); // duration + + position.setLatitude(buf.readUnsignedInt() * 0.0000001); + position.setLongitude(buf.readUnsignedInt() * 0.0000001); + position.setAltitude(0.0); + + position.setSpeed(buf.readUnsignedByte() * 0.539957); + position.setCourse(buf.readUnsignedByte() * 2.0); + + buf.readUnsignedByte(); // satellites in fix + + position.setPower(buf.readUnsignedByte() * 0.005 + 3.0); // battery voltage + + buf.readUnsignedInt(); // distance + + position.setExtendedInfo(extendedInfo.toString()); + return position; + } + + @Override + protected Object decode(ChannelHandlerContext ctx, Channel channel, Object msg) + throws Exception { + + ChannelBuffer buf = (ChannelBuffer) msg; + + buf.readUnsignedByte(); // protocol version + buf.readUnsignedByte(); // version id + int sequenceNumber = buf.readUnsignedShort(); + int messageId = buf.readUnsignedShort(); + int flags = buf.readUnsignedShort(); + buf.readUnsignedShort(); // checksum + + // Get device identifier + long deviceId; + String navigilDeviceId = String.valueOf(buf.readUnsignedInt()); + try { + deviceId = getDataManager().getDeviceByImei(navigilDeviceId).getId(); + } catch(Exception error) { + Log.warning("Unknown device - " + navigilDeviceId); + return null; + } + + long timestamp = buf.readUnsignedInt(); // message timestamp + + // Acknowledgment + if ((flags & 0x1) == 0x0) { + sendAcknowledgment(channel, sequenceNumber); + } + + // Parse messages + switch (messageId) { + case MESSAGE_UNIT_REPORT: + return parseUnitReport(buf, deviceId, sequenceNumber); + case MESSAGE_TG2_REPORT: + return parseTg2Report(buf, deviceId, sequenceNumber); + case MESSAGE_POSITION_REPORT: + return parsePositionReport(buf, deviceId, sequenceNumber, timestamp); + case MESSAGE_POSITION_REPORT_2: + return parsePositionReport2(buf, deviceId, sequenceNumber, timestamp); + case MESSAGE_SNAPSHOT4: + return parseSnapshot4(buf, deviceId, sequenceNumber); + case MESSAGE_TRACKING_DATA: + return parseTrackingData(buf, deviceId, sequenceNumber, timestamp); + } + + return null; + } + +} diff --git a/test/org/traccar/protocol/NavigilProtocolDecoderTest.java b/test/org/traccar/protocol/NavigilProtocolDecoderTest.java new file mode 100644 index 000000000..100e178d8 --- /dev/null +++ b/test/org/traccar/protocol/NavigilProtocolDecoderTest.java @@ -0,0 +1,22 @@ +package org.traccar.protocol; + +import java.nio.ByteOrder; +import org.jboss.netty.buffer.ChannelBuffers; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import org.junit.Test; + +public class NavigilProtocolDecoderTest { + + @Test + public void testDecode() throws Exception { + + NavigilProtocolDecoder decoder = new NavigilProtocolDecoder(null); + decoder.setDataManager(new TestDataManager()); + + //byte[] buf1 = {0x40,0x4E,0x54,0x43,0x01,0x00,0x00,0x00,0x7B,0x00,0x00,0x00,0x13,0x00,0x44,0x34,0x2A,0x3E,0x53,0x3A,0x38,0x36,0x31,0x37,0x38,0x35,0x30,0x30,0x35,0x32,0x30,0x35,0x30,0x37,0x39}; + //assertNull(decoder.decode(null, null, ChannelBuffers.wrappedBuffer(ByteOrder.LITTLE_ENDIAN, buf1))); + + } + +} -- cgit v1.2.3