• View
• Edit
• History
• Print

XBeeJavaAnalysis

Below is an analysis of the calling sequence for XBeeJava.

It turns out, that it is easier to use XBeeLogging.

• The XBeeDevice constructor invokes the constructor of the superclass, AbstractXBeeDevice, which does the bulk of the constructor work by setting some fields.
          /**
           * Class constructor. Instantiates a new {@code XBeeDevice} object in the
           * given port name and baud rate.
           *
           * @param port Serial port name where XBee device is attached to.
           * @param baudRate Serial port baud rate to communicate with the device.
           *                 Other connection parameters will be set as default (8
           *                 data bits, 1 stop bit, no parity, no flow control).
           *
           * @throws IllegalArgumentException if {@code baudRate < 0}.
           * @throws NullPointerException if {@code port == null}.
           *
           * @see #AbstractXBeeDevice(IConnectionInterface)
           * @see #AbstractXBeeDevice(String, SerialPortParameters)
           * @see #AbstractXBeeDevice(XBeeDevice, XBee64BitAddress)
           * @see #AbstractXBeeDevice(XBeeDevice, XBee64BitAddress, XBee16BitAddress, String)
           * @see #AbstractXBeeDevice(String, int, int, int, int, int)
           */
          public AbstractXBeeDevice(String port, int baudRate) {
                  this(XBee.createConnectiontionInterface(port, baudRate));
          }

  [$[Get Code]]

XBee (Javadoc, source creates the connection interface:

• XBeeDevice.open() is below, it creates a DataReader (JavaDoc, Source), which is used later:
         /**
           * Opens the connection interface associated with this XBee device.
           *
           * <p>When opening the device an information reading process is
           * automatically performed. This includes:</p>
           *
           * <ul>
           * <li>64-bit address.</li>
           * <li>Node Identifier.</li>
           * <li>Hardware version.</li>
           * <li>Firmware version.</li>
           * <li>XBee device protocol.</li>
           * <li>16-bit address (not for DigiMesh modules).</li>
           * </ul>
           *
           * @throws InterfaceAlreadyOpenException if this device connection is
           *                                       already open.
           * @throws XBeeException if there is any problem opening this device
           *                       connection.
           *
           * @see #close()
           * @see #isOpen()
           */
          public void open() throws XBeeException {
                  logger.info(toString() + "Opening the connection interface...");
  
                  // First, verify that the connection is not already open.
                  if (connectionInterface.isOpen())
                          throw new InterfaceAlreadyOpenException();
  
                  // Connect the interface.
                  connectionInterface.open();
  
                  logger.info(toString() + "Connection interface open.");
  
                  // Initialize the data reader.
                  dataReader = new DataReader(connectionInterface, operatingMode, this);
                  dataReader.start();
  
                  // Wait 10 milliseconds until the dataReader thread is started.
                  // This is because when the connection is opened immediately after
                  // closing it, there is sometimes a concurrency problem and the
                  // dataReader thread never dies.
                  try {
                          Thread.sleep(10);
                  } catch (InterruptedException e) {}
  
                  // Determine the operating mode of the XBee device if it is unknown.
                  if (operatingMode == OperatingMode.UNKNOWN)
                          operatingMode = determineOperatingMode();
  
                  // Check if the operating mode is a valid and supported one.
                  if (operatingMode == OperatingMode.UNKNOWN) {
                          close();
                          throw new InvalidOperatingModeException("Could not determine operating mode.");
                  } else if (operatingMode == OperatingMode.AT) {
                          close();
                          throw new InvalidOperatingModeException(operatingMode);
                  }
  
                  // Read the device info (obtain its parameters and protocol).
                  try {
                          readDeviceInfo();
                  } catch (ATCommandException e) {
                          throw new XBeeException("Error reading device information.", e);
                  }
          }

  [$[Get Code]]

XBeeDevice.sendBroadCastData() invokes the superclass:

XBeeDevice.sendData() creates an XBeePacket (Javadoc, Source)

Eventually AbstractXBeeDevice.sendXBeePacket() is called, which creates some listeners and then calls AbstractXBeeDevice.writePacket():