public SimpleRead() {
    try {
      /*
       * open方法打开通讯端口
       * ,
       * 获得一个CommPort对象
       * 。
       * 它使程序独占端口
       * 。
       * 如果端口正被其他应用程序占用
       * ,将使用
       * CommPortOwnershipListener事件机制
       * ,
       * 传递一个PORT_OWNERSHIP_REQUESTED事件
       * 。
       * 每个端口都关联一个
       * InputStream
       * 何一个OutputStream
       * 。
       * 如果端口是用open方法打开的
       * ,
       * 那么任何的getInputStream都将返回相同的数据流对象
       * ,
       * 除非有close
       * 被调用
       * 。有两个参数
       * ,
       * 第一个为应用程序名
       * ;
       * 第二个参数是在端口打开时阻塞等待的毫秒数
       * 。
       */
      serialPort = (SerialPort) portId.open("packinglinesmanage", 2000);
    } catch (PortInUseException e) {
    }
    try {
      inputStream = serialPort.getInputStream(); /* 获取端口的输入流对象 */
    } catch (IOException e) {
    }
    try {
      serialPort.addEventListener(this); /* 注册一个SerialPortEventListener事件来监听串口事件 */
    } catch (TooManyListenersException e) {
    }

    serialPort.notifyOnDataAvailable(true); /* 数据可用 */

    try {
      serialPort.setSerialPortParams(
          9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE); /*
																	 * 设置串口初始化参数,
																	 * 依次是波特率
																	 * ,数据位
																	 * ,停止位和校验
																	 */
    } catch (UnsupportedCommOperationException e) {
    }

    readThread = new Thread(this);
    readThread.start();
  }
예제 #2
0
  public static void main(String args[]) {
    Display display = IntelliBrain.getLcdDisplay();
    IBB ibb = new IBB();

    try {
      SerialPort comPort = IntelliBrain.getCom1();

      // Serial Parameters
      comPort.setSerialPortParams(
          38400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

      InputStream inputStream = comPort.getInputStream();
      OutputStream outputStream = comPort.getOutputStream();

      // clear screen
      display.print(0, "");
      display.print(1, "");

      // test the readLine routine
      byte[] buf = new byte[128];

      while (true) {
        int len = readLine(inputStream, outputStream, display, true, buf, 128);

        if (len == 0) continue;

        switch (buf[0]) {
          case 'B':
            ibb.getVersion(outputStream, buf, len);
            break;
          case 'D':
            ibb.setSpeed(outputStream, buf, len);
            break;
          case 'H':
            ibb.sysBeep(outputStream, buf, len);
            break;
          case 'L':
            ibb.setLedState(outputStream, buf, len);
            break;
          case 'N':
            ibb.readProximitySensors(outputStream, buf, len);
            break;
          case 'O':
            ibb.readLightSensors(outputStream, buf, len);
            break;
          case 'Z':
            ibb.motorsOff(outputStream, buf, len);
            break;
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
예제 #3
0
 /*! This method initializes the input and output stream member
 	variables. It throws an exception if the COM port identifier
 	is not found.
 */
 private void initSerial() throws Exception {
   CommPortIdentifier portId =
       CommPortIdentifier.getPortIdentifier(
           comPort); // get the port ID for the port name received through command line
   if (portId == null) {
     throw new NullPointerException("no com port identifier");
   }
   serPort = (SerialPort) portId.open("Shake", 5000); // open the serial Port
   outStream = serPort.getOutputStream(); // get output stream to the serial port
   inStream = serPort.getInputStream(); // get input stram to the serial port
   inBufReader = new BufferedReader(new InputStreamReader(inStream));
 }
예제 #4
0
  public void read(byte[] data) {
    try {
      is = port.getInputStream();
    } catch (IOException e) {
      System.err.println("IOException: " + e);
    }

    try {
      is.read(data);
    } catch (IOException e) {
      System.err.println("IOException: " + e);
    }
  }
예제 #5
0
  public void open()
      throws NoSuchPortException, PortInUseException, IOException,
          UnsupportedCommOperationException {
    portId = CommPortIdentifier.getPortIdentifier(portName);
    port = (SerialPort) portId.open(CLASS_NAME, 0);
    in = port.getInputStream();
    out = port.getOutputStream();

    port.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_IN);
    port.setFlowControlMode(SerialPort.FLOWCONTROL_RTSCTS_OUT);

    printPortStatus();
    port.setSerialPortParams(
        19200, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
    printPortStatus();
  }
  public void connection() {
    try {
      portId = CommPortIdentifier.getPortIdentifier("COM10");

      sPort = (SerialPort) portId.open("COM10", 1000);
      sPort.setSerialPortParams(9600, 8, 1, sPort.PARITY_NONE);

      is = sPort.getInputStream();
      os = sPort.getOutputStream();

      dis = new DataInputStream(is);
      dos = new DataOutputStream(os);
    } catch (NoSuchPortException e) {
      System.out.println("No Port\n" + e);
    } catch (PortInUseException e) {
      System.out.println("Port\n" + e);
    } catch (UnsupportedCommOperationException e) {
      System.out.println("Unsupported Problem\n" + e);
    } catch (IOException e) {
      System.out.println("IO Problem" + e);
    } catch (Exception e) {
      System.out.println("Unknown Problem" + e);
    }
  }
예제 #7
0
  @Override
  public void open() {
    // r�cup�ration de l'identifiant du port
    try {
      logger.info("Liste des ports : " + CommPortIdentifier.getPortIdentifiers());
      final Enumeration identifiers = CommPortIdentifier.getPortIdentifiers();
      while (identifiers.hasMoreElements()) {
        logger.info(((CommPortIdentifier) identifiers.nextElement()).getName());
      }
      portId = CommPortIdentifier.getPortIdentifier(connectionDescriptor.getPortName());
    } catch (final NoSuchPortException e) {
      throw new RuntimeException(
          "Rs232Connector (" + connectionDescriptor.getPortName() + ") : " + e.toString());
    }

    // ouverture du port
    try {
      serialPort = (SerialPort) portId.open("driver", 2000);
    } catch (final PortInUseException e) {
      throw new RuntimeException(
          "Rs232Connector (" + connectionDescriptor.getPortName() + ") : " + e.toString());
    }

    // param�trage du port
    // hmmmmmmmmmmmm cf :
    // http://forum.java.sun.com/thread.jspa?threadID=673793&start=15&tstart=0
    boolean result = false;
    while (!result) {
      try {
        serialPort.setSerialPortParams(
            connectionDescriptor.getBaudRate(),
            connectionDescriptor.getDataBits(),
            connectionDescriptor.getStopBits(),
            connectionDescriptor.getParity());
        result = true;
      } catch (final Exception ex) {
        logger.error("Unable to set serial ports parameters", ex);
        result = false;
        try {
          Thread.sleep(200);
        } catch (final InterruptedException exc) {
          logger.error("Error while sleeping", exc);
        }
      }
    }
    /** @todo : test */
    // Suppression
    try {
      serialPort.enableReceiveTimeout(5000); // timeout de 1 ms
    } catch (final UnsupportedCommOperationException ex) {
      logger.warn(
          "Warning : impossible to set timeout for port " + connectionDescriptor.getPortName(), ex);
    }

    try {
      // inputStream = new BufferedReader(new
      // InputStreamReader(serialPort.getInputStream()));
      inputStream = serialPort.getInputStream();
    } catch (final IOException e) {
      serialPort.close();
      throw new RuntimeException(
          "Rs232Connector (" + connectionDescriptor.getPortName() + ") : " + e.toString());
    }

    try {
      serialPort.addEventListener(
          new SerialPortEventListener() {

            @Override
            public void serialEvent(final SerialPortEvent evt) {
              if (evt.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
                synchronized (bufferMonitor) {
                  if (writeIndex >= BUFFER_LENGTH - 1) {
                    flushBuffer();
                  }
                  try {
                    byte newData = 0;
                    while (newData != -1) {
                      newData = (byte) inputStream.read();
                      if (newData == -1) {
                        break;
                      }
                      if (writeIndex >= BUFFER_LENGTH - 1) {
                        flushBuffer();
                      }
                      buffer[writeIndex++] = newData;
                    }
                  } catch (final Exception exc) {
                    logger.error("Error reading input stream from serial port", exc);
                  }
                  bufferMonitor.notify();
                }
              }
            }
          });
      serialPort.notifyOnDataAvailable(true);
      serialPort.enableReceiveTimeout(20);

    } catch (final TooManyListenersException exc) {
      logger.error("", exc);
    } catch (final UnsupportedCommOperationException exc) {
      logger.error("", exc);
    }

    final Thread threadParse =
        new Thread("Rs232Connector_" + connectionDescriptor.getPortName() + "_dispatch_thread") {
          @Override
          public void run() {
            try {
              parseThread();
            } catch (final Exception e) {
              logger.error("Error while parsing thread", e);
            }
          }
        };
    threadParse.start();
  }
예제 #8
0
  public static void main(String args[]) {

    // Command to turn of GPS
    int[] turn_off = new int[8];
    turn_off[0] = DLE;
    turn_off[1] = Pid_Command_Packet;
    turn_off[2] = 2; // Length of data
    turn_off[3] = Cmnd_Turn_Off_Pwr;
    turn_off[4] = 0;
    turn_off[6] = DLE;
    turn_off[7] = ETX;

    calcChecksum(turn_off);
    System.out.println("Turn off checksum: " + turn_off[5]);

    // Command to ask GPS for time data.
    int[] transfer_time = new int[8];
    transfer_time[0] = DLE;
    transfer_time[1] = Pid_Command_Packet;
    transfer_time[2] = 2;
    transfer_time[3] = Cmnd_Transfer_Time;
    transfer_time[4] = 0;
    transfer_time[6] = DLE;
    transfer_time[7] = ETX;

    calcChecksum(transfer_time);
    System.out.println("Transfer time" + transfer_time[5]);

    // Command to make a product request to the GPS.
    int[] product_request = new int[6];
    product_request[0] = DLE;
    product_request[1] = Pid_Product_Rqst;
    product_request[2] = 0;
    product_request[4] = DLE;
    product_request[5] = ETX;

    calcChecksum(product_request);
    System.out.println("Product request:" + product_request[5]);

    // Command to ask GPS for position data
    int[] transfer_position = new int[8];
    transfer_position[0] = DLE;
    transfer_position[1] = Pid_Command_Packet;
    transfer_position[2] = 2;
    transfer_position[3] = Cmnd_Transfer_Posn;
    transfer_position[4] = 0;
    transfer_position[6] = DLE;
    transfer_position[7] = ETX;

    calcChecksum(transfer_position);

    // Command to ask the GPS to start transmitting PVT data
    int[] start_PVT = new int[8];
    start_PVT[0] = DLE;
    start_PVT[1] = Pid_Command_Packet;
    start_PVT[2] = 2;
    start_PVT[3] = Cmnd_Start_Pvt_Data;
    start_PVT[4] = 0;
    start_PVT[6] = DLE;
    start_PVT[7] = ETX;

    calcChecksum(start_PVT);

    // Acknowledge-packet.
    int[] ack = new int[8];
    ack[0] = DLE;
    ack[1] = Pid_Ack_Byte;
    ack[2] = 2;
    ack[4] = 0;
    ack[6] = DLE;
    ack[7] = ETX;

    SerialPort port;
    BufferedInputStream input;
    BufferedOutputStream output;

    System.out.println("Using COM1.");
    // Open port.
    try {
      port =
          (SerialPort) CommPortIdentifier.getPortIdentifier("COM1").open("dk.itu.haas.GPS", 3000);
    } catch (NoSuchPortException e) {
      System.out.println("No such port!\n" + e.getMessage());
      return;
    } catch (PortInUseException e) {
      System.out.println("Port already in use! (??!)\n" + e.getMessage());
      return;
    }

    try {
      input = new BufferedInputStream(port.getInputStream());
      output = new BufferedOutputStream(port.getOutputStream());
    } catch (IOException e) {
      System.out.println("IOException... ");
      return;
    }

    System.out.println("Sending:");

    printPacket(turn_off);
    sendPacket(output, turn_off);

    /*
    printPacket(transfer_position);
    sendPacket(output, transfer_position);
    */
    /*
    printPacket(start_PVT);
    sendPacket(output, start_PVT);
    */
    /*
    printPacket(product_request);
    sendPacket(output, product_request);
    */
    System.out.println("--");

    int[] packet;
    try {
      Thread.sleep(500);
    } catch (InterruptedException e) {
    }

    try {
      while (input.available() > 0) {
        packet = readPacket(input);
        if (packet != null) {
          System.out.println("Received:");
          printPacket(packet);

          // Send acknowledge.
          ack[3] = packet[1];
          calcChecksum(ack);
          sendPacket(output, ack);

          System.out.println("--");
        } else {
          System.out.println("No packet received.");
        }
        try {
          Thread.sleep(5000);
        } catch (InterruptedException e) {
        }
      }
    } catch (IOException e) {
      System.out.println("IOError!");
      return;
    }
  }
예제 #9
0
  private void initialize() {

    // ==========================================
    /*
     * get System porperties:
     */
    String operatingSystem = null;
    Properties p = System.getProperties();
    Enumeration e = p.elements();
    while (e.hasMoreElements()) {
      operatingSystem = e.nextElement().toString();
      //				System.out.println(operatingSystem);
      if (operatingSystem.equals("Linux")) {
        logger.debug("found " + operatingSystem + " Operating System");
        comPort = "/dev/ttyS0";
        break;
      }
      if (operatingSystem.equals("Windows XP")) {
        logger.debug("found " + operatingSystem + " Operating System");
        comPort = "COM1";
        break;
      }

      //				if(operatingSystem.equals("Linux") || operatingSystem.equals("Windows")) {
      //					logger.debug("found "+operatingSystem+" Operating System");
      //					break;
      //				}
    }
    //	===============end===========================

    Enumeration pList = CommPortIdentifier.getPortIdentifiers();
    //		logger.debug("(Khepera) initializeeeee()...");

    while (pList.hasMoreElements()) {
      CommPortIdentifier cpi = (CommPortIdentifier) pList.nextElement();

      if (cpi.getName().equals(comPort)) {
        try {
          com = null;
          com = (SerialPort) cpi.open("KHEPERA_" + comPort, 1000);
          try {

            //	========================================
            /* under Linux this block is crucial to setSerialPortParams()
             * - i have no idea why...
             */
            String s =
                "default settings: "
                    + com.getBaudRate()
                    + " "
                    + com.getDataBits()
                    + " "
                    + com.getParity()
                    + " "
                    + com.getStopBits();
            System.out.println(s);
            //	===============end=========================

            com.setSerialPortParams(
                57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_2, SerialPort.PARITY_NONE);
            System.out.println(
                "Current settings: "
                    + com.getBaudRate()
                    + " "
                    + com.getDataBits()
                    + " "
                    + com.getParity()
                    + " "
                    + com.getStopBits());
          } catch (UnsupportedCommOperationException e1) {
            logger.debug("(Khepera) UnsupportedCommOperation: " + e1);
            e1.printStackTrace();
          }
          //					try {
          //						com.setSerialPortParams(BAUDRATE,
          //								com.DATABITS_8,
          //								com.STOPBITS_2,
          //								com.PARITY_NONE);
          //						com.setFlowControlMode(com.FLOWCONTROL_NONE);
          //					} catch (UnsupportedCommOperationException e1) {
          //						logger.debug("(Khepera) UnsupportedCommOperation: "+e1);
          //						e1.printStackTrace();
          //					}
          logger.debug("[Khepera.initialize()] established " + comPort);

          out = null;
          out = com.getOutputStream();
          inStream = null;
          inStream = com.getInputStream();

          byte[] readBuffer2 = new byte[1000];
          if (inStream.available() > 0) {
            int numBytes2 = inStream.read(readBuffer2);
            String result2 = new String(readBuffer2, 0, numBytes2);
            logger.debug("result2: " + result2);
          }

          //					in = null;
          in = new BufferedReader(new InputStreamReader(inStream));

          bufferedKheperaAnswer =
              new BufferedKheperaAnswer(logger, inStream, this, writelock, debug, operatingSystem);
          try {
            com.addEventListener(bufferedKheperaAnswer);

            com.notifyOnOutputEmpty(true);
            com.notifyOnDataAvailable(true);
            com.notifyOnOverrunError(true);
            com.notifyOnBreakInterrupt(true);
            com.notifyOnCarrierDetect(true);
            com.notifyOnCTS(true);
            com.notifyOnDSR(true);
            com.notifyOnFramingError(true);
            com.notifyOnParityError(true);
            com.notifyOnRingIndicator(false);
          } catch (TooManyListenersException e1) {
            logger.debug(
                "[Khepera.initialize()] can not add further eventListeners to serialPort object"
                    + e);
            e1.printStackTrace();
          }
        } catch (PortInUseException e2) {
          logger.debug("[Khepera.initialize()] Port in use: " + e2);
          e2.printStackTrace();
        } catch (IOException e3) {
          logger.debug(
              "[Khepera.initialize()] IOException while initialising COMport: <"
                  + comPort
                  + ">"
                  + e);
          e3.printStackTrace();
        }
        break;
      }
    }
    if (com == null)
      logger.error(
          "[Khepera.initialize()] unable to find specified COMport "
              + comPort
              + ". giving up! (the robot is not connected yet.)");
    else {
      logger.debug("[Khepera.initialize()] starting bufferedKheperaAnswer.start()");
      bufferedKheperaAnswer.start();

      if (debug) logger.debug("[Khepera.initialize()] initialize() finished");

      update = new KheperaUpdateManager(this, logger, debug);
      logger.debug("[Khepera.initialize()] starting KheperaUpdateManager update.start()");
      update.start();
    }
  }