onewirecontainer21.java

这是一个以JAVA编写的程序,本人还没有试过,是一个简单的温度控制系统

   /**
    * Gets an enumeration of memory bank instances that implement one or more
    * of the following interfaces:
    * {@link com.dalsemi.onewire.container.MemoryBank MemoryBank},
    * {@link com.dalsemi.onewire.container.PagedMemoryBank PagedMemoryBank},
    * and {@link com.dalsemi.onewire.container.OTPMemoryBank OTPMemoryBank}.
    * @return <CODE>Enumeration</CODE> of memory banks
    */
   public Enumeration getMemoryBanks ()
   {
      Vector bank_vector = new Vector(6);

      // scratchpad
      bank_vector.addElement(scratch);

      // NVRAM
      bank_vector.addElement(new MemoryBankNVCRC(this, scratch));

      // Register page
      bank_vector.addElement(register);

      // Alarm time stamps and duration
      bank_vector.addElement(alarm);

      // Histogram
      bank_vector.addElement(histogram);

      // Log
      bank_vector.addElement(log);

      return bank_vector.elements();
   }

   //--------
   //-------- Private
   //--------

   /**
    * Construct the memory banks used for I/O.
    */
   private void initMem ()
   {

      // scratchpad
      scratch = new MemoryBankScratchCRC(this);

      // Register
      register                      = new MemoryBankNVCRC(this, scratch);
      register.numberPages          = 1;
      register.size                 = 32;
      register.bankDescription      = "Register control";
      register.startPhysicalAddress = 0x200;
      register.generalPurposeMemory = false;

      // Alarm registers
      alarm                      = new MemoryBankNVCRC(this, scratch);
      alarm.numberPages          = 3;
      alarm.size                 = 96;
      alarm.bankDescription      = "Alarm time stamps";
      alarm.startPhysicalAddress = 544;
      alarm.generalPurposeMemory = false;
      alarm.readOnly             = true;
      alarm.readWrite            = false;

      // Histogram
      histogram                      = new MemoryBankNVCRC(this, scratch);
      histogram.numberPages          = 4;
      histogram.size                 = 128;
      histogram.bankDescription      = "Temperature Histogram";
      histogram.startPhysicalAddress = 2048;
      histogram.generalPurposeMemory = false;
      histogram.readOnly             = true;
      histogram.readWrite            = false;

      // Log
      log                      = new MemoryBankNVCRC(this, scratch);
      log.numberPages          = 64;
      log.size                 = 2048;
      log.bankDescription      = "Temperature log";
      log.startPhysicalAddress = 4096;
      log.generalPurposeMemory = false;
      log.readOnly             = true;
      log.readWrite            = false;
   }

   /**
    * Sets the following, calculated from the
    * 12-bit code of the 1-Wire Net Address:
    * (All temperatures set to degrees Celsius)
    * 1)  The part numbers:
    *     DS1921L-F50 = physical range -40 to +85,
    *                   operating range -40 to +85.
    *     DS1921L-F51 = physical range -40 to +85,
    *                   operating range -10 to +85.
    *     DS1921L-F52 = physical range -40 to +85,
    *                   operating range -20 to +85.
    *     DS1921L-F53 = physical range -40 to +85,
    *                   operating range -30 to +85.
    *
    *     DS1921H     = physical range 15 to 46,
    *                   operating range -40 to +85
    *     DS1921Z     = physical range -5 to 26,
    *                   operating range -40 to +85
    * 2)  Temperature Range low temperature.
    * 3)  Temperature Range width in degrees Celsius.
    * 4)  Temperature Resolution.
    * 5)  If a DS1921H or DS1921Z is detected.
    *
    */
   private void setThermochronVariables()
   {
      // Get Temperature Range code, which is the first 12 (MSB) bits of the
      // unique serial number (after the CRC).
      byte[] address = getAddress(); // retrieve 1-Wire net address to look at range code.
      int rangeCode = (((address[6]&0x0FF)<<4)|((address[5]&0x0FF)>>4));

      switch (rangeCode)
      {
         case 0x34C:
            partNumber = "DS1921L-F51";
            temperatureRangeLow = -40;
            temperatureRangeHigh = 85;
            temperatureResolution = 0.5;
            temperatureOperatingRangeLow = -10;
            temperatureOperatingRangeHigh = 85;
            isDS1921HZ = false;
            break;
         case 0x254:
            partNumber = "DS1921L-F52";
            temperatureRangeLow = -40;
            temperatureRangeHigh = 85;
            temperatureResolution = 0.5;
            temperatureOperatingRangeLow = -20;
            temperatureOperatingRangeHigh = 85;
            isDS1921HZ = false;
            break;
         case 0x15C:
            partNumber = "DS1921L-F53";
            temperatureRangeLow = -40;
            temperatureRangeHigh = 85;
            temperatureResolution = 0.5;
            temperatureOperatingRangeLow = -30;
            temperatureOperatingRangeHigh = 85;
            isDS1921HZ = false;
            break;
         case 0x4F2:
            partNumber = "DS1921H-F5";
            temperatureRangeLow = 15;
            temperatureRangeHigh = 46;
            temperatureResolution = 0.125;
            temperatureOperatingRangeLow = -40;
            temperatureOperatingRangeHigh = 85;
            isDS1921HZ = true;
            break;
         case 0x3B2:
            partNumber = "DS1921Z-F5";
            temperatureRangeLow = -5;
            temperatureRangeHigh = 26;
            temperatureResolution = 0.125;
            temperatureOperatingRangeLow = -40;
            temperatureOperatingRangeHigh = 85;
            isDS1921HZ = true;
            break;
         default:
            long lower36bits =
               (((long)address[5]&0x0F)<<32) |
               (((long)address[4]&0x0FF)<<24) |
               (((long)address[3]&0x0FF)<<16) |
               (((long)address[2]&0x0FF)<<8) |
               ((long)address[1]&0x0FF);
            if (lower36bits >= 0x100000)
               partNumber = "DS1921G-F5";
            else
               partNumber = "DS1921L-PROTO";

            temperatureRangeLow = -40;
            temperatureRangeHigh = 85;
            temperatureResolution = 0.5;
            temperatureOperatingRangeLow = -40;
            temperatureOperatingRangeHigh = 85;
            isDS1921HZ = false;
            break;

      }
      /*
      // Get Temperature Range code, which is the first 12 (MSB) bits of the
      // unique serial number (after the CRC).
      byte[] netAddress = getAddress(); // retrieve 1-Wire net address to look at range code.
      int rangeCode = (netAddress[6] & 0xFF); // And with 0xFF to get rid of sign extension
      rangeCode = rangeCode << 8;   // left shift 8 bits to put most significant byte in correct place
      rangeCode = rangeCode + (netAddress[5] & 0xFF);  // add the least significant byte to make integer.
      rangeCode = rangeCode >> 4;   // this is a 12-bit number, so get rid of extra 4 bits.

      // Detect what kind of part we have, a DS1921L-F5X or a DS1921H/Z
      int detectionInt = rangeCode & 0x03;  // get the last 2 bits to see what they are
      if (detectionInt > 0) isDS1921HZ = true; // if the last 2 bits > 0 then the part is a DS1921H or Z

      // Get temperature ranges as a result of the rangeCode and the type of device.
      if (isDS1921HZ)
      {
         // get the most significant 8 bits of the 12-bit rangeCode
         temperatureRangeLow = rangeCode >> 4;
         temperatureRangeLow = temperatureRangeLow - 64; // 1 degree increment with 0x000 = -64 degrees.

         // Resolution Code -- the last 2 bits of the 12-bit rangeCode number
         //
         // 0 = 0.5 degrees Celsius
         // 1 = 0.25
         // 2 = 0.125
         // 3 = 0.0625
         switch(rangeCode & 0x03) // gets the last 2 bits of the 12-bit rangeCode.
         {
            case 0:
               temperatureResolution = 0.5;
               break;
            case 1:
               temperatureResolution = 0.25;
               break;
            case 2:
               temperatureResolution = 0.125;
               break;
            case 3:
               temperatureResolution = 0.0625;
               break;
            default:
               temperatureResolution = 0.5;
         }

         // Range Modifier Code (range width)
         //
         // 0 = full range, 256 * resolution
         // 1 = reduced range, 2/3 of full range
         // 2 = reduced range, 1/2 of full range
         // 3 = reduced range, 1/3 of full range

         switch((rangeCode >> 2) & 0x03)
         {
            case 0:
               temperatureRangeWidth = (256 * temperatureResolution) - 1;
               break;
            case 1:
               temperatureRangeWidth = (256 * temperatureResolution * 2 / 3) - 1;
               break;
            case 2:
               temperatureRangeWidth = (256 * temperatureResolution / 2) - 1;
               break;
            case 3:
               temperatureRangeWidth = (256 * temperatureResolution / 3) - 1;
               break;
            default:
               temperatureRangeWidth = (256 * temperatureResolution) - 1;
         }
      }
      else
      {
         // get the most significant 5 bits of the 12-bit rangeCode number.
         temperatureRangeLow = rangeCode >> 7;
         temperatureRangeLow = (temperatureRangeLow * 5) - 40;  // 5 degree increment
         temperatureResolution = 0.5;  // for non DS1921H/Z parts, the resolution is the same.
         // if part has a range code, get the next 5 bits of the 12-bit number.
         if (rangeCode > 0) temperatureRangeWidth = ((rangeCode >> 2) & (0x1F)) * 5; // 5 degree increment
      }
      // set the part number based (currently) on low temperature.
      switch((int) temperatureRangeLow) // switches on the low temperature.
      {
         case 15:
            partNumber = "DS1921H-F5";
            break;
         case -5:
            partNumber = "DS1921Z-F5";
            break;
         case -10:
            partNumber = "DS1921L-F51";
            break;
         case -20:
            partNumber = "DS1921L-F52";
            break;
         case -30:
            partNumber = "DS1921L-F53";
            break;
         case -40:
            partNumber = "DS1921L-F50";
            break;
         default:
            partNumber = "DS1921";
      }*/
   }

   /**
    * Grab the date from one of the time registers.
    * returns int[] = {year, month, date}
    */
   private int[] getDate (int timeReg, byte[] state)
   {
      byte  upper, lower;
      int[] result = new int [3];

      timeReg = timeReg & 31;

      /* extract the day of the month */
      lower      = state [timeReg++];
      upper      = ( byte ) ((lower >>> 4) & 0x0f);
      lower      = ( byte ) (lower & 0x0f);
      result [2] = 10 * upper + lower;

      /* extract the month */
      lower = state [timeReg++];
      upper = ( byte ) ((lower >>> 4) & 0x0f);
      lower = ( byte ) (lower & 0x0f);

      // the upper bit contains the century, so subdivide upper
      byte century = ( byte ) ((upper >>> 3) & 0x01);

      upper      = ( byte ) (upper & 0x01);
      result [1] = lower + upper * 10;

      /* grab the year */
      result [0] = 1900 + century * 100;
      lower      = state [timeReg++];
      upper      = ( byte ) ((lower >>> 4) & 0x0f);
      lower      = ( byte ) (lower & 0x0f);
      result [0] += upper * 10 + lower;

      return result;
   }

   /**
    * Gets the time of day fields in 24-hour time from button
    * returns int[] = {seconds, minutes, hours}
    */
   private int[] getTime (int timeReg, byte[] state)
   {
      byte  upper, lower;
      int[] result = new int [3];

      timeReg = timeReg & 31;

      // NOTE: The MSbit is ANDed out (with the 0x07) because alarm clock
      //       registers have an extra bit to indicate alarm frequency

      /* First grab the seconds. Upper half holds the 10's of seconds       */
      lower      = state [timeReg++];
      upper      = ( byte ) ((lower >>> 4) & 0x07);
      lower      = ( byte ) (lower & 0x0f);
      result [0] = ( int ) lower + ( int ) upper * 10;

      /* now grab minutes. The upper half holds the 10s of minutes          */
      lower      = state [timeReg++];
      upper      = ( byte ) ((lower >>> 4) & 0x07);
      lower      = ( byte ) (lower & 0x0f);