Java Android在31-33次传输后停止接收来自微控制器的TCP传输

我有一个来自Android设备的移动热点，通过TCP无线连接到一个粒子光子，该粒子光子从激光雷达传感器发回一个距离测量值

光子持续查询传感器，从我的终端，串行输出持续实时显示距离

然而，在31到33次传输之后，我的Android上的TCP客户端停止显示实时信息。它无法接收光子正在发送的传输。在31次传输之后，无论传输间隔是1毫秒还是1000毫秒，它似乎都会挂起

为什么会发生这种情况，我如何防止这种情况发生

请在下面找到我的Java代码（Android）和接线代码（Photon）

安卓：

import android.util.Log;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;


public class TCPClient {
    private int i = 0;
    private String serverMessage;
    public static String buttonPushed;
    public static final String SERVERIP = "xxx.xxx.xxx.xxx"; //your Photon IP address
    public static final int SERVERPORT = 23;
    private OnMessageReceived mMessageListener = null;
    private boolean mRun = false;

    PrintWriter out;
    BufferedWriter out1;
    OutputStreamWriter out2;
    OutputStream out3;
    BufferedReader in;

    /**
     *  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 (out != null && !out.checkError()) {
            out.println(message);
            Log.d("TCP Client", "Message: " + message);
            out.flush();
        }
    }

    public void stopClient(){
        mRun = false;
    }

    public void run() {

        sendMessage(buttonPushed);
        if (buttonPushed == "Disconnect") {
            stopClient();
            return;
        }

        mRun = true;

        try {
            sendMessage(buttonPushed);
            if (buttonPushed == "Disconnect") {
                stopClient();
                return;
            }
            //here you must put your computer's IP address.
            InetAddress serverAddr = InetAddress.getByName(SERVERIP);

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

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

            try {
                sendMessage(buttonPushed);
                if (buttonPushed == "Disconnect") {
                    disconnectSession(socket);
                    return;
                }
                //send the message to the server

                out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);

                sendMessage(buttonPushed);

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

                //in this while the client listens for the messages sent by the server
                while (mRun) {
                    Log.e("TCP Client", "C: Reading from server...");

                    serverMessage = in.readLine();

                    Log.e("TCP Client", "C: Server successfully read!");
                    new TCPClient(mMessageListener);

                    if (serverMessage != null && mMessageListener != null) {
                        //call the method messageReceived from MyActivity class
                        mMessageListener.messageReceived(serverMessage);
                        i++;
                        Log.d("Incoming counter", String.valueOf(i));
                    } else {
                        serverMessage = null;
                    }

                    sendMessage(buttonPushed);
                    if (buttonPushed == "Disconnect") {
                        disconnectSession(socket);
                        break;
                    }
                }

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




            } catch (Exception e) {
                Log.e("TCP", "S: Error", e);
            } finally {
                if (buttonPushed == "Disconnect") {
                    disconnectSession(socket);
                    return;
                }
            }

        } catch (Exception e) {
            Log.e("TCP", "C: Error", e);
        }

    }

    public void disconnectSession(Socket socket) throws IOException {
        stopClient();

        //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();
        serverMessage = null;
    }

    //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);
    }
}

光子：

#include "application.h"
SYSTEM_MODE(MANUAL);

// TCP setup
TCPServer server = TCPServer(23);
TCPClient client;

int range;
// char read;
String readString;
String sentRange;

// LIDAR sensor setup

const int monitorPin1 = 3;
const int monitorPin2 = 1;

const int triggerPin1 = 2;
const int triggerPin2 = 0;

long pulseWidth;

// Initialise averaging array
const int numberOfReadings = 10; // reasonable DOF from Measurement and Noise
const int med = numberOfReadings/2;
long readings[numberOfReadings];
int median;

void setup() {
    Serial.begin(9600);
    WiFi.clearCredentials();

    //LIDAR 
    pinMode(triggerPin1, OUTPUT); // Set pin 2 as trigger pin
    pinMode(D7, OUTPUT);
    digitalWrite(triggerPin1, LOW); // Set trigger HIGH for non-continuous read
    pinMode(monitorPin1, INPUT); // Set pin 3 as monitor pin

    pinMode(triggerPin2, OUTPUT); // Set pin 2 as trigger pin
    digitalWrite(triggerPin2, LOW); // Set trigger HIGH for non-continuous read
    pinMode(monitorPin2, INPUT); // Set pin 3 as monitor pin
    delay(2000);

    WiFi.on(); // if this isn't working, make sure it's set up for Photons (not Electrons!)
    WiFi.setCredentials("AndroidAP", "12345678"); // NB: must call WiFi.on() before this line. Not sure why.
    delay(2000);
    WiFi.connect();

    // start listening for clients
    server.begin();
}

int readLIDAR(int triggerPin, int monitorPin){
    pulseWidth = pulseIn(monitorPin, HIGH); // Count how long the pulse is high in microseconds
    pulseWidth = pulseWidth / 10; // 10usec = 1 cm of distance
    return pulseWidth;
}

long takeReading(int triggerPin, int monitorPin) {
  for (int i = 0; i < numberOfReadings; i++) {
    readings[i] = readLIDAR(triggerPin, monitorPin);
    delay(10); // There doesn't seem to be a requirement for a delay, but to be safe, delay = 10ms.
  }
  return *readings;
}

// Sort readings
long sort(long* readings) {
    // bubble sort with flag
    for (int i = 0; i < numberOfReadings; i++) {
        bool flag = true;
        for (int j = 1; j < numberOfReadings; j++) {
            if (readings[j-1] > readings[j]) {
                int t = readings[j-1];
                readings[j-1] = readings[j];
                readings[j] = t;
                flag = false;
            }
        }
        if (flag) break;
    }
    return *readings;
}

int range1(String command){
    if (command == "Get range 1\n") *readings = takeReading(triggerPin1, monitorPin1); // gather sufficient (typ: 10) readings
    else if (command == "Get range 2\n") *readings = takeReading(triggerPin2, monitorPin2); // gather sufficient (typ: 10) readings

    *readings = sort(readings); // sort in ascending order for median value
    median = (readings[med-1] + readings[med])/2; // get median value to send to app
    memset(readings, 0, sizeof(readings)); //clear previous readings

    return median;
}

String goGetCredentials() {
    WiFiAccessPoint ap[5];
    int found = WiFi.getCredentials(ap, 5);
    for (int i = 0; i < found; i++) {
        Serial.print("ssid: ");
        Serial.println(ap[i].ssid);
        // security is one of WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA, WLAN_SEC_WPA2
        Serial.print("security: ");
        Serial.println(ap[i].security);
        // cipher is one of WLAN_CIPHER_AES, WLAN_CIPHER_TKIP
        Serial.print("cipher: ");
        Serial.println(ap[i].cipher);
    }
}

void loop() {

    if (client.connected()) {
        Serial.println("Client connected.");
        // read client for which sensor to query and send back result
        while (client.available()) {
            readString = "Get range 1\n";
            range = range1(readString);
            sentRange = "u" + String(range) + " cm" + "\n";
            Serial.print(sentRange);
            server.write(sentRange);

            delay(300);

            readString = "Get range 2\n";
            range = range1(readString);
            sentRange = "f" + String(range) + " cm" + "\n";
            Serial.print(sentRange);
            server.write(sentRange);
            delay(300);
        }
    } else {
        // if no client is yet connected, check for a new connection
        client = server.available();

        if(WiFi.hasCredentials()==true) {
          Serial.println("Has credentials.");
        //   goGetCredentials();
        } else {
          Serial.println("No credentials.");
        }

        Serial.println("Looking for server.");
        delay(2000);
    }
}

#包括“application.h”
系统模式（手动）；
//TCP设置
TCPServer服务器=TCPServer（23）；
TCP客户机；
整数范围；
//字符读取；
字符串读取字符串；
字符串范围；
//激光雷达传感器设置
const int monitorPin1=3；
常数int monitorPin2=1；
常数int triggerPin1=2；
常数int触发器pin2=0；
长脉冲宽度；
//初始化平均阵列
常数int numberOfReadings=10；//从测量和噪声看合理的自由度
常数int med=读数数/2；
长读数[读数数量]；
整数中值；
无效设置（）{
Serial.begin（9600）；
WiFi.clearCredentials（）；
//激光雷达
pinMode（triggerPin1，输出）；//将引脚2设置为触发引脚
引脚模式（D7，输出）；
digitalWrite（triggerPin1，低）；//为非连续读取设置触发器高
引脚模式（监视器引脚1，输入）；//将引脚3设置为监视器引脚
pinMode（triggerPin2，输出）；//将引脚2设置为触发引脚
digitalWrite（triggerPin2，低）；//为非连续读取设置触发器高
引脚模式（监视器引脚2，输入）；//将引脚3设置为监视器引脚
延迟（2000年）；
WiFi.on（）；//如果这不起作用，请确保它是为光子（而不是电子）设置的
WiFi.setCredentials（“AndroidAP”，“12345678”）；//注意：必须在此行之前调用WiFi.on（）。不确定原因。
延迟（2000年）；
WiFi.connect（）；
//开始监听客户机
server.begin（）；
}
int readLIDAR（int触发器、int监视器）{
脉冲宽度=脉冲宽度（监视器，高）；//以微秒为单位计算脉冲高的时间
脉冲宽度=脉冲宽度/10；//10usec=1厘米的距离
返回脉冲宽度；
}
长取读数（int触发器引脚、int监视器引脚）{
对于（int i=0；i读数[j]）{
int t=读数[j-1]；
读数[j-1]=读数[j]；
读数[j]=t；
flag=false；
}
}
如果（旗帜）断裂；
}
返回*读数；
}
int range1（字符串命令）{
if（command==“Get range 1\n”）*reads=takeReading（triggerPin1，monitorPin1）；//收集足够的（典型值：10）读数
else if（command==“Get range 2\n”）*reads=takeReading（triggerPin2，monitorPin2）；//收集足够的（典型值：10）读数
*读数=排序（读数）；//按中值升序排序
中值=（读数[med-1]+读数[med]）/2；//获取要发送到应用程序的中值
memset（读数，0，sizeof（读数））；//清除以前的读数
返回中值；
}
字符串goGetCredentials（）{
wifiaccesspointap[5]；
int found=WiFi.getCredentials（ap，5）；
for（int i=0；i

---

提前谢谢

提前感谢。如果你不需要帮助，就说这样的话；