deluge.java

tinyos最新版

	if (prevVNum == DelugeConsts.DELUGE_INVALID_VNUM) {
	  System.out.println("Upgrading image [" + imgID + "] from version [NONE] to ["
			     + ((int)vNum&0xffff) + "] ...");
	}
	else {
	  System.out.println("Upgrading image [" + imgID + "] from version [" 
			     + ((int)prevVNum&0xffff) + "] to ["
			     + ((int)vNum&0xffff) + "] ...");
	}			   

	advMsg.setElement_imgSummaries_vNum(imgID, vNum);
	advMsg.setElement_imgSummaries_numPgs(imgID, (byte)numPgs);
	advMsg.setElement_imgSummaries_numPgsComplete(imgID, (byte)numPgs);

	break;
      default:
	System.err.println("ERROR: Unexpected mode: " + mode);
	allDone(1);
      }
	
      break;

    case DelugeReqMsg.AM_TYPE:

      DelugeReqMsg req = (DelugeReqMsg)m;
      boolean      pktsToSend[] = new boolean[DelugeConsts.DELUGE_PKTS_PER_PAGE];

      if (printAllMsgs) System.out.print(req);

      if (vNum == (short)DelugeConsts.DELUGE_INVALID_VNUM)
	return;

      if (vNum != req.get_vNum()) {
	System.out.println("ERROR: Node requesting version " + req.get_vNum() 
			   + ", wrong version.");
	allDone(1);
      }
      
      for ( int i = 0; i < DelugeConsts.DELUGE_PKTS_PER_PAGE; i++ ) {
	short[] tmp = req.get_requestedPkts();
	if ((tmp[i/8]&(1 << (i%8))) != 0)
	  pktsToSend[i] = true;
      }

      image.transmitPage(req.get_pgNum(), pktsToSend);
      
      break;
    }

  }

  synchronized void send(Message m) {
    try {
      intf.send(MoteIF.TOS_BCAST_ADDR, m);
    } catch (IOException e) {
      e.printStackTrace();
      System.out.println("ERROR: Can't send message");
      allDone(1);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  boolean readBinary(String fName) {
    short tmpImage[] = new short[DelugeConsts.DELUGE_MAX_IMAGE_SIZE*1024*2];
    int   totalBytes = 0;

    try {
      DataInputStream dis = new DataInputStream(new FileInputStream(fName));

      System.out.println("Reading file: " + fName);
      while(true) {
	short value = (short)((short)dis.readByte() & (short)0xff);
	if (totalBytes >= DelugeConsts.DELUGE_MAX_IMAGE_SIZE*1024) {
	  System.out.println("ERROR: Image too large (max supported image = " + 
			     (DelugeConsts.DELUGE_MAX_IMAGE_SIZE*1024) + " bytes).");
	  allDone(1);
	}
	tmpImage[totalBytes++] = value;
      }
    } catch (EOFException e) {
      ;
    } catch(FileNotFoundException e) {
      System.out.println("ERROR: File '" + fName + "' not found.");
      return false;
    } catch (IOException e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    }
    
    image = new DelugeImg(tmpImage, totalBytes);
    imageThread = new Thread(image);
    imageThread.start();

    numPgs = (short)(((image.getImgSize()-1)/(DelugeConsts.DELUGE_PKTS_PER_PAGE*DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE))+1);
    System.out.println("Read complete: (Bytes=" + totalBytes + ")");
    System.out.println("Deluge image stats: (Size=" + image.getImgSize() +
		       ",Pages=" + numPgs +
		       ",Pkts=" + (numPgs*DelugeConsts.DELUGE_PKTS_PER_PAGE) +
		       ")");
    System.out.println("-------------------------------------------------------");


    return true;
  }
  
  boolean readIhex(String fName) {
    short tmpImage[] = new short[DelugeConsts.DELUGE_MAX_IMAGE_SIZE*1024*2];
    int   upperSegBaseAddr = 0;
    int   tmpImageOffset = 0;
    int   totalBytes = 0;
    int   sectionCount = 0;
    int   curAddr = 0;
    int   sectionStartAddr = 0;
    int   imgStartOffset = 0;
    
    try {
      BufferedReader dis = new BufferedReader(new InputStreamReader(new FileInputStream(fName)));

      System.out.println("Reading file: " + fName);

      while(true) {
	char bline[] = dis.readLine().toUpperCase().toCharArray();
	if (bline[0] != ':') {
	  System.out.println("ERROR: Parse error in ihex file.");
	  return false;
	}

	int reclen = Integer.parseInt(Character.toString(bline[1]) + 
				      Character.toString(bline[2]),
				      16);

	int offset = Integer.parseInt(Character.toString(bline[3]) + 
				      Character.toString(bline[4]) +
				      Character.toString(bline[5]) +
				      Character.toString(bline[6]),
				      16);

	int rectyp = Integer.parseInt(Character.toString(bline[7]) +
				      Character.toString(bline[8]),
				      16);

	switch(rectyp) {
	case RECTYP_DATA:
	  if ((upperSegBaseAddr+offset) != curAddr) {
	    int sectionLen = curAddr - sectionStartAddr;
	    for ( int i = 0; i < 4; i++ )
	      tmpImage[imgStartOffset+4+i] = (short)((sectionLen >> (i*8)) & 0xff);
	  }
	  
	  if (tmpImageOffset == 0 || (upperSegBaseAddr+offset) != curAddr) {
	    sectionCount++;
	    curAddr = (upperSegBaseAddr+offset);
	    sectionStartAddr = (upperSegBaseAddr+offset);
	    imgStartOffset = tmpImageOffset;
	    tmpImage[tmpImageOffset+0] = (short)((curAddr >> 0x0) & 0xff);
	    tmpImage[tmpImageOffset+1] = (short)((curAddr >> 0x8) & 0xff);
	    tmpImageOffset += 8;
	  }
	  
	  for ( int i = 0; i < reclen; i++ ) {

	    if (tmpImageOffset >= DelugeConsts.DELUGE_MAX_IMAGE_SIZE*1024) {
	      System.out.println("ERROR: Image too large (max supported image = " + 
				 (DelugeConsts.DELUGE_MAX_IMAGE_SIZE*1024) + " bytes).");
	      allDone(1);
	    }
	    
	    tmpImage[tmpImageOffset++] = (short)Integer.parseInt(Character.toString(bline[2*i+9]) +
								 Character.toString(bline[2*i+10]),
								 16);
	    
	    totalBytes++;
	    curAddr++;
	    
	  }
	  break;
	case RECTYP_EXTSEG:
	  upperSegBaseAddr = Integer.parseInt(Character.toString(bline[9]) +
					      Character.toString(bline[10]) +
					      Character.toString(bline[11]) +
					      Character.toString(bline[12]),
					      16);
	  upperSegBaseAddr <<= 4;
	}

	if (rectyp == RECTYP_EOF) {
	  int sectionLen = curAddr - sectionStartAddr;
	  for ( int i = 0; i < 4; i++ )
	    tmpImage[imgStartOffset+4+i] = (short)((sectionLen >> (i*8)) & 0xff);
	  for ( int i = 0; i < 8; i++ )
	    tmpImage[tmpImageOffset++] = 0x0;
	  break;
	}
      }
    } catch(FileNotFoundException e) {
      System.out.println("ERROR: File '" + fName + "' not found.");
      return false;
    } catch (IOException e) {
      e.printStackTrace();
      return false;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }

    image = new DelugeImg(tmpImage, tmpImageOffset);
    imageThread = new Thread(image);
    imageThread.start();
    numPgs = (short)(((image.getImgSize()-1)/(DelugeConsts.DELUGE_PKTS_PER_PAGE*DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE))+1);
    System.out.println("Read complete: (Bytes=" + totalBytes +
		       ",Sections=" + sectionCount +
		       ")");
    System.out.println("Deluge image stats: (Size=" + image.getImgSize() +
		       ",Pages=" + numPgs +
		       ",Pkts=" + (numPgs*DelugeConsts.DELUGE_PKTS_PER_PAGE) +
		       ")");
    
    System.out.println("-------------------------------------------------------");

    return true;
  }

  private short crcByte(short crc, byte b) {
    int i;
    
    crc = (short)(crc ^ b << 8);
    i = 8;
    do {
      if ((crc & 0x8000) != 0)
	crc = (short)(crc << 1 ^ 0x1021);
      else
	crc = (short)(crc << 1);
    } while (--i > 0);
    
    return crc;
  }

  public static void main(String[] args) {

    Thread thread = new Thread(new Deluge(args));
    thread.setDaemon(true);
    thread.start();
    try {
      thread.join();
    } catch (Exception e) {
      e.printStackTrace();
    }

  }

  private class DelugeImg implements Runnable {

    private short   image[] = new short[DelugeConsts.DELUGE_MAX_IMAGE_SIZE*1024*2];
    private boolean pktsToSend[] = new boolean[DelugeConsts.DELUGE_PKTS_PER_PAGE];
    private int     pageToSend = DelugeConsts.DELUGE_NO_PAGE;
    private int     byteCount = 0;
    private int     curPkt = 0;

    private int     size;

    public DelugeImg(short source[], int length) {
      short crc = 0;

      for ( int i = 0; i < length; i++ ) {
	if (isCrcByte(size)) {
	  image[size+0] = (short)((crc >> 0x0) & 0xff);
	  image[size+1] = (short)((crc >> 0x8) & 0xff);
	  size += 2;
	  crc = 0;
	}
	crc = crcByte(crc, (byte)source[i]);
	image[size++] = source[i];
      }
      
      // finish out rest of page and calculate CRC
      while(!isCrcByte(size)) {
	crc = crcByte(crc, (byte)0x0);
	image[size++] = 0;
      }
      
      image[size+0] = (short)((crc >> 0x0) & 0xff);
      image[size+1] = (short)((crc >> 0x8) & 0xff);
      size += 2;
    }

    public int  getImgSize() { return size; }

    public void dump() {
      for (int i = 0; i < size; i++ )
	printByte(image[i]);
      System.out.println();
    }

    synchronized public void transmitPage(int pgNum, boolean _pktsToSend[]) {

      if (pgNum > pageToSend)
	return;
      
      if (pgNum < pageToSend) {
	for ( int i = 0; i < pktsToSend.length; i++ )
	  pktsToSend[i] = false;
	pageToSend = pgNum;
	curPkt = 0;
      }
      for ( int i = 0; i < pktsToSend.length; i++ )
	pktsToSend[i] |= _pktsToSend[i];

      notifyAll();

    }

    private void printByte(int byteVal) {
      if (byteVal >= 0 && byteVal < 16)
	System.out.print("0");
      System.out.print(Integer.toHexString(byteVal).toUpperCase() + " " );
      byteCount++;
      if (byteCount >= 16) {
	System.out.println();
	byteCount = 0;
      }
    }

    private boolean isCrcByte(int offset) {
      return (((offset + 2) % 
	       (DelugeConsts.DELUGE_PKTS_PER_PAGE*DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE)) == 0);
      //(offset+DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE)%
      //(DelugeConsts.DELUGE_PKTS_PER_PAGE*DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE)) == 0;
    }

    private boolean arePacketsToSend() {
      for ( int i = 0; i < DelugeConsts.DELUGE_PKTS_PER_PAGE; i++ ) {
	if (pktsToSend[i])
	  return true;
      }
      return false;
    }

    synchronized private void transmitPacket() {

      DelugeDataMsg dataMsg = new DelugeDataMsg();
      short packet[] = new short[DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE];

      while ( !arePacketsToSend() ) {
	pageToSend = DelugeConsts.DELUGE_NO_PAGE;
	try {
	  wait();
	  System.out.print("\rInjecting page [" + (pageToSend+1) + "] of [" + numPgs + "] ...");
	} catch (Exception e) {
	  e.printStackTrace();
	}
      }
      
      dataMsg.set_vNum((short)vNum);
      dataMsg.set_imgNum(imgID);
      dataMsg.set_pgNum((short)pageToSend);
    
      while (!pktsToSend[curPkt])
	curPkt = (curPkt+1) % DelugeConsts.DELUGE_PKTS_PER_PAGE;
      
      System.arraycopy(image, pageToSend*(DelugeConsts.DELUGE_PKTS_PER_PAGE*DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE)
		       + curPkt*DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE, 
		       packet, 0,
		       DelugeConsts.DELUGE_PKT_PAYLOAD_SIZE);
      
      dataMsg.set_pktNum((short)curPkt);
      dataMsg.set_data(packet);
      if (printAllMsgs) System.out.print(dataMsg);
      send(dataMsg);
      pktsToSend[curPkt] = false;
      curPkt = (curPkt + 1) % DelugeConsts.DELUGE_PKTS_PER_PAGE;
    
    }

    synchronized private void send(Message m) {
      try {
	intf.send(MoteIF.TOS_BCAST_ADDR, m);
      } catch (IOException e) {
	e.printStackTrace();
	System.out.println("ERROR: Can't send message");
	allDone(1);
      } catch (Exception e) {
	e.printStackTrace();
      }
    }

    public void run() {
      try {
	for(;;) {
	  transmitPacket();
	}
      } catch (Exception e) {
	e.printStackTrace();
      }
    }

  }

}