Esempio n. 1
0
  /**
   * Start modem command manager.
   *
   * @throws Exception the exception
   */
  public void startModemCommandManager() throws Exception {
    CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(this.commandPortName);
    if (portIdentifier.isCurrentlyOwned()) {
      logger.error("Serial port " + this.commandPortName + " is currently in use");
    }
    CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000);
    if (commPort instanceof SerialPort) {
      modemComPort = (SerialPort) commPort;
      modemComPort.setSerialPortParams(
          9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

      modemComPort.notifyOnDataAvailable(true);

      commandInputStream = new DataInputStream(modemComPort.getInputStream());
      serialCommandReader = new SerialCommandReader(commandInputStream, this);
      modemComPort.addEventListener(serialCommandReader);

      commandOutputStream = new DataOutputStream(modemComPort.getOutputStream());

      this.sendCommandToModem(ATCommands.DISABLE_ECHO);
      this.sendCommandToModem(ATCommands.DISABLE_DIAGNOSTIC);
      this.sendCommandToModem(ATCommands.END_CALL);
      this.sendCommandToModem(ATCommands.CHECK_PIN);
    }
  }
  /**
   * Gets the serial port on the given port name. Throws an {@link IOException} if it does not
   * succeed in doing so.
   *
   * @param portName The port name.
   * @return The port.
   * @throws IOException If the port could not be opened.
   */
  private final SerialPort getSerialPort(final String portName) throws IOException {
    try {
      final CommPortIdentifier identifier = CommPortIdentifier.getPortIdentifier(portName);

      if (identifier.isCurrentlyOwned()) {
        throw new IOException(
            "The port specified ["
                + portName
                + "] is already in use by ["
                + identifier.getCurrentOwner()
                + "] !");
      }

      final CommPort rawPort = identifier.open("DOM_SER_DRV", 2000);

      if (rawPort instanceof SerialPort) {
        final SerialPort port = (SerialPort) rawPort;
        port.setSerialPortParams(
            BAUDRATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

        return port;
      } else {
        throw new IOException("Port [" + portName + "] is not a serial port !");
      }
    } catch (NoSuchPortException e) {
      throw new IOException("The port specified [" + portName + "] does not exist !", e);
    } catch (PortInUseException e) {
      throw new IOException("The port specified [" + portName + "] is already in use !");
    } catch (UnsupportedCommOperationException e) {
      throw new IOException("Unsupported comm operation when setting the serial parameters !", e);
    }
  }
Esempio n. 3
0
 /**
  * Start call.
  *
  * @throws Exception the exception
  */
 public void startCall() throws Exception {
   CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(this.streamPortName);
   if (portIdentifier.isCurrentlyOwned()) {
     logger.error("Serial port " + this.streamPortName + " is currently in use");
   }
   CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000);
   if (commPort instanceof SerialPort) {
     voiceStreamCommPort = (SerialPort) commPort;
     voiceStreamCommPort.setSerialPortParams(
         230400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
     voiceInputStream = new DataInputStream(voiceStreamCommPort.getInputStream());
     voiceOutputStream = new DataOutputStream(voiceStreamCommPort.getOutputStream());
     serialVoiceReader = new SerialVoiceReader(voiceInputStream, af);
     serialVoiceWriter = new SerialVoiceWriter(voiceOutputStream, af, playMessage);
     (new Thread(serialVoiceReader, "VoiceReader")).start();
     (new Thread(serialVoiceWriter, "VoiceWriter")).start();
   }
 }
  public CommDriverDS2480B(CommPortIdentifier identifier) throws PortInUseException {

    System.out.println(String.format("Opening %s", identifier.getName()));

    if (identifier.isCurrentlyOwned())
      throw new IllegalStateException("Comm port owned by someone else");

    CommPort unknownPort = identifier.open(this.getClass().getName(), TIMEOUT_OPEN_MILLIS);

    if (!(unknownPort instanceof SerialPort)) throw new IllegalStateException("not a serial port");

    this.port = (SerialPort) unknownPort;
    try {
      // this.port.setSerialPortParams(9600,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
      this.port.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);

      // flashRTS();
      input = new DataInputStream(new DebugInputStream(debug, this.port.getInputStream()));
      output = new DataOutputStream(new DebugOutputStream(debug, this.port.getOutputStream()));

      // cause software reset by using PARITY_SPACE for one byte...
      System.out.println("initial hardware reset/clock sync");
      this.port.setSerialPortParams(
          9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_SPACE);
      output.write(0x00);
      Thread.sleep(100);

      // send sync (reset) pulse for clock calibration
      this.port.setSerialPortParams(
          9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
      output.write(Integer.parseInt("11000001", 2));
      output.flush();
      Thread.sleep(50);
      // note, no response byte generated

    } catch (UnsupportedCommOperationException e) {
      throw new IllegalStateException("port did not accept params", e);
    } catch (IOException e) {
      throw new IllegalStateException("port did not accept params", e);
    } catch (InterruptedException e) {
      throw new IllegalStateException("port did not accept params", e);
    }
  }
Esempio n. 5
0
  public CardReader(String portName)
      throws IOException, PortInUseException, UnsupportedCommOperationException,
          NoSuchPortException {
    CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
    if (portIdentifier.isCurrentlyOwned()) {
      System.out.println("Error: Port is currently in use");
    } else {
      int timeout = 2000;
      CommPort commPort = portIdentifier.open(this.getClass().getName(), timeout);

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

        in = serialPort.getInputStream();

      } else {
        System.out.println("Error: Only serial ports are handled by this example.");
      }
    }
  }
Esempio n. 6
0
  private SerialPort connectSerial(String portName)
      throws NoSuchPortException, PortInUseException, UnsupportedCommOperationException {
    SerialPort serialPort = null;

    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(
            57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
        //				serialPort.setSerialPortParams(115200, SerialPort.DATABITS_8,
        //						SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
      } else {
        System.out.println("Error: Only serial ports are handled by this example.");
      }
    }
    return serialPort;
  }
  /** @see com.svhelloworld.knotlog.engine.sources.StreamedSource#open() */
  @Override
  public InputStream open() {
    try {
      // make sure the specified port is available
      CommPortIdentifier identifier = CommPortIdentifier.getPortIdentifier(config.getName());
      if (identifier.isCurrentlyOwned()) {
        throw new SerialPortOccupiedException(
            config.getName() + " port is currently opened by another application");
      }
      // open up the port
      CommPort port = identifier.open(getOwnerName(), PORT_TIMEOUT);
      if (port instanceof SerialPort) {

        // configure serial port
        serialPort = (SerialPort) port;
        serialPort.setSerialPortParams(
            config.getBaudRate(),
            config.getDataBits().getRXTXConstant(),
            config.getStopBit().getRXTXConstant(),
            config.getParity().getRXTXConstant());
        /*
         * the following 2 lines fix the exception:
         *       "IOException: Underlying input stream returned zero bytes"
         *       that is thrown when we read from the InputStream.
         */
        serialPort.enableReceiveTimeout(PORT_TIMEOUT);
        serialPort.enableReceiveThreshold(0);

        InputStream is = serialPort.getInputStream();
        return is;
      }
      // not a serial port
      throw new SerialPortException("must operate against a serial port");
    } catch (PortInUseException e) {
      throw new SerialPortOccupiedException(e.getMessage(), e);
    } catch (Exception e) {
      throw new SerialPortException(e.getMessage(), e);
    }
  }
Esempio n. 8
0
  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 mSerialPort = (SerialPort) commPort;
        mSerialPort.setSerialPortParams(
            57600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

        InputStream mIn = mSerialPort.getInputStream();
        OutputStream mOut = mSerialPort.getOutputStream();

        (new Thread(new SerialReader(mIn))).start();
        (new Thread(new SerialWriter(mOut))).start();

      } else {
        System.out.println("Error: Only serial ports are handled by this example.");
      }
    }
  }
Esempio n. 9
0
  public static void main(String[] args) {

    boolean boolArgs = false;
    if ((args.length == 0) || (args.length == 1)) {
      log.error(
          MARKER_RunPcOpRs1Sender,
          "{} please input device name (e.g. /dev/ttyUSB0) and input file",
          Thread.currentThread().getStackTrace()[1].getMethodName());
    } else if (args.length > 2) {
      log.error(
          MARKER_RunPcOpRs1Sender,
          "{} too many args",
          Thread.currentThread().getStackTrace()[1].getMethodName());
    } else {
      boolArgs = true;
    }

    if (boolArgs) {

      String deviceName = args[0];
      // String deviceName = "/dev/ttyUSB0";
      log.debug(
          MARKER_RunPcOpRs1Sender,
          "{} [deviceName] {}",
          Thread.currentThread().getStackTrace()[1].getMethodName(),
          deviceName);

      String signalPath = args[1];
      log.debug(
          MARKER_RunPcOpRs1Sender,
          "{} [signalPath] {}",
          Thread.currentThread().getStackTrace()[1].getMethodName(),
          signalPath);

      CommPortIdentifier portID;
      // SerialPort port;

      @SuppressWarnings("unchecked")
      Enumeration<CommPortIdentifier> portList = CommPortIdentifier.getPortIdentifiers();

      while (portList.hasMoreElements()) {

        portID = (CommPortIdentifier) portList.nextElement();
        log.debug(
            MARKER_RunPcOpRs1Sender,
            "{} [portID.getName()] {}",
            Thread.currentThread().getStackTrace()[1].getMethodName(),
            portID.getName());

        if (portID.getPortType() == CommPortIdentifier.PORT_SERIAL) {

          log.debug(
              MARKER_RunPcOpRs1Sender,
              "{} {} is a serial device",
              Thread.currentThread().getStackTrace()[1].getMethodName(),
              deviceName);

          if (portID.getName().equals(deviceName)) {

            if (portID.isCurrentlyOwned()) {
              log.debug(
                  MARKER_RunPcOpRs1Sender,
                  "{} {} is currently owned",
                  Thread.currentThread().getStackTrace()[1].getMethodName(),
                  deviceName);
              break;
            } else {
              log.debug(
                  MARKER_RunPcOpRs1Sender,
                  "{} {} can be used",
                  Thread.currentThread().getStackTrace()[1].getMethodName(),
                  deviceName);

              PcOpRs1Sender rxtx = new PcOpRs1Sender(deviceName, signalPath);

              if (rxtx.openSerialPort()) {
                if (rxtx.setSerialPort()) {
                  rxtx.send0x74();
                } else {
                  break;
                }
              } else {
                break;
              }
            }

          } else {
            log.debug(
                MARKER_RunPcOpRs1Sender,
                "{} {} is not match {}",
                Thread.currentThread().getStackTrace()[1].getMethodName(),
                portID.getName(),
                deviceName);
          }

        } else if (portID.getPortType() == CommPortIdentifier.PORT_PARALLEL) {
          log.debug(
              MARKER_RunPcOpRs1Sender,
              "{} {} is a parallel device",
              Thread.currentThread().getStackTrace()[1].getMethodName(),
              deviceName);
          break;
        } else {
          log.debug(
              MARKER_RunPcOpRs1Sender,
              "{} {} is an unknown device",
              Thread.currentThread().getStackTrace()[1].getMethodName(),
              deviceName);
          break;
        }
      } // while()
    } // if bool
  } // main()
Esempio n. 10
0
  // open a serial connection to a device.  We won't know it's the robot until
  public int OpenPort(String portName) {
    if (portOpened && portName.equals(recentPort)) return 0;

    ClosePort();

    Log("<font color='green'>Connecting to " + portName + "...</font>\n");

    // find the port
    try {
      portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
    } catch (Exception e) {
      Log("<span style='color:red'>Ports could not be identified:" + e.getMessage() + "</span>\n");
      e.printStackTrace();
      return 1;
    }

    if (portIdentifier.isCurrentlyOwned()) {
      Log(
          "<span style='color:red'>Error: Another program is currently using this port."
              + "</span>\n");
      return 2;
    }

    // open the port
    try {
      commPort = portIdentifier.open("DrawbotGUI", 2000);
    } catch (Exception e) {
      Log("Port could not be opened:" + e.getMessage() + NL);
      e.printStackTrace();
      return 3;
    }

    if ((commPort instanceof SerialPort) == false) {
      Log("<span style='color:red'>Only serial ports are handled by this example." + "</span>\n");
      return 4;
    }

    // set the port parameters (like baud rate)
    serialPort = (SerialPort) commPort;
    try {
      serialPort.setSerialPortParams(
          BAUD_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
    } catch (Exception e) {
      Log("<span style='color:red'>Port could not be configured:" + e.getMessage() + "</span>\n");
      return 5;
    }

    try {
      in = serialPort.getInputStream();
      out = serialPort.getOutputStream();
    } catch (Exception e) {
      Log("<span style='color:red'>Streams could not be opened:" + e.getMessage() + "</span>\n");
      return 6;
    }

    try {
      serialPort.addEventListener(this);
      serialPort.notifyOnDataAvailable(true);
    } catch (TooManyListenersException e) {
      Log("<span style='color:red'>Streams could not be opened:" + e.getMessage() + "</span>\n");
      return 7;
    }

    Log("<span style='green'>Opened.</span>\n");
    SetRecentPort(portName);
    portOpened = true;
    UpdateMenuBar();

    return 0;
  }