Fatal编程技术网
  • java/
  • Java 包含空元素的Fifo缓冲区

Java 包含空元素的Fifo缓冲区

java arrays

Java 包含空元素的Fifo缓冲区,java,arrays,arraylist,fifo,Java,Arrays,Arraylist,Fifo,我有一个通过rs232与程序通信的设备。设备发送一条消息，程序逐字节读取并放入缓冲区，以便另一个线程解析缓冲区。 问题是，在消息中，我将有一个0x00字节{null element for fifo buffer}，所以我不能在fifo中输入该元素。如何解决这个问题。 我用 如何输入空元素，因为消息将有空字节 用于解析的代码（用于解析的线程）： public void run（）{ while（true）{ 而（！queue.isEmpty（））{ System.out.println（queu

我有一个通过rs232与程序通信的设备。设备发送一条消息，程序逐字节读取并放入缓冲区，以便另一个线程解析缓冲区。 问题是，在消息中，我将有一个0x00字节{null element for fifo buffer}，所以我不能在fifo中输入该元素。如何解决这个问题。 我用

如何输入空元素，因为消息将有空字节

用于解析的代码（用于解析的线程）：

public void run（）{
while（true）{
而（！queue.isEmpty（））{
System.out.println（queue.size（）+“1 proverka”）；
sb=新的StringBuilder（）；
字节stx=queue.poll（）；
System.out.println（byteToHex（stx）+“解析器”）；
如果（stx==0x02）{
sb.append（字符串格式（“%02X”，stx））；
System.out.println（queue.size（）+“2 proverka”）；
对于（int i=0；i<3；i++）{
System.out.println（queue.size（）+“3 proverka”+i+“krug”）；
len[i]=queue.poll（）；
System.out.println（byteToHex（len[i]）+“解析器”）；
输出：

02事件 0000事件 01事件 4.1 proverka 77事件 2解析器 03事件 75事件 6.2 proverka 6 3 proverka 0 krug 线程“thread-1”java.lang.NullPointerException中的异常 在es.moduli.ingenico\u card\u reader.ingenico\u card\u reader$SerialParser.run（ingenico\u card\u reader.java:127）

用我的自定义字节类编辑

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package es.moduli.ingenico_card_reader;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import jssc.SerialPort;
import jssc.SerialPortEventListener;
import jssc.SerialPortException;

/**
 *
 * @author GiGo
 */
public class Ingenico_Card_Reader {

    static SerialPort serialPort;
    static BlockingQueue<CustomByte> queue = new ArrayBlockingQueue<>(1000);
    final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();

    public void open() {
        serialPort = new SerialPort("COM4");
        try {
            serialPort.openPort();//Open port
            serialPort.setParams(9600, 8, 1, 0);//Set params
            int mask = SerialPort.MASK_RXCHAR;//Prepare mask
            serialPort.setEventsMask(mask);//Set mask
            serialPort.addEventListener(new SerialPortEvent());//Add SerialPortEventListener
        } catch (SerialPortException ex) {
            System.out.println(ex);
        }

        SerialParser parser = new SerialParser();
        parser.start();
    }

    public static String bytesToHex(byte[] bytes) {
        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < bytes.length; j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }
        return new String(hexChars);
    }

    public static String byteToHex(byte b) {
        int i = b & 0xFF;
        return Integer.toHexString(i);
    }

    public static int byteToIntBE(byte[] b) {
        ByteBuffer bb = ByteBuffer.wrap(b);
        bb.order(ByteOrder.BIG_ENDIAN);
        int result = bb.getInt();
        return result;
    }

    public static void sleep(long i) {
        try {
            Thread.sleep(i);
        } catch (Exception e) {
        }
    }

    public static String hexString(byte[] b) {
        StringBuilder d = new StringBuilder(b.length * 2);
        for (int i = 0; i < b.length; i++) {
            char hi = Character.forDigit(b[i] >> 4 & 0xF, 16);
            char lo = Character.forDigit(b[i] & 0xF, 16);
            d.append(Character.toUpperCase(hi));
            d.append(Character.toUpperCase(lo));
        }
        return d.toString();
    }

    public static class SerialPortEvent implements SerialPortEventListener {

        byte buffer[];

        @Override
        public void serialEvent(jssc.SerialPortEvent event) {
            if (event.isRXCHAR()) {//If data is available
                //if (event.getEventValue() == 1) {//Check bytes count in the input buffer
                //Read data, if 1 byte available 
                try {
                    buffer = serialPort.readBytes();
                    System.out.println(bytesToHex(buffer) + " event");
                    for (int i = 0; i < buffer.length; i++) {
                        queue.add(new CustomByte(buffer[i], true));
                    }
                } catch (SerialPortException ex) {
                    System.out.println(ex);
                }
            }
            // }

        }
    }

    public static class SerialParser extends Thread {

        StringBuilder sb = new StringBuilder();
        Byte len[];
        int len_mess = 0;
        Byte mess[];

        @Override
        public void run() {
            while (true) {
                while (!queue.isEmpty()) {
                    System.out.println(queue.size() + " 1 proverka");
                    sb = new StringBuilder();
                    byte stx = queue.poll().getBufferByte();
                    System.out.println(byteToHex(stx) + " parser");
                    if (stx == 0x02) {
                        sb.append(String.format("%02X ", stx));
                        System.out.println(queue.size() + " 2 proverka");
                        for (int i = 0; i < 3; i++) {
                            System.out.println(queue.size() + " 3 proverka " + i + " krug");
                            len[i] = queue.poll().getBufferByte();
                            System.out.println(byteToHex(len[i]) + " parser");
                            //sb.append(String.format("%02X ", len[i]));
                        }
                        len_mess = (256 * 256 * len[0]) + (256 * len[1]) + (len[2]);
                        for (int i = 0; i < len_mess; i++) {
                            mess[i] = queue.poll().getBufferByte();
                            System.out.println(byteToHex(mess[i]) + "parser");
                            sb.append(String.format("%02X ", mess[i]));
                            try {
                                Thread.sleep(50);
                            } catch (InterruptedException ex) {
                                System.out.println(ex.getMessage());
                            }
                        }
                        byte etx = queue.poll().getBufferByte();
                        System.out.println(byteToHex(etx) + "parser");
                        if (etx == 0x03) {
                            sb.append(String.format("%02X ", etx));
                            System.out.println(sb.toString());
                        } else {
                            System.out.println("NOT ETX");
                        }
                    } else {
                        System.out.println("NOT STX");
                    }
                    System.out.println(sb.toString());
                }
            }
        }

    }

}

/*
*要更改此许可证标题，请在“项目属性”中选择“许可证标题”。
*要更改此模板文件，请选择工具|模板
*然后在编辑器中打开模板。
*/
封装E.moduli.ingenico\u读卡器；
导入java.nio.ByteBuffer；
导入java.nio.ByteOrder；
导入java.util.concurrent.ArrayBlockingQueue；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.TimeUnit；
导入java.util.logging.Level；
导入java.util.logging.Logger；
导入jssc.SerialPort；
导入jssc.SerialPortEventListener；
导入jssc.SerialPortException；
/**
*
*@作者GiGo
*/
公共级Ingenico_读卡器{
静态串口串口；
静态阻塞队列=新的ArrayBlockingQueue（1000）；
最终受保护的静态字符[]hexArray=“0123456789ABCDEF”.toCharArray（）；
公开作废{
serialPort=新的serialPort（“COM4”）；
试一试{
serialPort.openPort（）；//打开端口
serialPort.setParams（9600,8,1,0）；//Set params
int mask=SerialPort.mask\u RXCHAR；//准备掩码
serialPort.setEventsMask（掩码）；//设置掩码
serialPort.addEventListener（新的SerialPortEvent（））；//添加SerialPortEventListener
}捕获（SerialPortException例外）{
系统输出打印项次（ex）；
}
SerialParser=新的SerialParser（）；
parser.start（）；
}
公共静态字符串bytesToHex（字节[]字节）{
char[]hexChars=新字符[bytes.length*2]；
对于（int j=0；j>>4]；
hexChars[j*2+1]=hexArray[v&0x0F]；
}
返回新字符串（hexChars）；
}
公共静态字符串byteToHex（字节b）{
inti=b&0xFF；
返回整数.toHexString（i）；
}
公共静态int字节点be（字节[]b）{
ByteBuffer bb=ByteBuffer.wrap（b）；
bb.order（ByteOrder.BIG_ENDIAN）；
int result=bb.getInt（）；
返回结果；
}
公共静态无效睡眠（长i）{
试一试{
睡眠（i）；
}捕获（例外e）{
}
}
公共静态字符串hexString（字节[]b）{
StringBuilder d=新StringBuilder（b.长度*2）；
for（int i=0；i>4&0xF，16）；
char lo=Character.forDigit（b[i]&0xF，16）；
d、 追加（Character.toUpperCase（hi））；
d、 追加（Character.toUpperCase（lo））；
}
返回d.toString（）；
}
公共静态类SerialPortEvent实现SerialPortEventListener{
字节缓冲区[]；
@凌驾
public void serialEvent（jssc.SerialPortEvent事件）{
if（event.isRXCHAR（））{//if数据可用
//如果（event.getEventValue（）==1）{//检查输入缓冲区中的字节数
//读取数据（如果1字节可用）
试一试{
buffer=serialPort.readBytes（）；
System.out.println（bytesToHex（缓冲区）+“事件”）；
for（int i=0；ipublic void serialEvent(jssc.SerialPortEvent event) {
  if (event.isRXCHAR()) {//If data is available
     try {
        buffer = serialPort.readBytes();
        System.out.println(bytesToHex(buffer) + " event");
        for (int i = 0; i < buffer.length; i++) {
        queue.add(buffer[i]);
        }
  } catch (SerialPortException ex) {
      System.out.println(ex);
  }

byte stx = queue.poll();

public void run() {
            while (true) {
                while (!queue.isEmpty()) {
                    System.out.println(queue.size() + " 1 proverka");
                    sb = new StringBuilder();
                    byte stx = queue.poll();
                    System.out.println(byteToHex(stx) + " parser");
                    if (stx == 0x02) {
                        sb.append(String.format("%02X ", stx));
                        System.out.println(queue.size() + " 2 proverka");
                        for (int i = 0; i < 3; i++) {
                            System.out.println(queue.size() + " 3 proverka " + i + " krug");
                            len[i] = queue.poll();
                            System.out.println(byteToHex(len[i]) + " parser");

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package es.moduli.ingenico_card_reader;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import jssc.SerialPort;
import jssc.SerialPortEventListener;
import jssc.SerialPortException;

/**
 *
 * @author GiGo
 */
public class Ingenico_Card_Reader {

    static SerialPort serialPort;
    static BlockingQueue<CustomByte> queue = new ArrayBlockingQueue<>(1000);
    final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();

    public void open() {
        serialPort = new SerialPort("COM4");
        try {
            serialPort.openPort();//Open port
            serialPort.setParams(9600, 8, 1, 0);//Set params
            int mask = SerialPort.MASK_RXCHAR;//Prepare mask
            serialPort.setEventsMask(mask);//Set mask
            serialPort.addEventListener(new SerialPortEvent());//Add SerialPortEventListener
        } catch (SerialPortException ex) {
            System.out.println(ex);
        }

        SerialParser parser = new SerialParser();
        parser.start();
    }

    public static String bytesToHex(byte[] bytes) {
        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < bytes.length; j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }
        return new String(hexChars);
    }

    public static String byteToHex(byte b) {
        int i = b & 0xFF;
        return Integer.toHexString(i);
    }

    public static int byteToIntBE(byte[] b) {
        ByteBuffer bb = ByteBuffer.wrap(b);
        bb.order(ByteOrder.BIG_ENDIAN);
        int result = bb.getInt();
        return result;
    }

    public static void sleep(long i) {
        try {
            Thread.sleep(i);
        } catch (Exception e) {
        }
    }

    public static String hexString(byte[] b) {
        StringBuilder d = new StringBuilder(b.length * 2);
        for (int i = 0; i < b.length; i++) {
            char hi = Character.forDigit(b[i] >> 4 & 0xF, 16);
            char lo = Character.forDigit(b[i] & 0xF, 16);
            d.append(Character.toUpperCase(hi));
            d.append(Character.toUpperCase(lo));
        }
        return d.toString();
    }

    public static class SerialPortEvent implements SerialPortEventListener {

        byte buffer[];

        @Override
        public void serialEvent(jssc.SerialPortEvent event) {
            if (event.isRXCHAR()) {//If data is available
                //if (event.getEventValue() == 1) {//Check bytes count in the input buffer
                //Read data, if 1 byte available 
                try {
                    buffer = serialPort.readBytes();
                    System.out.println(bytesToHex(buffer) + " event");
                    for (int i = 0; i < buffer.length; i++) {
                        queue.add(new CustomByte(buffer[i], true));
                    }
                } catch (SerialPortException ex) {
                    System.out.println(ex);
                }
            }
            // }

        }
    }

    public static class SerialParser extends Thread {

        StringBuilder sb = new StringBuilder();
        Byte len[];
        int len_mess = 0;
        Byte mess[];

        @Override
        public void run() {
            while (true) {
                while (!queue.isEmpty()) {
                    System.out.println(queue.size() + " 1 proverka");
                    sb = new StringBuilder();
                    byte stx = queue.poll().getBufferByte();
                    System.out.println(byteToHex(stx) + " parser");
                    if (stx == 0x02) {
                        sb.append(String.format("%02X ", stx));
                        System.out.println(queue.size() + " 2 proverka");
                        for (int i = 0; i < 3; i++) {
                            System.out.println(queue.size() + " 3 proverka " + i + " krug");
                            len[i] = queue.poll().getBufferByte();
                            System.out.println(byteToHex(len[i]) + " parser");
                            //sb.append(String.format("%02X ", len[i]));
                        }
                        len_mess = (256 * 256 * len[0]) + (256 * len[1]) + (len[2]);
                        for (int i = 0; i < len_mess; i++) {
                            mess[i] = queue.poll().getBufferByte();
                            System.out.println(byteToHex(mess[i]) + "parser");
                            sb.append(String.format("%02X ", mess[i]));
                            try {
                                Thread.sleep(50);
                            } catch (InterruptedException ex) {
                                System.out.println(ex.getMessage());
                            }
                        }
                        byte etx = queue.poll().getBufferByte();
                        System.out.println(byteToHex(etx) + "parser");
                        if (etx == 0x03) {
                            sb.append(String.format("%02X ", etx));
                            System.out.println(sb.toString());
                        } else {
                            System.out.println("NOT ETX");
                        }
                    } else {
                        System.out.println("NOT STX");
                    }
                    System.out.println(sb.toString());
                }
            }
        }

    }

}

public class CustomByte {
    private Byte bufferByte;
    private boolean isNull;

    // Add constructor, getters/setters as required
}

queue.add(new CustomByte(buffer[i], true))

PipedOutputStream out = new PipedOutputStream();
PipedInputStream in = new PipedInputStream(out);