示例#1
0
  public int setUpBam() {
    Enumeration<?> portIdentifiers = CommPortIdentifier.getPortIdentifiers();
    CommPortIdentifier portId = null;

    while (portIdentifiers.hasMoreElements()) {
      CommPortIdentifier pid = (CommPortIdentifier) portIdentifiers.nextElement();

      if (pid.getPortType() == CommPortIdentifier.PORT_SERIAL
          && pid.getName().equals(wantedPortName)) {
        portId = pid;
        System.out.println("Found port: " + pid.getName());
        break;
      }
    }

    try {
      port = (SerialPort) portId.open("Driver", 10000);
    } catch (PortInUseException e) {
      System.err.println("Port already in use: " + e);
      System.exit(1);
    }

    try {
      port.setSerialPortParams(
          57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
    } catch (UnsupportedCommOperationException e) {
      System.err.println("Failed to set up port: " + e);
    }
    System.out.println("Port should be open now");
    return 0;
  }
示例#2
0
  /**
   * This creates an mbed object for an mbed connected over Serial. <br>
   * Using this class requires the Sun Communications API to be installed
   *
   * @param PortName The Serial Port mbed is connected to eg "COM5" on Windows.
   * @param Baud The baud rate
   */
  public SerialRPC(String PortName, int Baud) {
    // open serial port
    try {
      mbedPortID = CommPortIdentifier.getPortIdentifier(PortName);

      mbedPort = mbedPortID.open("mbed", 100000);
      mbedSerialPort = (SerialPort) mbedPort;
      mbedSerialPort.setSerialPortParams(
          Baud, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

      inputStream = new DataInputStream(mbedPort.getInputStream());
      outputStream = new PrintStream(mbedPort.getOutputStream(), true);

      reader = new BufferedReader(new InputStreamReader(inputStream));
      to_mbed = new PrintWriter(outputStream, true);

      mbedSerialPort.addEventListener(this);
      // Important to set this regardless of whether interrupts are in use to keep the buffer clear
      mbedSerialPort.notifyOnDataAvailable(true);

    } catch (TooManyListenersException e) {
      // Error adding event listener
      System.out.println("Too many Event Listeners");
    } catch (NoSuchPortException e) {
      System.out.println("No Such Port");
    } catch (PortInUseException e) {
      System.out.println("Port Already In Use");
    } catch (UnsupportedCommOperationException e) {
      System.out.println("Unsupported Comm Operation");
    } catch (IOException e) {
      System.out.println("Serial Port IOException");
    }
  }
  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();
  }
示例#4
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));
 }
示例#5
0
  public Connection(String device, Dumper dumper)
      throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException,
          IOException {
    this.device = device;
    this.dumper = dumper;

    this.portIdentifier = CommPortIdentifier.getPortIdentifier(this.device);

    this.serialPort = (SerialPort) portIdentifier.open(this.getClass().getName(), 2000);
    this.serialPort.setSerialPortParams(
        57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

    this.inputStream = this.serialPort.getInputStream();
    this.outputStream = this.serialPort.getOutputStream();
  }
示例#6
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);
    }
  }
示例#8
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();
  }
示例#9
0
  /**
   * Opens a device for subsequent I/O.
   *
   * @param logicalDeviceName Parameter specifies the device name to open
   * @param ec Callback event handler
   * @throws JposException
   */
  public void open(String logicalDeviceName, EventCallbacks ec) throws JposException {

    // Check port opened
    if ((state != JposConst.JPOS_S_CLOSED) && (port != null))
      throw new JposException(
          JposConst.JPOS_E_ILLEGAL, getErrorDescription(JposConst.JPOS_E_ILLEGAL));

    powerNotify = JposConst.JPOS_PN_DISABLED;
    powerState = JposConst.JPOS_PS_UNKNOWN;

    // Read and check parameters
    // if (!jposEntry.getProp("deviceBus").getValueAsString().equalsIgnoreCase("RS232"))
    //    throw new JposException(JposConst.JPOS_E_NOSERVICE,
    //            getErrorDescription(JposConst.JPOS_E_NOSERVICE));
    portName = jposEntry.getProp("portName").getValueAsString();
    int baudRate = Integer.valueOf(jposEntry.getProp("baudRate").getValueAsString());
    // if (!(jposEntry.getProp("dataBits").getValueAsString().equalsIgnoreCase("8") &&
    //        jposEntry.getProp("stopBits").getValueAsString().equalsIgnoreCase("1") &&
    //        jposEntry.getProp("parity").getValueAsString().equalsIgnoreCase("None")))
    //    throw new JposException(JposConst.JPOS_E_NOSERVICE,
    //            getErrorDescription(JposConst.JPOS_E_NOSERVICE));

    // Try find existen serial port
    for (DeviceService value : deviceServices.keySet()) {
      if (value.getPortName().equalsIgnoreCase(portName)) {
        port = deviceServices.get(value);
        break;
      }
    }
    // Open port
    if (port == null) {
      try {
        CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
        CommPort commPort = portIdentifier.open("CASHCODE", DeviceTiming.NON_RESPONSE);
        if (commPort instanceof SerialPort) {
          port = ((SerialPort) commPort);
          port.setSerialPortParams(
              baudRate, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
          // Init timing
          responseTime = System.currentTimeMillis();
          executeTime = responseTime + DeviceTiming.BUS_RESET;
          port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
          port.setDTR(true);
          port.setRTS(true);
          port.setInputBufferSize(SIZE_BUFFER);
          port.setOutputBufferSize(SIZE_BUFFER);
          port.enableReceiveTimeout(DeviceTiming.INTER_BYTE);
        } else
          throw new JposException(
              JposConst.JPOS_E_NOSERVICE, getErrorDescription(JposConst.JPOS_E_NOSERVICE));
      } catch (Exception e) {
        throw new JposException(
            JposConst.JPOS_E_NOSERVICE, getErrorDescription(JposConst.JPOS_E_NOSERVICE), e);
      }
    }
    // Streams
    try {
      is = port.getInputStream();
      os = port.getOutputStream();
    } catch (IOException e) {
      throw new JposException(
          JposConst.JPOS_E_FAILURE, getErrorDescription(JposConst.JPOS_E_FAILURE), e);
    }

    // Add reference to port
    deviceServices.put(this, port);
    // Set events callback handler
    eventCallbacks = ec;

    // Initialize device
    try {
      initialize();
      state = JposConst.JPOS_S_IDLE;
    } catch (JposException e) {
      state = JposConst.JPOS_S_ERROR;
      startInit(DeviceTiming.RESET_NON_RESPONSE);
    }
  }
示例#10
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();
    }
  }