contikimotetype.java

Contiki是一个开源

   */
  public void setContikiBaseDir(String path) {
    contikiBaseDir = path;
  }

  /**
   * Returns path to contiki core dir
   *
   * @return String containing path
   */
  public String getContikiCoreDir() {
    return contikiCoreDir;
  }

  /**
   * Sets contiki core dir to path.
   *
   * @param path
   *          Contiki core dir
   */
  public void setContikiCoreDir(String path) {
    contikiCoreDir = path;
  }

  /**
   * Returns compilation files
   *
   * @return Compilation files
   */
  public Vector<File> getCompilationFiles() {
    return compilationFiles;
  }

  /**
   * Sets compilation files.
   *
   * @param files
   *          New compilation files
   */
  public void setCompilationFiles(Vector<File> files) {
    compilationFiles = files;
  }

  /**
   * Returns mote type specific project directories
   *
   * @return Project directories
   */
  public Vector<File> getProjectDirs() {
    return projectDirs;
  }

  /**
   * Sets mote type specific project directories.
   *
   * @param dirs
   *          New project directories
   */
  public void setProjectDirs(Vector<File> dirs) {
    projectDirs = dirs;
  }

  public ProjectConfig getConfig() {
    return myConfig;
  }

  /**
   * Sets mote type project configuration. This may differ from the general
   * simulator project configuration.
   *
   * @param moteTypeConfig
   *          Project configuration
   */
  public void setConfig(ProjectConfig moteTypeConfig) {
    myConfig = moteTypeConfig;
  }

  /**
   * Returns all processes of this mote type
   *
   * @return All processes
   */
  public Vector<String> getProcesses() {
    return processes;
  }

  /**
   * Set startup processes
   *
   * @param processes
   *          New startup processes
   */
  public void setProcesses(Vector<String> processes) {
    this.processes = processes;
  }

  /**
   * Returns all sensors of this mote type
   *
   * @return All sensors
   */
  public Vector<String> getSensors() {
    return sensors;
  }

  /**
   * Set sensors
   *
   * @param sensors
   *          New sensors
   */
  public void setSensors(Vector<String> sensors) {
    this.sensors = sensors;
  }

  /**
   * Returns all core interfaces of this mote type
   *
   * @return All core interfaces
   */
  public Vector<String> getCoreInterfaces() {
    return coreInterfaces;
  }

  /**
   * Set core interfaces
   *
   * @param coreInterfaces
   *          New core interfaces
   */
  public void setCoreInterfaces(Vector<String> coreInterfaces) {
    this.coreInterfaces = coreInterfaces;
  }

  /**
   * Returns all mote interfaces of this mote type
   *
   * @return All mote interfaces
   */
  public Vector<Class<? extends MoteInterface>> getMoteInterfaces() {
    return moteInterfaces;
  }

  /**
   * Set mote interfaces of this mote type
   *
   * @param moteInterfaces
   *          New mote interfaces
   */
  public void setMoteInterfaces(
      Vector<Class<? extends MoteInterface>> moteInterfaces) {
    this.moteInterfaces = moteInterfaces;
  }

  /**
   * Create a checksum of file. Used for checking if needed files are unchanged
   * when loading a saved simulation.
   *
   * @param file
   *          File containg data to checksum
   * @return Checksum
   */
  protected byte[] createChecksum(File file) {
    int bytesRead = 1;
    byte[] readBytes = new byte[128];
    MessageDigest messageDigest;

    try {
      InputStream fileInputStream = new FileInputStream(file);
      messageDigest = MessageDigest.getInstance("MD5");

      while (bytesRead > 0) {
        bytesRead = fileInputStream.read(readBytes);
        if (bytesRead > 0) {
          messageDigest.update(readBytes, 0, bytesRead);
        }
      }
      fileInputStream.close();
    } catch (NoSuchAlgorithmException e) {
      return null;
    } catch (IOException e) {
      return null;
    }
    return messageDigest.digest();
  }

  /**
   * Generates a unique Contiki mote type ID.
   *
   * @param existingTypes Already existing mote types, may be null
   * @param reservedIdentifiers Already reserved identifiers, may be null
   * @return Unique mote type ID.
   */
  public static String generateUniqueMoteTypeID(Collection<MoteType> existingTypes, Collection reservedIdentifiers) {
    int counter = 0;
    String testID = "";
    boolean okID = false;

    while (!okID) {
      counter++;
      testID = ContikiMoteTypeDialog.ID_PREFIX + counter;
      okID = true;

      // Check if identifier is reserved
      if (reservedIdentifiers != null && reservedIdentifiers.contains(testID)) {
        okID = false;
      }

      if (!okID) {
        continue;
      }

      // Check if identifier is used
      if (existingTypes != null) {
        for (MoteType existingMoteType : existingTypes) {
          if (existingMoteType.getIdentifier().equals(testID)) {
            okID = false;
            break;
          }
        }
      }

      if (!okID) {
        continue;
      }

      // Check if identifier library has been loaded
      File libraryFile = new File(ContikiMoteType.tempOutputDirectory, testID + ContikiMoteType.librarySuffix);
      if (CoreComm.hasLibraryFileBeenLoaded(libraryFile)) {
        okID = false;
      }
    }

    return testID;
  }

  /**
   * Returns a panel with interesting data for this mote type.
   *
   * @return Mote type visualizer
   */
  public JPanel getTypeVisualizer() {
    JPanel panel = new JPanel();
    JLabel label = new JLabel();
    JPanel smallPane;

    panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));

    // Identifier
    smallPane = new JPanel(new BorderLayout());
    label = new JLabel("Identifier");
    smallPane.add(BorderLayout.WEST, label);
    label = new JLabel(identifier);
    smallPane.add(BorderLayout.EAST, label);
    panel.add(smallPane);

    // Description
    smallPane = new JPanel(new BorderLayout());
    label = new JLabel("Description");
    smallPane.add(BorderLayout.WEST, label);
    label = new JLabel(description);
    smallPane.add(BorderLayout.EAST, label);
    panel.add(smallPane);

    // Contiki dir
    smallPane = new JPanel(new BorderLayout());
    label = new JLabel("Contiki path");
    smallPane.add(BorderLayout.WEST, label);
    label = new JLabel(contikiBaseDir);
    smallPane.add(BorderLayout.EAST, label);
    panel.add(smallPane);

    // Library class name
    smallPane = new JPanel(new BorderLayout());
    label = new JLabel("JNI Class");
    smallPane.add(BorderLayout.WEST, label);
    label = new JLabel(libraryClassName);
    smallPane.add(BorderLayout.EAST, label);
    panel.add(smallPane);

    // Processes
    smallPane = new JPanel(new BorderLayout());
    label = new JLabel("Processes");
    smallPane.add(BorderLayout.WEST, label);
    panel.add(smallPane);

    for (String process : processes) {
      smallPane = new JPanel(new BorderLayout());
      label = new JLabel(process);
      smallPane.add(BorderLayout.EAST, label);
      panel.add(smallPane);
    }

    // Sensors
    smallPane = new JPanel(new BorderLayout());
    label = new JLabel("Sensors");
    smallPane.add(BorderLayout.WEST, label);
    panel.add(smallPane);

    for (String sensor : sensors) {
      smallPane = new JPanel(new BorderLayout());
      label = new JLabel(sensor);
      smallPane.add(BorderLayout.EAST, label);
      panel.add(smallPane);
    }

    // Core Interfaces
    smallPane = new JPanel(new BorderLayout());
    label = new JLabel("Core interfaces");
    smallPane.add(BorderLayout.WEST, label);
    panel.add(smallPane);

    for (String mInterface : coreInterfaces) {
      smallPane = new JPanel(new BorderLayout());
      label = new JLabel(mInterface);
      smallPane.add(BorderLayout.EAST, label);
      panel.add(smallPane);
    }

    // Mote Interfaces
    smallPane = new JPanel(new BorderLayout());
    label = new JLabel("Mote interfaces");
    smallPane.add(BorderLayout.WEST, label);
    panel.add(smallPane);

    for (Class moteInterface : moteInterfaces) {
      smallPane = new JPanel(new BorderLayout());
      label = new JLabel(moteInterface.getSimpleName());
      smallPane.add(BorderLayout.EAST, label);
      panel.add(smallPane);
    }

    panel.add(Box.createRigidArea(new Dimension(0, 5)));
    return panel;
  }

  public Collection<Element> getConfigXML() {
    Vector<Element> config = new Vector<Element>();

    Element element;

    // Identifier
    element = new Element("identifier");
    element.setText(getIdentifier());
    config.add(element);

    // Description
    element = new Element("description");
    element.setText(getDescription());
    config.add(element);

    // Contiki base directory
    element = new Element("contikibasedir");
    element.setText(getContikiBaseDir());
    config.add(element);

    // Contiki core directory
    element = new Element("contikicoredir");
    element.setText(getContikiCoreDir());
    config.add(element);

    // User project directory
    for (File projectDir : projectDirs) {
      element = new Element("projectdir");
      element.setText(projectDir.getPath().replace('\\', '/'));
      config.add(element);
    }

    // Compilation files
    for (File compileFile : compilationFiles) {
      element = new Element("compilefile");
      element.setText(compileFile.getPath().replace('\\', '/'));
      config.add(element);
    }

    // Contiki processes
    for (String process : getProcesses()) {
      element = new Element("process");
      element.setText(process);
      config.add(element);
    }

    // Contiki sensors
    for (String sensor : getSensors()) {
      element = new Element("sensor");
      element.setText(sensor);
      config.add(element);
    }

    // Mote interfaces
    for (Class moteInterface : getMoteInterfaces()) {
      element = new Element("moteinterface");
      element.setText(moteInterface.getName());
      config.add(element);
    }

    // Core interfaces
    for (String coreInterface : getCoreInterfaces()) {
      element = new Element("coreinterface");
      element.setText(coreInterface);
      config.add(element);
    }

    // Has system symbols
    element = new Element("symbols");
    element.setText(new Boolean(hasSystemSymbols).toString());
    config.add(element);

    // Communication stack
    element = new Element("commstack");
    element.setText(commStack.toString());
    config.add(element);

    return config;
  }

  public boolean setConfigXML(Simulation simulation,
      Collection<Element> configXML, boolean visAvailable)
      throws MoteTypeCreationException {
    projectDirs = new Vector<File>();
    compilationFiles = new Vector<File>();
    processes = new Vector<String>();
    sensors = new Vector<String>();
    coreInterfaces = new Vector<String>();
    moteInterfaces = new Vector<Class<? extends MoteInterface>>();
    mySimulation = simulation;

    for (Element element : configXML) {
      String name = element.getName();

      if (name.equals("identifier")) {
        identifier = element.getText();
      } else if (name.equals("description")) {
        description = element.getText();
      } else if (name.equals("contikibasedir")) {
        contikiBaseDir = element.getText();
      } else if (name.equals("contikicoredir")) {
        contikiCoreDir = element.getText();
      } else if (name.equals("projectdir")) {
        projectDirs.add(new File(element.getText()));
      } else if (name.equals("compilefile")) {
        compilationFiles.add(new File(element.getText()));
      } else if (name.equals("process")) {
        processes.add(element.getText());
      } else if (name.equals("sensor")) {
        sensors.add(element.getText());
      } else if (name.equals("symbols")) {
        hasSystemSymbols = Boolean.parseBoolean(element.getText());
      } else if (name.equals("commstack")) {
        commStack = CommunicationStack.parse(element.getText());
      } else if (name.equals("coreinterface")) {
        coreInterfaces.add(element.getText());
      } else if (name.equals("moteinterface")) {
        Class<? extends MoteInterface> moteInterfaceClass = simulation.getGUI()
            .tryLoadClass(this, MoteInterface.class, element.getText().trim());

        if (moteInterfaceClass == null) {
          logger.warn("Can't find mote interface class: " + element.getText());
        } else {
          moteInterfaces.add(moteInterfaceClass);
        }
      } else {
        logger.fatal("Unrecognized entry in loaded configuration: " + name);
      }
    }

    // Create class specific configuration
    myConfig = simulation.getGUI().getProjectConfig().clone();

    // Merge with all project directory configs (if any)
    for (File projectDir : projectDirs) {
      try {
        myConfig.appendProjectDir(projectDir);
      } catch (Exception ex) {
        logger.fatal("Error when parsing project directory config: " + ex);
        return false;
      }
    }

    mySimulation = simulation;
    boolean createdOK = configureAndInit(GUI.getTopParentContainer(), simulation, visAvailable);
    return createdOK;
  }

}