如何在TCP端口上使用二进制通信协议发送数据包

Question

我正在开发一种设备，通过传感器测量某些读数。该设备由一个Android应用程序操作。我需要从TCP层获取读数。以下是发送TCP数据的代码：

TcpClient.java

import android.util.Log;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;

/**
* Created by shahbaz on 25/4/17.
*/

 public class TcpClient {

 public static final String SERVER_IP = "192.168.1.76"; //server IP address
 public static final int SERVER_PORT = 1800;
 // message to send to the server
 private String mServerMessage;
 // sends message received notifications
 private OnMessageReceived mMessageListener = null;
 // while this is true, the server will continue running
 private boolean mRun = false;
 // used to send messages
 private PrintWriter mBufferOut;
 // used to read messages from the server
 private BufferedReader mBufferIn;

 /**
  * Constructor of the class. OnMessagedReceived listens for the messages received from server
  */
 public TcpClient(OnMessageReceived listener) {
    mMessageListener = listener;
 }

/**
 * Sends the message entered by client to the server
 *
 * @param message text entered by client
 */
public void sendMessage(String message) {
    if (mBufferOut != null && !mBufferOut.checkError()) {
        mBufferOut.println(message);
        mBufferOut.flush();
    }
}

/**
 * Close the connection and release the members
 */
public void stopClient() {

    mRun = false;

    if (mBufferOut != null) {
        mBufferOut.flush();
        mBufferOut.close();
    }

    mMessageListener = null;
    mBufferIn = null;
    mBufferOut = null;
    mServerMessage = null;
}

public void run() {

    mRun = true;

    try {
        //here you must put your computer's IP address.
        InetAddress serverAddr = InetAddress.getByName(SERVER_IP);

        Log.e("TCP Client", "C: Connecting...");

        //create a socket to make the connection with the server
        Socket socket = new Socket(serverAddr, SERVER_PORT);

        try {

            //sends the message to the server
            mBufferOut = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);

            //receives the message which the server sends back
            mBufferIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));


            //in this while the client listens for the messages sent by the server
            while (mRun) {

                mServerMessage = mBufferIn.readLine();

                if (mServerMessage != null && mMessageListener != null) {
                    //call the method messageReceived from MyActivity class
                    mMessageListener.messageReceived(mServerMessage);
                }

            }

            Log.e("RESPONSE FROM SERVER", "S: Received Message: '" + mServerMessage + "'");

        } catch (Exception e) {

            Log.e("TCP", "S: Error", e);

        } finally {
            //the socket must be closed. It is not possible to reconnect to this socket
            // after it is closed, which means a new socket instance has to be created.
            socket.close();
        }

    } catch (Exception e) {

        Log.e("TCP", "C: Error", e);

    }

}

   //Declare the interface. The method messageReceived(String message) will must be implemented in the MyActivity
   //class at on asynckTask doInBackground
   public interface OnMessageReceived {
    public void messageReceived(String message);
}

}

数据包结构

数据包格式包含以下内容： 在使用TCP与设备通信时，无法识别数据包之间的边界。在这种情况下，如果数据包不按顺序或任何数据包丢失，则可以使用“头部开始”来识别新的数据包。 因此，数据包中的前两个字节表示数据包的开头。

头部开始：两个字节的字段，表示每个数据包的开始。0x55AA是用作头部开始的2字节数字。

协议版本：1字节字段，用于指定正在使用的协议版本。在有效载荷中指定的版本将决定有效载荷结构。在任何给定时刻，设备将支持单个协议版本。目前的协议版本为“1”。

DSN：序列号是1字节字段，可唯一标识数据包。请求方必须在请求有效载荷中填写此字段；响应方必须在响应有效载荷中填写相同的唯一标识符。

请求ID：一个字节的字段，指定命令ID。根据命令ID进行有效载荷的解析。在请求有效载荷的情况下，此字段将为非零值，在响应中将为零。

有效载荷长度：两个字节的字段，指定有效载荷的长度（以字节为单位）。它指定了跟随有效载荷长度字段的字节数。在有效载荷长度、头部长度和CRC中不包括。目前，网关设备支持的最大有效载荷长度为512（字节）。 CRC：1字节字段，将通过对所有字节进行异或并添加0的异或计数来计算。

它正在工作。但是根据文档，我必须使用二进制通信协议发送数据包。包括头部开始、有效载荷数据等。如何在数据包结构中发送这些参数？如何创建数据包？

任何帮助都将不胜感激。

- Shahbaz Hashmi

---

由于你要发送字节，所以你（可能）需要使用DataInputStream和DataOutputStream。我会使用一个长度为7的字节数组来存储“Header Start”到“Payload Length”。然后再使用另一个最大长度为2^15的字节数组来存储“Payload Data”和“CRC”。然后将这两个数组连接成一个大小为7 + 2^15的字节数组，并使用DataOutputStream#write(byte[] array, int offset, int length)写入该数组，其中offset将为0，length将为7 + 2^15。但是，这是一种非常低级的方法。 - Jonny Henly

请您可以发一篇带有代码的答案吗？另外，负载数据如何处理？它的结构是什么样的？ - Shahbaz Hashmi

我想翻译，但我要上班迟到了。感谢您编辑您的问题，由于您的编辑和我对此问题的兴趣，我将我的负评改为正评。我下班后会再次查看是否有任何答案发布，如果没有，我会尝试提供一个答案。 - Jonny Henly

谢谢Jonny。请在您有空的时候稍后发布您的答案。我也会尝试。 - Shahbaz Hashmi

嗨Jonny，我更新了我的问题。我该如何创建数据包？请帮忙。 - Shahbaz Hashmi

Answer 1

主要错误是我没有考虑原始数据类型的大小。

byte = 1字节

short = 2字节

int = 4字节 long = 8字节

float = 4字节

double = 8字节

char = 2字节

参考了原始数据类型的大小之后，我意识到我们应该跟踪数据包的大小和索引，因为我们正在处理字节数组。

TcpPacket.java

public class TcpPacket {

private static int header_start =  0x55AA;

private static int protocol_version = 1;

private PacketUtils packetUtils = new PacketUtils();






 public byte[] getHandshakePacket()
 {
    int request_id = 1;

    byte[] header_data = packetUtils.ItoBA2(header_start);
    byte[] payload_data = packetUtils.ItoBA4(packetUtils.getDateTime());
    byte[] payload_length = packetUtils.ItoBA2(4);


    byte[] a_data = new byte[]{header_data[0], header_data[1], (byte) protocol_version, packetUtils.getDSN(), (byte) request_id, payload_length[0], payload_length[1],
            payload_data[0], payload_data[1], payload_data[2], payload_data[3]};

    byte[] b_data = new byte[]{ packetUtils.getCRC(a_data)};

    byte[] packet_data = packetUtils.concatBytes(a_data,b_data);


    return packet_data;
 }

}

PacketUtils.java

public class PacketUtils {



public byte[] ItoBA4(int value) {       // integer to bytes function (return byte array of 4 bytes)
    return new byte[] {
            (byte)(value >>> 24),
            (byte)(value >>> 16),
            (byte)(value >>> 8),
            (byte)value};
}


public byte[] ItoBA2(int value) {   // integer to bytes function (return byte array of 2 bytes)
    return new byte[] {
            (byte)(value >>> 8),
            (byte)value};
}


public byte getDSN()    // return one byte random number
{
    char[] chars = "1234567890".toCharArray();
    StringBuilder sb = new StringBuilder();
    Random random = new Random();
    for (int i = 0; i < 1; i++) {
        char c = chars[random.nextInt(chars.length)];
        sb.append(c);
    }
    byte output = Byte.valueOf(sb.toString());
    return output;
}



public byte getCRC(byte[] packet)   //  required CRC function (return byte)
{
    try
    {
        if (packet == null)
        {
            //Logger.Error("empty packet received");
            return (byte)0;
        }

        byte XORCheckSum = 0;
        byte zeroCount = 0;
        byte FFCount = 0;

        for (int i = 0; i < packet.length; i++)
        {
            XORCheckSum ^= packet[i];
            if (packet[i] == (byte) 0)
            {
                zeroCount++;
                continue;
            }
            if (packet[i] == (byte)255)
            {
                FFCount++;
                continue;
            }
        }

        XORCheckSum ^= zeroCount;
        XORCheckSum ^= FFCount;
        return XORCheckSum;
    }
    catch (Exception ex)
    {
        //Logger.Error(ex);
        return (byte)0;
    }
}



byte[] concatBytes(byte[]...arrays)     //  concatenate byte arrays
{
    // Determine the length of the result array
    int totalLength = 0;
    for (int i = 0; i < arrays.length; i++)
    {
        totalLength += arrays[i].length;
    }

    // create the result array
    byte[] result = new byte[totalLength];

    // copy the source arrays into the result array
    int currentIndex = 0;
    for (int i = 0; i < arrays.length; i++)
    {
        System.arraycopy(arrays[i], 0, result, currentIndex, arrays[i].length);
        currentIndex += arrays[i].length;
    }

    return result;
}

public int getDateTime()
{
    int dateInSec = (int) (System.currentTimeMillis() / 1000);
    return dateInSec;

}



}

- Shahbaz Hashmi