Question

我正在编写将接受来自arduino的字节值的代码，将它们存储为数组，执行一些数学计算，然后将值发送回arduino。现在我可以向Arduino发送127个值，然后返回127个值，但它们的类型为string，并且任何尝试使用Integer类转换这些字符串都会导致程序挂起。我相信缓冲区有时会提供空字符串，而parseInt（）不知道该怎么做。有没有人有什么建议？我是java的初学者，可以接受更好的解决方案。

这是我的代码：

package GridMap;

import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 *
*/
public class SerialWriter implements Runnable {

OutputStream out;
byte array[] = new byte[10];
byte c;

public SerialWriter(OutputStream out, byte[] in) {
    this.out = out;
    array = in;
}

public void run() {

        try {
            int index = 0;
            c = array[index];
            while ((c) > -1) {
                this.out.write(c);
                System.out.println("sent " + c);
                if (index == 64){
                    Thread.sleep(2);
                }
                index++;
                c = array[index];
            }
            TwoWaySerialComm.recieve();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }


}
}

public class SerialReader implements Runnable {
static byte[] output = new byte[128];
private InputStream in;
private int[] buffer = new int[11];
static SerialPort thisSerialPort;
static OutputStream thisOut;
static String total = new String("333");

public SerialReader(InputStream in) {
    this.in = in;

    for (byte i = 0; i < 127; i++) {
            output[i] = i;
        }
    output[127] = - 1;
}
public void run ()
    {
        byte[] buffer = new byte[1024];
        int len = -1;
        int index = 0;
        int value;
        try
        {
            Thread.sleep(200);

            while (( len = this.in.read(buffer)) > -1 && index < 200)
            {


                String string = new String(buffer, 0, len);
                //value = Integer.getInteger(string, len);
               // System.out.print(value);
                //System.out.println("buffer" + value);
                System.out.print(string);
                index++;

            }


            TwoWaySerialComm.send(output);
        }
        catch (Exception e )
        {
            e.printStackTrace();
        } 
    }
public static int byteArrayToInt(byte[] b) 
{
return   b[3] & 0xFF |
        (b[2] & 0xFF) << 8 |
        (b[1] & 0xFF) << 16 |
        (b[0] & 0xFF) << 24;
}


}
public class TwoWaySerialComm {

static SerialPort serialPort;
static OutputStream out = null;
static InputStream in;
static Thread receiveThread;
static Thread sendThread;
static byte[] output = new byte[11];


public TwoWaySerialComm() {
    super();
}

void connect(String portName) throws Exception {
    CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
    if (portIdentifier.isCurrentlyOwned()) {
        System.out.println("Error: Port is currently in use");
    } else {
        CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000);

        if (commPort instanceof SerialPort) {
            serialPort = (SerialPort) commPort;
            serialPort.setSerialPortParams(114400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);




        } else {
            System.out.println("Error: Only serial ports are handled by this example.");
        }
    }

}

static void send(byte[] output) {
    try {
        out = serialPort.getOutputStream();
        sendThread = new Thread(new SerialWriter(out, output));
        sendThread.start();
        //sendThread.join();
    } catch (Exception e) {
        System.out.println("Port Not Avaialable (send) ");
    }
}

static void recieve(){
    try {
    in = serialPort.getInputStream();
    receiveThread = new Thread(new SerialReader(in));
    receiveThread.start();
    receiveThread.join();
    } catch (Exception e) {

    }
}

public static void main(String[] args) {
    try {

        (new TwoWaySerialComm()).connect("COM3");

        for (byte i = 0; i < 10; i++) {
            output[i] = i;
        }
        output[10] = -1;
        send(output);  



    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

public static SerialPort returnSerialPort(){
    return serialPort;
}
}

Answer 1

我没有完全得到描述但问题标题的答案就在这里 Convert InputStream to byte array in Java

Answer 2

从corsiKa对Determine if a String is an Integer in Java的回答，您可以检查String是否是这样的有效int：

public static boolean isInteger(String s) {
    try { 
        Integer.parseInt(s); 
    } catch(NumberFormatException e) { 
        return false; 
    }
    // only got here if we didn't return false
    return true;
}

Answer 3

如果你想从你的流中获取int，使用BuffereInputStream会更容易，并使用read（）方法返回一个int - ＆gt;无需转换。在SerialReader类中添加：

  Thread.sleep(200);
  BufferedInputStream input = new BufferedInputStream(in);

  while ((value = input.read()) != 1 && index < 200)
  {
    compute(value);
    index++;
  }
  input.close();

当您阅读完所有数据后，请不要忘记关闭（）您的信息流。写入时这一点更为重要，因为如果不关闭（），则不会写入所有数据（除非您之前使用flush（））。

在Java中将输入流转换为数组的最佳方法是什么？

3 个答案: