利用串口解析AIS接收机数据

串口：
串行接口简称串口，也称串行通信接口或串行通讯接口（通常指COM接口），是采用串行通信方式的扩展接口。串行接口 (Serial Interface) 是指数据一位一位地顺序传送，其特点是通信线路简单，只要一对传输线就可以实现双向通信（可以直接利用电话线作为传输线），从而大大降低了成本，特别适用于远距离通信，但传送速度较慢。

AIS接收机：
船舶自动识别系统，是指一种应用于船和岸、船和船之间的海事安全与通信的新型助航系统。常由VHF通信机、GPS定位仪和与船载显示器及传感器等相连接的通信控制器组成，能自动交换船位、航速、航向、船名、呼号等重要信息。装在船上的AIS在向外发送这些信息的同时，同样接收VHF覆盖范围内其他船舶的信息，从而实现了自动应答。此外，作为一种开放式数据传输系统,它可与雷达、ARPA、ECDIS、VTS等终端设备和INTERNET实现连接，构成海上交管和监视网络，是不用雷达探测也能获得交通信息的有效手段，可以有效减少船舶碰撞事故。

GitHub源码：https://github.com/Phoenixsmf/AIS

java实现串口通信：
基于java语言实现 对AIS接收机的数据解析，java代码：

package com.yang.serialport.manager;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.TooManyListenersException;

import com.yang.serialport.utils.ArrayUtils;
import com.yang.serialport.utils.ShowUtils;

import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;

/**
 * 串口管理
 * 
 * @author SMF
 */
@SuppressWarnings("all")
public class SerialPortManager {

	/**
	 * 查找所有可用端口
	 * 
	 * @return 可用端口名称列表
	 */
	public static final ArrayList<String> findPorts() {
		// 获得当前所有可用串口
		Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();
		ArrayList<String> portNameList = new ArrayList<String>();
		// 将可用串口名添加到List并返回该List
		while (portList.hasMoreElements()) {
			String portName = portList.nextElement().getName();
			portNameList.add(portName);
		}
		return portNameList;
	}

	/**
	 * 打开串口
	 * 
	 * @param portName
	 *            端口名称
	 * @param baudrate
	 *            波特率
	 * @return 串口对象
	 * @throws PortInUseException
	 *             串口已被占用
	 */
	public static final SerialPort openPort(String portName, int baudrate) throws PortInUseException {
		try {
			// 通过端口名识别端口
			CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
			// 打开端口，并给端口名字和一个timeout（打开操作的超时时间）
			CommPort commPort = portIdentifier.open(portName, 2000);
			// 判断是不是串口
			if (commPort instanceof SerialPort) {
				SerialPort serialPort = (SerialPort) commPort;
				try {
					// 设置一下串口的波特率等参数
					// 数据位：8
					// 停止位：1
					// 校验位：None
					serialPort.setSerialPortParams(baudrate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
							SerialPort.PARITY_NONE);
				} catch (UnsupportedCommOperationException e) {
					e.printStackTrace();
				}
				return serialPort;
			}
		} catch (NoSuchPortException e1) {
			e1.printStackTrace();
		}
		return null;
	}

	/**
	 * 关闭串口
	 * 
	 * @param serialport
	 *            待关闭的串口对象
	 */
	public static void closePort(SerialPort serialPort) {
		if (serialPort != null) {
			serialPort.close();
		}
	}

	/**
	 * 往串口发送数据
	 * 
	 * @param serialPort
	 *            串口对象
	 * @param order
	 *            待发送数据
	 */
	public static void sendToPort(SerialPort serialPort, byte[] order) {
		OutputStream out = null;
		try {
			out = serialPort.getOutputStream();
			out.write(order);
			out.flush();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (out != null) {
					out.close();
					out = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	

	/**
	 * 从串口读取数据
	 * 
	 * @param serialPort
	 *            当前已建立连接的SerialPort对象
	 * @return 读取到的数据
	 */
	public static byte[] readFromPort(SerialPort serialPort) {
		InputStream in = null;
		byte[] bytes = {};
		try {
			in = serialPort.getInputStream();
			// 缓冲区大小为一个字节
			byte[] readBuffer = new byte[1];
			int bytesNum = in.read(readBuffer);
			while (bytesNum > 0) {
				bytes = ArrayUtils.concat(bytes, readBuffer);
				bytesNum = in.read(readBuffer);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (in != null) {
					in.close();
					in = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return bytes;
	}

	/**
	 * 添加监听器
	 * 
	 * @param port
	 *            串口对象
	 * @param listener
	 *            串口存在有效数据监听
	 */
	public static void addListener(SerialPort serialPort, DataAvailableListener listener) {
		try {
			// 给串口添加监听器
			serialPort.addEventListener(new SerialPortListener(listener));
			// 设置当有数据到达时唤醒监听接收线程
			serialPort.notifyOnDataAvailable(true);
			// 设置当通信中断时唤醒中断线程
			serialPort.notifyOnBreakInterrupt(true);
		} catch (TooManyListenersException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 串口监听
	 */
	public static class SerialPortListener implements SerialPortEventListener {

		private DataAvailableListener mDataAvailableListener;

		public SerialPortListener(DataAvailableListener mDataAvailableListener) {
			this.mDataAvailableListener = mDataAvailableListener;
		}

		public void serialEvent(SerialPortEvent serialPortEvent) {
			switch (serialPortEvent.getEventType()) {
			case SerialPortEvent.DATA_AVAILABLE: // 1.串口存在有效数据
				if (mDataAvailableListener != null) {
					mDataAvailableListener.dataAvailable();
				}
				break;

			case SerialPortEvent.OUTPUT_BUFFER_EMPTY: // 2.输出缓冲区已清空
				break;

			case SerialPortEvent.CTS: // 3.清除待发送数据
				break;

			case SerialPortEvent.DSR: // 4.待发送数据准备好了
				break;

			case SerialPortEvent.RI: // 5.振铃指示
				break;

			case SerialPortEvent.CD: // 6.载波检测
				break;

			case SerialPortEvent.OE: // 7.溢位（溢出）错误
				break;

			case SerialPortEvent.PE: // 8.奇偶校验错误
				break;

			case SerialPortEvent.FE: // 9.帧错误
				break;

			case SerialPortEvent.BI: // 10.通讯中断
				ShowUtils.errorMessage("与串口设备通讯中断");
				break;

			default:
				break;
			}
		}
	}

	/**
	 * 串口存在有效数据监听
	 */
	public interface DataAvailableListener {
		/**
		 * 串口存在有效数据
		 */
		void dataAvailable();
	}
}

界面 代码：

package com.yang.serialport.ui;

import java.awt.Color;
import java.awt.GraphicsEnvironment;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;

import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;

import com.nms.ais.AIS_Analyse;
import com.yang.serialport.manager.SerialPortManager;
import com.yang.serialport.utils.ByteUtils;
import com.yang.serialport.utils.ShowUtils;
import com.yang.serialport.utils.SqlSessionFactoryInit;

import gnu.io.PortInUseException;
import gnu.io.SerialPort;

/**
 * 主界面
 * 
 * @author SMF
 */
@SuppressWarnings("all")
public class MainFrame extends JFrame {

	// 程序界面宽度
	public final int WIDTH = 1000;
	// 程序界面高度
	public final int HEIGHT = 390;

	// 数据显示区
	private JTextArea mDataView = new JTextArea();
	private JScrollPane mScrollDataView = new JScrollPane(mDataView);

	//有效数据显示区域
	public static  JTextArea mDataValiableView = new JTextArea();
	public static JScrollPane mScrollDataViewValiable = new JScrollPane(mDataValiableView);
	// 串口设置面板
	private JPanel mSerialPortPanel = new JPanel();
	private JLabel mSerialPortLabel = new JLabel("串口");
	private JLabel mBaudrateLabel = new JLabel("波特率");
	private JComboBox mCommChoice = new JComboBox();
	private JComboBox mBaudrateChoice = new JComboBox();
	private ButtonGroup mDataChoice = new ButtonGroup();
	private JRadioButton mDataASCIIChoice = new JRadioButton("ASCII", true);
	private JRadioButton mDataHexChoice = new JRadioButton("Hex");

	// 操作面板
	private JPanel mOperatePanel = new JPanel();
	private JTextArea mDataInput = new JTextArea();
	private JButton mSerialPortOperate = new JButton("打开串口");
	private JButton mSendData = new JButton("发送数据");

	// 串口列表
	private List<String> mCommList = null;
	// 串口对象
	private SerialPort mSerialport;

	public MainFrame() {
		try{
		SqlSessionFactoryInit.creatSqlSessionFactory();
		initView();
		initComponents();
		actionListener();
		initData();
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	/**
	 * 初始化窗口
	 */
	private void initView() {
		// 关闭程序
		setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
		// 禁止窗口最大化
		setResizable(false);

		// 设置程序窗口居中显示
		Point p = GraphicsEnvironment.getLocalGraphicsEnvironment().getCenterPoint();
		setBounds(p.x - WIDTH / 2, p.y - HEIGHT / 2, WIDTH, HEIGHT);
		this.setLayout(null);

		setTitle("串口通信");
	}

	/**
	 * 初始化控件
	 */
	private void initComponents() {
		// 数据显示
		mDataView.setFocusable(false);
		mScrollDataView.setBounds(10, 10, 505, 200);
		add(mScrollDataView);
		
		// 数据显示
		mDataValiableView.setFocusable(false);
		mScrollDataViewValiable.setBounds(520, 10, 400, 200);
		add(mScrollDataViewValiable);
		
		
		// 串口设置
		mSerialPortPanel.setBorder(BorderFactory.createTitledBorder("串口设置"));
		mSerialPortPanel.setBounds(10, 220, 170, 130);
		mSerialPortPanel.setLayout(null);
		add(mSerialPortPanel);

		mSerialPortLabel.setForeground(Color.gray);
		mSerialPortLabel.setBounds(10, 25, 40, 20);
		mSerialPortPanel.add(mSerialPortLabel);

		mCommChoice.setFocusable(false);
		mCommChoice.setBounds(60, 25, 100, 20);
		mSerialPortPanel.add(mCommChoice);

		mBaudrateLabel.setForeground(Color.gray);
		mBaudrateLabel.setBounds(10, 60, 40, 20);
		mSerialPortPanel.add(mBaudrateLabel);

		mBaudrateChoice.setFocusable(false);
		mBaudrateChoice.setBounds(60, 60, 100, 20);
		mSerialPortPanel.add(mBaudrateChoice);

		mDataASCIIChoice.setBounds(20, 95, 55, 20);
		mDataHexChoice.setBounds(95, 95, 55, 20);
		mDataChoice.add(mDataASCIIChoice);
		mDataChoice.add(mDataHexChoice);
		mSerialPortPanel.add(mDataASCIIChoice);
		mSerialPortPanel.add(mDataHexChoice);

		// 操作
		mOperatePanel.setBorder(BorderFactory.createTitledBorder("操作"));
		mOperatePanel.setBounds(200, 220, 315, 130);
		mOperatePanel.setLayout(null);
		add(mOperatePanel);

		mDataInput.setBounds(25, 25, 265, 50);
		mDataInput.setLineWrap(true);
		mDataInput.setWrapStyleWord(true);
		mOperatePanel.add(mDataInput);

		mSerialPortOperate.setFocusable(false);
		mSerialPortOperate.setBounds(45, 95, 90, 20);
		mOperatePanel.add(mSerialPortOperate);

		mSendData.setFocusable(false);
		mSendData.setBounds(180, 95, 90, 20);
		mOperatePanel.add(mSendData);
	}

	/**
	 * 初始化数据
	 */
	private void initData() {
		mCommList = SerialPortManager.findPorts();
		// 检查是否有可用串口，有则加入选项中
		if (mCommList == null || mCommList.size() < 1) {
			ShowUtils.warningMessage("没有搜索到有效串口！");
		} else {
			for (String s : mCommList) {
				mCommChoice.addItem(s);
			}
		}

		mBaudrateChoice.addItem("9600");
		mBaudrateChoice.addItem("19200");
		mBaudrateChoice.addItem("38400");
		mBaudrateChoice.addItem("57600");
		mBaudrateChoice.addItem("115200");
	}

	/**
	 * 按钮监听事件
	 */
	private void actionListener() {
		// 串口
		mCommChoice.addPopupMenuListener(new PopupMenuListener() {

			@Override
			public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
				mCommList = SerialPortManager.findPorts();
				// 检查是否有可用串口，有则加入选项中
				if (mCommList == null || mCommList.size() < 1) {
					ShowUtils.warningMessage("没有搜索到有效串口！");
				} else {
					int index = mCommChoice.getSelectedIndex();
					mCommChoice.removeAllItems();
					for (String s : mCommList) {
						mCommChoice.addItem(s);
					}
					mCommChoice.setSelectedIndex(index);
				}
			}

			@Override
			public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
				// NO OP
			}

			@Override
			public void popupMenuCanceled(PopupMenuEvent e) {
				// NO OP
			}
		});

		// 打开|关闭串口
		mSerialPortOperate.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				if ("打开串口".equals(mSerialPortOperate.getText()) && mSerialport == null) {
					openSerialPort(e);
				} else {
					closeSerialPort(e);
				}
			}
		});

		// 发送数据
		mSendData.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				sendData(e);
			}
		});
	}

	/**
	 * 打开串口
	 * 
	 * @param evt
	 *            点击事件
	 */
	private void openSerialPort(java.awt.event.ActionEvent evt) {
		// 获取串口名称
		String commName = (String) mCommChoice.getSelectedItem();
		// 获取波特率，默认为9600
		int baudrate = 9600;
		String bps = (String) mBaudrateChoice.getSelectedItem();
		baudrate = Integer.parseInt(bps);

		// 检查串口名称是否获取正确
		if (commName == null || commName.equals("")) {
			ShowUtils.warningMessage("没有搜索到有效串口！");
		} else {
			try {
				mSerialport = SerialPortManager.openPort(commName, baudrate);
				if (mSerialport != null) {
					mDataView.setText("串口已打开" + "\r\n");
					mSerialPortOperate.setText("关闭串口");
				}
			} catch (PortInUseException e) {
				ShowUtils.warningMessage("串口已被占用！");
			}
		}

		// 添加串口监听
		SerialPortManager.addListener(mSerialport, new SerialPortManager.DataAvailableListener() {

			@Override
			public void dataAvailable() {
				byte[] data = null;
				try {
					if (mSerialport == null) {
						ShowUtils.errorMessage("串口对象为空，监听失败！");
						System.out.print("串口对象为空，监听失败！");
					} else {
						// 读取串口数据
						data = SerialPortManager.readFromPort(mSerialport);
						//System.out.println(data.toString());
						// 以字符串的形式接收数据
						if (mDataASCIIChoice.isSelected()) {
							mDataView.append(new String(data) + "\r\n");							
							AIS_Analyse.comport1_DataReceived(new String(data));
							//System.out.println(new String(data) + "\r\n");
						}

						// 以十六进制的形式接收数据
						if (mDataHexChoice.isSelected()) {
							mDataView.append(ByteUtils.byteArrayToHexString(data) + "\r\n");
							///System.out.println(ByteUtils.byteArrayToHexString(data));
						}
					}
				} catch (Exception e) {
					ShowUtils.errorMessage(e.toString());
					e.printStackTrace();
					// 发生读取错误时显示错误信息后退出系统
					System.exit(0);
				}
			}
		});
	}

	/**
	 * 关闭串口
	 * 
	 * @param evt
	 *            点击事件
	 */
	private void closeSerialPort(java.awt.event.ActionEvent evt) {
		SerialPortManager.closePort(mSerialport);
		mDataView.setText("串口已关闭" + "\r\n");
		mSerialPortOperate.setText("打开串口");
		mSerialport = null;
	}

	/**
	 * 发送数据
	 * 
	 * @param evt
	 *            点击事件
	 */
	private void sendData(java.awt.event.ActionEvent evt) {
		// 待发送数据
		String data = mDataInput.getText().toString();

		if (mSerialport == null) {
			ShowUtils.warningMessage("请先打开串口！");
			return;
		}

		if ("".equals(data) || data == null) {
			ShowUtils.warningMessage("请输入要发送的数据！");
			return;
		}

		// 以字符串的形式发送数据
		if (mDataASCIIChoice.isSelected()) {
			SerialPortManager.sendToPort(mSerialport, data.getBytes());
		}

		// 以十六进制的形式发送数据
		if (mDataHexChoice.isSelected()) {
			SerialPortManager.sendToPort(mSerialport, ByteUtils.hexStr2Byte(data));
		}
	}

	public static void main(String args[]) {
		java.awt.EventQueue.invokeLater(new Runnable() {
			public void run() {
				new MainFrame().setVisible(true);
			}
		});
	}
}

AIS数据解析 此处较为复杂：

package com.nms.ais;

import java.util.ArrayList;
import java.util.List;

import com.nms.dao.config.BoatMapper;
import com.nms.model.config.Boat;
import com.nms.service.config.BoatHistoryService;
import com.nms.service.config.BoatService;
import com.yang.serialport.manager.SerialPortManager;
import com.yang.serialport.ui.MainFrame;
import com.yang.serialport.utils.AISLog;
import com.yang.serialport.utils.MiscUtil;
import com.yang.serialport.utils.Msg;
import com.yang.serialport.utils.SqlSessionFactoryInit;

import gnu.io.SerialPort;
/**
 * @author smf
 * @description ais数据解析
 * */
public class AIS_Analyse {
	public String AIS_msg = null; // 触发一次串口事件接收到的AIS数据

	public static int i = 0;

	public int j = 0;
	public int k = 0;
	/**单一语句长度*/
	public static int data_length = 0; // 单一语句长度
	/**语句字符位置*/
	public int chars_count = 0; // 语句字符位置
	/**完整的一条AIS语句*/
	public static char[] SingleDataBuffer = new char[82]; // 完整的一条AIS语句
	/**一条AIS语句的解封装结果*/
	public static char[] sum_binary = new char[372]; // 一条AIS语句的解封装结果
	/**单一语句字符数*/
	public static int data_count; // 单一语句字符数
	/** AIS语句接收窗口显示的AIS语句计数*/
	public static int newline_count = 0; // AIS语句接收窗口显示的AIS语句计数
	/**事件顺序（语句排列顺序）标识*/
	public static int event_count = 0; // 事件顺序（语句排列顺序）标识
	/**用户船（查询目标）识别码*/
	public String TargetMMSI = null; // 用户船（查询目标）识别码
	/**用户船（查询目标）查询结果标识*/
	public static int MMSI_enable = 0; // 用户船（查询目标）查询结果标识
	/**语句类型识别码*/
	public static int defi_m = 0; // 语句类型识别码
	/**当前AIS信息包含的经度*/
	public static double RecentLongitude; // 当前AIS信息包含的经度
	public static double RecentLatitude; // 当前AIS信息包含的纬度
	public static double RecentCourse; // 当前AIS信息包含的航向信息

	public static double ShipLongitude; // 用户船经度
	public static double ShipLatitude; // 用户船纬度
	public static double BaseLongitude; // 基站经度
	public static double BaseLatitude; // 基站纬度
	public static BoatMapper boatMapper = SqlSessionFactoryInit.getContext().getBean(BoatMapper.class);
	public static BoatService boatService = SqlSessionFactoryInit.getContext().getBean(BoatService.class);
	public static BoatHistoryService boatHistoryService = SqlSessionFactoryInit.getContext().getBean(BoatHistoryService.class);
	public double PI = Math.PI; // 3.14159265358979323846
	public double R = 6371.393; // 地球半径
	public double Distance; // 两点间距离
	/**天线转向的目的位置*/
	public String DestinationAngle = null; // 天线转向的目的位置

	public static int basechange; // 基站切换指令标识
	public static int count_enable; // 指向角度计算控制指令标识 ： 1.计算开始; 0.计算关闭
	public static int angle_send; // 指向角度发送指令标识 : 1.发送开始; 0.发送关闭

	// public bool bOpenPort; //1.串口2关闭; 0.串口2打开
	public Boolean bCountDistanceAUTO; // 指向角计算使能信号: 1.计算开始; 0.计算关闭
	public Boolean bChangeBase; // 基站选择使能信号： 1.选择船载移动基站; 0.选择岸基基站
	public Boolean bAngleSendAUTO; // 目的位置自动发送使能型号: 1.发送开始; 0.发送关闭
	private static List<String> _buff = new ArrayList<String>();
	private static Boolean _recstatu = false; // 是否处于一个正在接收数据包的状态
	/**数据域起始位*/
	public static int data_start; // 数据域起始位
	/**数据域终止位*/
	public static int data_end; // 数据域终止位
	/** 语句类型识别码*/
	public static int sen_f; // 语句类型识别码

	public static void Data_analyze_m123(String AISMessage ) // 消息1、2、3数据解析
	{
		int i=0;
		Boat boat = new Boat();

		AISMessage += "\r\n\r\n";
		AISMessage += "解析后的数据如下：\r\n\r\n";

		// 二进制数据向有效数据转换

		char data_tr_bin; // 二进制数据中间变量初始化
		int data_tr_valid = 0; // 有效数据中间变量初始化
		int count_s = 0; // 数据位起始值
		int count_e = 0; // 数据位终止值
		int digit_num; // 数据位数

		// 提取消息识别码

		int message_identifier; // 消息识别码

		digit_num = 6; // 消息识别码的位数为6位
		count_e = count_s + digit_num - 1; // 计算数据终止位

		for (i = count_s; i <= count_e; i++) {
			data_tr_bin = sum_binary[i];
			data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));
		}

		message_identifier = data_tr_valid;

		switch (message_identifier) {
		case 1: {
			AISMessage += "消息识别码：  ";
			AISMessage += String.valueOf(message_identifier);
			AISMessage += "  即 消息类型为“定时的船位报告（A类船载移动设备）”。\r\n";

			break;
		}

		case 2: {
			AISMessage += "消息识别码：  ";
			AISMessage += String.valueOf(message_identifier);
			AISMessage += "  即 消息类型为“定时的船位报告（A类船载移动设备）”。\r\n";

			break;
		}

		case 3: {
			AISMessage += "消息识别码：  ";
			AISMessage += String.valueOf(message_identifier);
			AISMessage += "  即 消息类型为“特别船位报告，对询问的回复（A类船载移动设备）”。\r\n";

			break;
		}

		}

		count_s = count_e + 1; // 提取完毕后，重置数据位起始值

		// END（提取消息识别码）

		// 提取转发指示符

		int transpond_indicate; // 转发指示符

		digit_num = 2; // 转发指示符的位数为2位
		count_e = count_s + digit_num - 1; // 计算数据终止位
		data_tr_valid = 0;
		for (i = count_s; i <= count_e; i++) {
			data_tr_bin = sum_binary[i];
			data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));
		}

		transpond_indicate = data_tr_valid;

		AISMessage += "转发指示符：  ";

		AISMessage += String.valueOf(transpond_indicate);
		AISMessage += "  即 该条消息被转发的次数为：";
		AISMessage += String.valueOf(transpond_indicate);
		AISMessage += "  次。\r\n";

		count_s = count_e + 1; // 提取完毕后，重置数据位起始值

		// END（提取转发指示符）

		// 提取用户识别码，即MMSI码

		int MMSI; // 用户识别码

		digit_num = 30; // 用户识别码，即MMSI码的位数为30位
		count_e = count_s + digit_num - 1; // 计算数据终止位
		data_tr_valid = 0;
		for (i = count_s; i <= count_e; i++) {
			data_tr_bin = sum_binary[i];
			data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));
		}

		MMSI = data_tr_valid;

		AISMessage += "用户识别码（即MMSI码）：  ";
		AISMessage += String.valueOf(MMSI);
		AISMessage += "\r\n";

		//String MMSI_OUT = String.valueOf(MMSI); // 提取当前信息的MMSI码，用于船舶识别

		count_s = count_e + 1; // 提取完毕后，重置数据位起始值

		// END（提取用户识别码，即MMSI码）

		// 提取航行状态

		int navigation_status; // 航行状态

		digit_num = 4; // 航行状态的位数为4位
		count_e = count_s + digit_num - 1; // 计算数据终止位
		data_tr_valid = 0;
		for (i = count_s; i <= count_e; i++) {
			data_tr_bin = sum_binary[i];
			data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));
		}

		navigation_status = data_tr_valid;

		AISMessage += "航行状态：  ";
		AISMessage += String.valueOf(navigation_status);
		if (navigation_status == 15)
			AISMessage += " 即 默认值（未定义）";
		AISMessage += "\r\n";

		count_s = count_e + 1; // 提取完毕后，重置数据位起始值

		// END（提取航行状态）

		// 提取转向率ROT(AIS)

		int ROT_AIS; // 转向率ROT(AIS)

		digit_num = 8; // 转向率ROT(AIS)的位数为8位
		count_e = count_s + digit_num - 1; // 计算数据终止位
		data_tr_valid = 0;

		if (sum_binary[count_s] != '1') {

			for (i = count_s; i <= count_e; i++) {
				data_tr_bin = sum_binary[i];
				data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));

			}

			ROT_AIS = data_tr_valid;

			AISMessage += "转向率ROT(AIS)：  ";
			AISMessage += String.valueOf(ROT_AIS);
			AISMessage += " 度/分钟";
			AISMessage += "\r\n";

		}

		else if (sum_binary[count_s] == '1') {
			// ("转向率是负数\n");
			for (i = count_s + 1; i <= count_e; i++) {
				if (sum_binary[i] == '0')
					data_tr_bin = '1';
				else
					data_tr_bin = '0';

				data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));

			}
			data_tr_valid = data_tr_valid + 1;

			data_tr_valid = -data_tr_valid;

			ROT_AIS = data_tr_valid;

			AISMessage += "转向率ROT(AIS)：  ";
			AISMessage += String.valueOf(ROT_AIS);
			AISMessage += " 度/分钟";
			if (ROT_AIS == -128)
				AISMessage += " 即默认值（表示无法获得）";
			AISMessage += "\r\n";
		}

		count_s = count_e + 1; // 提取完毕后，重置数据位起始值

		// END（提取转向率ROT(AIS)）

		// 提取对地航速

		double speed_over_ground; // 对地航速

		digit_num = 10; // 对地航速的位数为10位
		count_e = count_s + digit_num - 1; // 计算数据终止位
		data_tr_valid = 0;

		for (i = count_s; i <= count_e; i++) {
			data_tr_bin = sum_binary[i];
			data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));
		}

		speed_over_ground = (float) (data_tr_valid) / 10;

		AISMessage += "对地航速：  ";
		AISMessage += String.valueOf(speed_over_ground);
		boat.setSog(speed_over_ground+"kn");
		AISMessage += " kn";
		AISMessage += "\r\n";

		count_s = count_e + 1; // 提取完毕后，重置数据位起始值

		// END（提取对地航速）

		// 提取船位精确度

		int position_accuracy; // 船位精确度

		digit_num = 1; // 船位精确度的位数为1位
		count_e = count_s + digit_num - 1; // 计算数据终止位
		data_tr_valid = 0;
		for (i = count_s; i <= count_e; i++) {
			data_tr_bin = sum_binary[i];
			data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));

		}

		position_accuracy = data_tr_valid;

		AISMessage += "船位精确度：  ";
		AISMessage += String.valueOf(position_accuracy);
		if (data_tr_valid == 1)
			AISMessage += " 即 高精度（<10m，DGNSS接收机的差分模式）";
		else if (data_tr_valid == 0)
			AISMessage += " 即 低精度（>10m，GNSS接收机或其他电子定位装置的自主模式）";
		AISMessage += "\r\n";

		count_s = count_e + 1; // 提取完毕后，重置数据位起始值

		// END（提取船位精确度）

		// 提取经度

		double longitude; // 经度

		digit_num = 28; // 经度的位数为28位
		count_e = count_s + digit_num - 1; // 计算数据终止位
		data_tr_valid = 0;

		int hour;
		int minute;
		double second;

		if (sum_binary[count_s] != '1') {
			// ("经度是正数，即东经\n");
			for (i = count_s; i <= count_e; i++) {
				data_tr_bin = sum_binary[i];
				data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));

			}

			longitude = (float) ((data_tr_valid) / 10000);

			hour = (int) (data_tr_valid / 10000 / 60);

			minute = (int) (longitude - hour * 60);

			second = (longitude - hour * 60 - minute) * 60;

			RecentLongitude = longitude / 60; // 将经度信息传递给全局变量,单位为度

			AISMessage += "经度：  ";
			AISMessage += "东经 ";
			AISMessage += String.valueOf(hour);
			AISMessage += "度";
			AISMessage += String.valueOf(minute);
			AISMessage += "分";
			AISMessage += String.valueOf(0.0000);
			AISMessage += "秒";
			AISMessage += "\r\n";

		}

		else if (sum_binary[count_s] == '1') {
			// ("经度是负数，即西经\n");
			for (i = count_s + 1; i <= count_e; i++) {
				if (sum_binary[i] == '0')
					data_tr_bin = '1';
				else
					data_tr_bin = '0';

				data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));

			}
			data_tr_valid = data_tr_valid + 1; // 经度的绝对值

			longitude = (float) ((data_tr_valid) / 10000);

			hour = (int) (data_tr_valid / 10000 / 60);

			minute = (int) (longitude - hour * 60);

			second = (longitude - hour * 60 - minute) * 60;

			longitude = -longitude; // 经度的真实值

			RecentLongitude = longitude / 60; // 将经度信息传递给全局变量

			AISMessage += "经度：  ";
			AISMessage += "西经 ";
			AISMessage += String.valueOf(hour);
			AISMessage += "度";
			AISMessage += String.valueOf(minute);
			AISMessage += "分";
			AISMessage += String.valueOf(0.0000);
			AISMessage += "秒";
			AISMessage += "\r\n";

		}

		count_s = count_e + 1; // 提取完毕后，重置数据位起始值

		// END（提取经度）

		// 提取纬度

		double latitude; // 纬度

		digit_num = 27; // 纬度的位数为27位
		count_e = count_s + digit_num - 1; // 计算数据终止位
		data_tr_valid = 0;

		if (sum_binary[count_s] != '1') {
			 ("纬度是正数，即北纬\n");
			for (i = count_s; i <= count_e; i++) {
				data_tr_bin = sum_binary[i];
				data_tr_valid = data_tr_valid + (data_tr_bin - '0') * (int) (Math.pow(2, count_e - i));

			}

			latitude = (float) (data_tr_valid) / 10000;

			hour = (int) (data_tr_valid / 10000 / 60);

			minute = (int) (latitude - hour * 60);

			second = (latitude - hour * 60 - minute) * 60;

			RecentLatitude = latitude / 60; // 将当前纬度传递给全局变量

			AISMessage += "纬度：  ";
			AISMessage += "北纬 ";
			AISMessage += String.valueOf(hour);
			AISMessage += "度";
			AISMessage += String.valueOf(minute);
			AISMessage += "分";
			AISMessage += String.valueOf(0.0000);
			AISMessage += "秒";
			AISMessage += "\r\n";

		}

		else if (sum_binary[count_s] == '1') {
			// ("纬度是负数，即南纬\n");
			for (i = count_s + 1; i <= count_e; i++) {
				if (sum_binary[i] == '0')
					data_tr_bin = '1';
				else
					data_tr_bin = '0';

				data_