demo.java

伟大的Contiki工程, 短小精悍 的操作系统, 学习编程不可不看

    totalLabel = new JLabel();
    totalLabel.setIcon(new ImageIcon(image));

    MouseListener categoryChangeListener = new MouseListener() {
      public void mouseClicked(MouseEvent e) {
        System.out.println("Toggling category order");

        categoryOrder++;
        totalDataset.clear();
        for (int i=0; i < NUMBER_NODES; i++) {
          for (int j=0; j < CATEGORIES.length; j++) {
            totalDataset.addValue(0, CATEGORIES[(j + categoryOrder) % CATEGORIES.length], getNodeNameFromIndex(i));
          }
        }
        totalChart = ChartFactory.createStackedBarChart(null, null, "Power (mW)", totalDataset, PlotOrientation.VERTICAL, true, true, true);
        ValueAxis rangeAxis = totalChart.getCategoryPlot().getRangeAxis();
//         rangeAxis.setRange(0, CHARTS_MAX_MILLIWATTS);

        relativeDataset.clear();
        for (int i=0; i < NUMBER_NODES; i++) {
          for (int j=0; j < CATEGORIES.length; j++) {
            relativeDataset.setValue(CATEGORIES[(j + categoryOrder) % CATEGORIES.length], 0.00001);
          }
        }
        relativeChart = ChartFactory.createPieChart("Moving Average: Relative power distribution", relativeDataset, false, false, false);

	updateCharts();
      }
      public void mousePressed(MouseEvent e) {
      }
      public void mouseReleased(MouseEvent e) {
      }
      public void mouseEntered(MouseEvent e) {
      }
      public void mouseExited(MouseEvent e) {
      }
    };
    totalLabel.addMouseListener(categoryChangeListener);
    relativeLabel.addMouseListener(categoryChangeListener);

    MouseListener toggleTrackedListener = new MouseListener() {
      public void mouseClicked(MouseEvent e) {
        trackedNodeIndex = (trackedNodeIndex + 1) % NODE_IDS.length;
        System.out.println("Tracking " + getNodeNameFromIndex(trackedNodeIndex));

        createHistoryChartForNode(nodeHistoryLabel, trackedNodeIndex);

        updateCharts();
      }
      public void mousePressed(MouseEvent e) {
      }
      public void mouseReleased(MouseEvent e) {
      }
      public void mouseEntered(MouseEvent e) {
      }
      public void mouseExited(MouseEvent e) {
      }
    };
    nodeHistoryLabel.addMouseListener(toggleTrackedListener);
  }

  public void createHistoryChartForNode(JLabel label, int index) {
    BufferedImage image;

    /* Create history */
    nodeHistorySerie = new TimeSeries("", Second.class);
    nodeHistorySerie.removeAgedItems(true);
    nodeHistorySerie.setMaximumItemCount(HISTORY_MAX_SECONDS);
    TimeSeriesCollection historyData = new TimeSeriesCollection(nodeHistorySerie);
    nodeHistoryChart = ChartFactory.createTimeSeriesChart(getNodeNameFromIndex(index) + ": Total power (mW)", null, null, historyData, false, false, false);
    ValueAxis rangeAxis = nodeHistoryChart.getXYPlot().getRangeAxis();
    rangeAxis.setRange(0, CHARTS_MAX_MILLIWATTS);
    image = nodeHistoryChart.createBufferedImage(NODE_WIDTH,NODE_HEIGHT);
    label.setIcon(new ImageIcon(image));
  }

  public void addHistoryPower(double newPower) {
    if (nodeHistorySerie != null) {
      nodeHistorySerie.addOrUpdate(new Second(), newPower);
    }
  }

  public void updateTotalPower(String category, String nodeName, double newValue) {
    if (totalDataset != null) {
      totalDataset.addValue(newValue, category, nodeName);
    }
  }

  public void updateTotalPowers(String nodeName, double lpm, double cpu, double listen, double transmit) {
    updateTotalPower(CATEGORIES[0], nodeName, lpm);
    updateTotalPower(CATEGORIES[1], nodeName, cpu);
    updateTotalPower(CATEGORIES[2], nodeName, listen);
    updateTotalPower(CATEGORIES[3], nodeName, transmit);
  }

  public void setRelativePower(String category, double newVal) {
    if (relativeDataset != null) {
      relativeDataset.setValue(category, newVal);
    }
  }

  public void setRelativePowers(double lpm, double cpu, double listen, double transmit) {
    setRelativePower(CATEGORIES[0], lpm);
    setRelativePower(CATEGORIES[1], cpu);
    setRelativePower(CATEGORIES[2], listen);
    setRelativePower(CATEGORIES[3], transmit);
  }

  public void updateMARelativePowers(double lpm, double cpu, double listen, double transmit) {
    /* Add new values */
    historyLPM.add(lpm);
    historyCPU.add(cpu);
    historyListen.add(listen);
    historyTransmit.add(transmit);

    /* Remove old values (if any) */
    if (historyLPM.size() > MA_HISTORY_LENGTH) {
      historyLPM.remove(0);
    }
    if (historyCPU.size() > MA_HISTORY_LENGTH) {
      historyCPU.remove(0);
    }
    if (historyListen.size() > MA_HISTORY_LENGTH) {
      historyListen.remove(0);
    }
    if (historyTransmit.size() > MA_HISTORY_LENGTH) {
      historyTransmit.remove(0);
    }

    /* Calculate average */
    double lpmMA = 0;
    for (double power: historyLPM) {
      lpmMA += power;
    }
    lpmMA /= historyLPM.size();

    double cpuMA = 0;
    for (double power: historyCPU) {
      cpuMA += power;
    }
    cpuMA /= historyCPU.size();

    double transmitMA = 0;
    for (double power: historyTransmit) {
      transmitMA += power;
    }
    transmitMA /= historyTransmit.size();

    double listenMA = 0;
    for (double power: historyListen) {
      listenMA += power;
    }
    listenMA /= historyListen.size();

    setRelativePowers(lpmMA, cpuMA, listenMA, transmitMA);
  }


  public void parseIncomingLine(String line) {
    if (line == null) {
      System.err.println("Parsing null line");
      return;
    }

    /* Split line into components */
    String[] components = line.split(" ");
    if (components.length != PARSE_NR_COMPONENTS) {
      System.err.println("Parsing wrong components count (" + components.length + "): '" + line + "'");
      return;
    }

    /* Parse source and components times */
    int sinkNodeID=-1, sourceNodeID=-1, timeCPU=-1, timeLPM=-1, timeTransmit=-1, timeListen=-1;
    try {
      sinkNodeID = Integer.parseInt(components[PARSE_POS_SINK_ID]);
      if (!components[PARSE_POS_SICS_ID].equals(PARSE_SICS_ID)) {
        throw new Exception("Parsing non-demo data: '" + line + "'");
      }
      /*Integer.parseInt(components[PARSE_POS_COUNT]);*/
      sourceNodeID = Integer.parseInt(components[PARSE_POS_SOURCE_ID]);
      timeCPU = Integer.parseInt(components[PARSE_POS_TIME_CPU]);
      timeLPM = Integer.parseInt(components[PARSE_POS_TIME_LPM]);
      timeTransmit = Integer.parseInt(components[PARSE_POS_TIME_TRANSMIT]);
      /* TODO Too big transmit time? */
      timeListen = Integer.parseInt(components[PARSE_POS_TIME_LISTEN]);
    } catch (Exception e) {
      System.err.println(e.getMessage());
      return;
    }

    /* Validate parsed values */
    String nodeName = getNodeNameFromId(sourceNodeID);
    if (nodeName == null) {
      System.err.println("No registered node with ID " + sourceNodeID + ": '" + line + "'");
      return;
    }
    if (timeCPU < 0) {
      System.err.println("Parsed negative CPU time (" + timeCPU + "): '" + line + "'");
      return;
    }
    if (timeLPM < 0) {
      System.err.println("Parsed negative LPM time (" + timeLPM + "): '" + line + "'");
      return;
    }
    if (timeTransmit < 0) {
      System.err.println("Parsed negative transmit time (" + timeTransmit + "): '" + line + "'");
      return;
    }
    if (timeListen < 0) {
      System.err.println("Parsed negative listen time (" + timeListen + "): '" + line + "'");
      return;
    }

    /* Calculate component specific powers using parsed times */
    double powerCPU = (timeCPU / TICKS_PER_SECOND) * POWER_CPU / UPDATE_PERIOD;
    double powerLPM = (timeLPM  / TICKS_PER_SECOND)* POWER_LPM / UPDATE_PERIOD;
    double powerTransmit = (timeTransmit / TICKS_PER_SECOND)* POWER_TRANSMIT / UPDATE_PERIOD;
    double powerListen = (timeListen / TICKS_PER_SECOND) * POWER_LISTEN / UPDATE_PERIOD;

    /* Update node history */
    if (getNodeNameFromId(sourceNodeID).equals(getNodeNameFromIndex(trackedNodeIndex))) {
      System.out.println("Parsed data from tracked " + nodeName);
      addHistoryPower(powerCPU + powerLPM + powerTransmit + powerListen);
    } else {
      System.out.println("Parsed data from " + nodeName);
    }

    updateMARelativePowers(powerLPM, powerCPU, powerListen, powerTransmit);

    updateTotalPowers(nodeName, powerLPM, powerCPU, powerListen, powerTransmit);

    //    updateCharts();
  }


  public void updateCharts() {
    BufferedImage image;

    /* Recreate all label icons */
    /* TODO Only update changed charts: i */
    if (relativeLabel != null) {
      image = relativeChart.createBufferedImage(NODE_WIDTH,NODE_HEIGHT);
      relativeLabel.setIcon(new ImageIcon(image));
    }
    if (nodeHistoryLabel != null) {
      image = nodeHistoryChart.createBufferedImage(NODE_WIDTH,NODE_HEIGHT);
      nodeHistoryLabel.setIcon(new ImageIcon(image));
    }
    if (totalLabel != null) {
      image = totalChart.createBufferedImage(TOTAL_WIDTH,TOTAL_HEIGHT);
      totalLabel.setIcon(new ImageIcon(image));
    }

    repaint();
  }


  public String getNodeNameFromIndex(int index) {
    return "Node " + NODE_IDS[index];
  }

  public static String getNodeNameFromId(int id) {
    boolean exists = false;
    for (int existingID: NODE_IDS) {
      if (existingID == id) {
        exists = true;
        break;
      }
    }

    if (!exists) {
      System.err.println("Node " + id + " is not registered!");
      return null;
    }
    return "Node " + id;
  }


  public static void main(final String[] args) {
    if (args.length != 1) {
      System.err.println("Usage: java Demo COMPORT [TRACK_NODE_ID]");
      return;
    }

    final String comPort = args[0];

    javax.swing.SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        new Demo(comPort);
      }
    });
  }

  /* TEMPORARY DATA */
  int TEMP_COUNTER = 0;
  String[] TEMP_NODE_DATA = {
    "33 S 1 33 3 0 4093 0",
    "33 R 1 34 44 0 4052 0",
    "33 S 2 33 77 0 4019 0",
    "33 S 3 33 39 0 4057 0",
    "33 R 2 34 39 0 4057 0",
    "33 S 4 33 78 0 4018 0",
    "33 R 3 34 80 0 4016 0",
    "33 S 5 33 83 0 4013 0",
    "33 R 4 34 80 0 4015 0",
    "33 S 6 33 90 0 4006 0",
    "33 S 7 33 40 0 4056 0",
    "33 R 5 34 87 0 4009 0",
    "33 S 8 33 80 0 4016 0",
    "33 R 6 34 130 0 3965 0",
    "33 S 9 33 81 0 4015 0",
    "33 S 10 33 39 0 4057 0",
    "33 R 7 34 87 0 4009 0",
    "33 S 11 33 89 0 4007 0",
    "33 R 8 34 94 0 4002 0",
    "33 S 12 33 89 0 4007 0",
    "33 R 9 34 47 0 4049 0",
    "33 S 13 33 83 0 4013 0",
    "33 R 10 34 82 0 4014 0",
    "33 S 14 33 90 0 4006 0",
    "33 R 11 34 94 0 3999 0",
    "33 S 15 33 92 0 4004 0",
    "33 S 16 33 46 0 4050 0",
    "33 R 12 34 132 0 3964 0",
    "33 R 13 34 46 0 4050 0",
    "33 S 17 33 140 0 3956 0",
    "33 R 14 34 86 0 4009 0",
    "33 S 18 33 85 0 4010 0",
    "33 R 15 34 94 0 4002 0",
    "33 S 19 33 83 0 4013 0",
    "33 S 20 33 41 0 4055 0",
    "33 R 16 34 41 0 4055 0",
    "33 S 21 33 86 0 4009 0",
    "33 R 17 34 86 0 4010 0",
    "33 R 18 34 84 0 4012 0",
    "33 S 22 33 127 0 3969 0",
    "33 R 19 34 84 0 4012 0",
    "33 S 23 33 85 0 4011 0",
    "33 S 24 33 44 0 4052 0",
    "33 R 20 34 41 0 4055 0",
    "33 S 25 33 86 0 4010 0",
    "33 S 26 33 47 0 4048 0",
    "33 R 21 34 94 0 4000 0",
    "33 S 27 33 89 0 4004 0"
  };
}