Revision 4:5213bee8158e, committed 2014-04-14

Comitter:

redplam

Date:

Mon Apr 14 02:15:32 2014 +0000

Parent:

3:0ef2ced1f02d

Commit message:

myproject;

Changed in this revision

diff -r 0ef2ced1f02d -r 5213bee8158e DS18B20Multiple/DS18B20.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DS18B20Multiple/DS18B20.cpp	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,103 @@
+/*
+* DS18B20. Maxim DS18B20 One-Wire Thermometer. 
+* Uses the OneWireCRC library.
+*
+* Copyright (C) <2010> Petras Saduikis <petras@petras.co.uk>
+*
+* This file is part of OneWireThermometer.
+*
+* OneWireThermometer is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+* 
+* OneWireThermometer is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with OneWireThermometer.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "DS18B20.h"
+//#include "DebugTrace.h"
+
+//DebugTrace pc_ds18B20(OFF, TO_SERIAL);
+
+DS18B20::DS18B20( PinName pin) : 
+    OneWireThermometer(pin, DS18B20_ID)
+{
+}
+
+void DS18B20::setResolution(eResolution resln)
+{
+    // as the write to the configuration register involves a write to the
+    // high and low alarm bytes, need to read these registers first
+    // and copy them back on the write
+    
+    BYTE read_data[THERMOM_SCRATCHPAD_SIZE];
+    BYTE write_data[ALARM_CONFIG_SIZE];
+    
+    if (readAndValidateData(read_data))
+    {
+        // copy alarm and config data to write data
+        for (int k = 2; k < 5; k++)
+        {
+            write_data[k - 2] = read_data[k];
+        }
+        int config = write_data[2];
+        config &= 0x9F;
+        config ^= (resln << 5);
+        write_data[2] = config;
+        
+        resetAndAddress();
+        oneWire.writeByte(WRITESCRATCH);
+        for (int k = 0; k < 3; k++)
+        {
+            oneWire.writeByte(write_data[k]);
+        }
+        
+        // remember it so we can use the correct delay in reading the temperature
+        // for parasitic power
+        resolution = resln; 
+    }
+}
+
+float DS18B20::calculateTemperature(BYTE* data)
+{
+    bool signBit = false;
+    if (data[TEMPERATURE_MSB] & 0x80) signBit = true;
+        
+    int read_temp = (data[TEMPERATURE_MSB] << 8) + data[TEMPERATURE_LSB];
+    if (signBit)
+    {
+        read_temp = (read_temp ^ 0xFFFF) + 1;    // two's complement
+        read_temp *= -1;
+    }
+    
+    int resolution = (data[CONFIG_REG_BYTE] & 0x60) >> 5; // mask off bits 6,5 and move to 1,0
+    switch (resolution)
+    {
+        case nineBit:    // 0.5 deg C increments
+            read_temp &= 0xFFF8;                // bits 2,1,0 are undefined
+            //pc_ds18B20.traceOut("9 bit resolution ...\r\n");
+            break;
+        case tenBit:     // 0.25 deg C increments
+            read_temp &= 0xFFFC;                // bits 1,0 are undefined
+            //pc_ds18B20.traceOut("10 bit resolution ...\r\n");
+            break;
+        case elevenBit:  // 0.125 deg C increments
+            read_temp &= 0xFFFE;                // bit 0 is undefined
+            //pc_ds18B20.traceOut("11 bit resolution ...\r\n");
+            break;
+        case twelveBit:  // 0.0625 deg C increments
+            //pc_ds18B20.traceOut("12 bit resolution ...\r\n");
+            break;
+    }
+    float realTemp = (float)read_temp/16 ;
+                 
+    //pc_ds18B20.traceOut("TEMP_READ/REAL TEMP: %f \r\n", realTemp); 
+               
+    return realTemp;
+}
\ No newline at end of file

diff -r 0ef2ced1f02d -r 5213bee8158e DS18B20Multiple/DS18B20.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DS18B20Multiple/DS18B20.h	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,41 @@
+/*
+* DS18B20. Maxim DS18B20 One-Wire Thermometer. 
+* Uses the OneWireCRC library.
+*
+* Copyright (C) <2010> Petras Saduikis <petras@petras.co.uk>
+*
+* This file is part of OneWireThermometer.
+*
+* OneWireThermometer is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+* 
+* OneWireThermometer is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with OneWireThermometer.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef SNATCH59_DS18B20_H
+#define SNATCH59_DS18B20_H
+
+#include "OneWireThermometer.h"
+#include "OneWireDefs.h"
+
+class DS18B20 : public OneWireThermometer
+{
+public:
+    DS18B20( PinName pin);
+    
+    virtual void setResolution(eResolution resln);
+    
+protected:
+    virtual float calculateTemperature(BYTE* data);
+};
+
+
+#endif
\ No newline at end of file

diff -r 0ef2ced1f02d -r 5213bee8158e DS18B20Multiple/OneWireCRC.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DS18B20Multiple/OneWireCRC.cpp	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,459 @@
+/*
+* OneWireCRC. This is a port to mbed of Jim Studt's Adruino One Wire
+* library. Please see additional copyrights below this one, including
+* references to other copyrights.
+*
+* Copyright (C) <2009> Petras Saduikis <petras@petras.co.uk>
+*
+* This file is part of OneWireCRC.
+*
+* OneWireCRC is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+* 
+* OneWireCRC is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with OneWireCRC.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*
+Copyright (c) 2007, Jim Studt
+
+Updated to work with arduino-0008 and to include skip() as of
+2007/07/06. --RJL20
+
+Modified to calculate the 8-bit CRC directly, avoiding the need for
+the 256-byte lookup table to be loaded in RAM.  Tested in arduino-0010
+-- Tom Pollard, Jan 23, 2008
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Much of the code was inspired by Derek Yerger's code, though I don't
+think much of that remains.  In any event that was..
+    (copyleft) 2006 by Derek Yerger - Free to distribute freely.
+
+The CRC code was excerpted and inspired by the Dallas Semiconductor 
+sample code bearing this copyright.
+//---------------------------------------------------------------------------
+// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY,  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES
+// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+// Except as contained in this notice, the name of Dallas Semiconductor
+// shall not be used except as stated in the Dallas Semiconductor
+// Branding Policy.
+//--------------------------------------------------------------------------
+*/
+
+#include "OneWireCRC.h"
+#include "OneWireDefs.h"
+
+// recommended data sheet timings in micro seconds
+const int standardT[] = {6, 64, 60, 10, 9, 55, 0, 480, 70, 410};
+const int overdriveT[] = {1.5, 7.5, 7.5, 2.5, 0.75, 7, 2.5, 70, 8.5, 40};
+
+OneWireCRC::OneWireCRC(PinName oneWire, eSpeed speed) : oneWirePort(oneWire)
+{
+    if (STANDARD == speed) timing = standardT;   
+    else  timing = overdriveT;  // overdrive
+    
+    resetSearch();    // reset address search state
+}
+
+// Generate a 1-wire reset, return 1 if no presence detect was found,
+// return 0 otherwise.
+// (NOTE: does not handle alarm presence from DS2404/DS1994)
+int OneWireCRC::reset() 
+{
+    
+    BYTE result = 0;    // sample presence pulse result
+        
+    wait_us(timing[6]);
+    oneWirePort.output();
+    oneWirePort = 0;
+    wait_us(timing[7]);
+    oneWirePort.input();
+    wait_us(timing[8]);
+    result = !(oneWirePort & 0x01);
+    wait_us(timing[9]);
+    
+    return result;
+}
+
+//
+// Write a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+void OneWireCRC::writeBit(int bit)
+{
+    bit = bit & 0x01;
+    
+    if (bit)
+    {
+        // Write '1' bit
+        oneWirePort.output();
+        oneWirePort = 0;
+        wait_us(timing[0]);
+        oneWirePort.input();
+        wait_us(timing[1]);
+    }
+    else
+    {
+        // Write '0' bit
+        oneWirePort.output();
+        oneWirePort = 0;
+        wait_us(timing[2]);
+        oneWirePort.input();
+        wait_us(timing[3]);
+    }
+}
+
+//
+// Read a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+int OneWireCRC::readBit() 
+{
+    BYTE result;
+    
+    oneWirePort.output();
+    oneWirePort = 0;
+    wait_us(timing[0]);
+    oneWirePort.input();
+    wait_us(timing[4]);
+    result = oneWirePort & 0x01;
+    wait_us(timing[5]);
+       
+    return result;
+}
+
+//
+// Write a byte. The writing code uses the active drivers to raise the
+// pin high, if you need power after the write (e.g. DS18S20 in
+// parasite power mode) then set 'power' to 1, otherwise the pin will
+// go tri-state at the end of the write to avoid heating in a short or
+// other mishap.
+//
+void OneWireCRC::writeByte(int data) 
+{
+    // Loop to write each bit in the byte, LS-bit first
+    for (int loop = 0; loop < 8; loop++)
+    {
+        writeBit(data & 0x01);
+        
+        // shift the data byte for the next bit
+        data >>= 1;
+    }
+}
+
+//
+// Read a byte
+//
+int OneWireCRC::readByte() 
+{
+    int result = 0;
+    
+    for (int loop = 0; loop < 8; loop++)
+    {
+        // shift the result to get it ready for the next bit
+        result >>= 1;
+        
+        // if result is one, then set MS bit
+        if (readBit()) result |= 0x80;
+    }
+    
+    return result;
+}
+
+int OneWireCRC::touchByte(int data)
+{
+    int result = 0;
+    
+    for (int loop = 0; loop < 8; loop++)
+    {
+        // shift the result to get it ready for the next bit
+        result >>= 1;
+        
+        // If sending a '1' then read a bit else write a '0'
+        if (data & 0x01)
+        {
+            if (readBit()) result |= 0x80;
+        }
+        else writeBit(0);
+        
+        // shift the data byte for the next bit
+        data >>= 1;
+    }
+    
+    return result;
+}
+
+void OneWireCRC::block(BYTE* data, int data_len)
+{
+    for (int loop = 0; loop < data_len; loop++)
+    {
+        data[loop] = touchByte(data[loop]);
+    }
+}
+
+int OneWireCRC::overdriveSkip(BYTE* data, int data_len)
+{
+    // set the speed to 'standard'
+    timing = standardT;
+    
+    // reset all devices
+    if (reset()) return 0;    // if no devices found
+    
+    // overdrive skip command
+    writeByte(OVERDRIVE_SKIP);
+    
+    // set the speed to 'overdrive'
+    timing = overdriveT;
+    
+    // do a 1-Wire reset in 'overdrive' and return presence result
+    return reset();
+}
+
+//
+// Do a ROM select
+//
+void OneWireCRC::matchROM(BYTE rom[8])
+{
+    writeByte(MATCH_ROM);         // Choose ROM
+
+    for(int i = 0; i < 8; i++) writeByte(rom[i]);
+}
+
+//
+// Do a ROM skip
+//
+void OneWireCRC::skipROM()
+{
+    writeByte(SKIP_ROM);         // Skip ROM
+}
+
+//
+// You need to use this function to start a search again from the beginning.
+// You do not need to do it for the first search, though you could.
+//
+void OneWireCRC::resetSearch()
+{
+    searchJunction = -1;
+    searchExhausted = false;
+    for (int i = 0; i < 8; i++) 
+    {
+        address[i] = 0;
+    }
+}
+
+//
+// Perform a search. If this function returns a '1' then it has
+// enumerated the next device and you may retrieve the ROM from the
+// OneWire::address variable. If there are no devices, no further
+// devices, or something horrible happens in the middle of the
+// enumeration then a 0 is returned.  If a new device is found then
+// its address is copied to newAddr.  Use OneWire::reset_search() to
+// start over.
+// 
+BYTE OneWireCRC::search(BYTE* newAddr)
+{
+    BYTE i;
+    int lastJunction = -1;
+    BYTE done = 1;
+    
+    if (searchExhausted) return 0;
+    
+    if (!reset()) return 0;
+
+    writeByte(SEARCH_ROM);
+    
+    for(i = 0; i < 64; i++) 
+    {
+        BYTE a = readBit( );
+        BYTE nota = readBit( );
+        BYTE ibyte = i/8;
+        BYTE ibit = 1 << (i & 7);
+    
+        // I don't think this should happen, this means nothing responded, but maybe if
+        // something vanishes during the search it will come up.
+        if (a && nota) return 0;  
+        
+        if (!a && !nota)
+        {
+            if (i == searchJunction) 
+            {
+                // this is our time to decide differently, we went zero last time, go one.
+                a = 1;
+                searchJunction = lastJunction;
+            } 
+            else if (i < searchJunction) 
+            {
+                // take whatever we took last time, look in address
+                if (address[ibyte] & ibit) a = 1;
+                else 
+                {
+                    // Only 0s count as pending junctions, we've already exhasuted the 0 side of 1s
+                    a = 0;
+                    done = 0;
+                    lastJunction = i;
+                }
+            } 
+            else 
+            {
+                // we are blazing new tree, take the 0
+                a = 0;
+                searchJunction = i;
+                done = 0;
+            }
+            lastJunction = i;
+        }
+        
+        if (a) address[ibyte] |= ibit;
+        else address[ibyte] &= ~ibit;
+    
+        writeBit(a);
+    }
+    
+    if (done) searchExhausted = true;
+    
+    for (i = 0; i < 8; i++) newAddr[i] = address[i];
+    
+    return 1;  
+}
+
+// The 1-Wire CRC scheme is described in Maxim Application Note 27:
+// "Understanding and Using Cyclic Redundancy Checks with Maxim iButton Products"
+//
+
+#if ONEWIRE_CRC8_TABLE
+// This table comes from Dallas sample code where it is freely reusable, 
+// though Copyright (C) 2000 Dallas Semiconductor Corporation
+static BYTE dscrc_table[] = 
+{
+      0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
+    157,195, 33,127,252,162, 64, 30, 95,  1,227,189, 62, 96,130,220,
+     35,125,159,193, 66, 28,254,160,225,191, 93,  3,128,222, 60, 98,
+    190,224,  2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
+     70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89,  7,
+    219,133,103, 57,186,228,  6, 88, 25, 71,165,251,120, 38,196,154,
+    101, 59,217,135,  4, 90,184,230,167,249, 27, 69,198,152,122, 36,
+    248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91,  5,231,185,
+    140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
+     17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
+    175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
+     50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
+    202,148,118, 40,171,245, 23, 73,  8, 86,180,234,105, 55,213,139,
+     87,  9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
+    233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
+    116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};
+
+//
+// Compute a Dallas Semiconductor 8 bit CRC. These show up in the ROM
+// and the registers.  (note: this might better be done without the
+// table, it would probably be smaller and certainly fast enough
+// compared to all those delayMicrosecond() calls.  But I got
+// confused, so I use this table from the examples.)  
+//
+BYTE OneWireCRC::crc8(BYTE* addr, BYTE len)
+{
+    BYTE i;
+    BYTE crc = 0;
+    
+    for (i = 0; i < len; i++)
+    {
+        crc  = dscrc_table[crc ^ addr[i] ];
+    }
+    
+    return crc;
+}
+#else
+//
+// Compute a Dallas Semiconductor 8 bit CRC directly. 
+//
+BYTE OneWireCRC::crc8(BYTE* addr, BYTE len)
+{
+    BYTE i, j;
+    BYTE crc = 0;
+    
+    for (i = 0; i < len; i++) 
+    {
+        BYTE inbyte = addr[i];
+        for (j = 0; j < 8; j++) 
+        {
+            BYTE mix = (crc ^ inbyte) & 0x01;
+            crc >>= 1;
+            if (mix) crc ^= 0x8C;
+            inbyte >>= 1;
+        }
+    }
+    
+    return crc;
+}
+#endif
+
+static short oddparity[16] = { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
+
+//
+// Compute a Dallas Semiconductor 16 bit CRC. I have never seen one of
+// these, but here it is.
+//
+unsigned short OneWireCRC::crc16(unsigned short* data, unsigned short len)
+{
+    unsigned short i;
+    unsigned short crc = 0;
+    
+    for ( i = 0; i < len; i++) 
+    {
+        unsigned short cdata = data[len];
+    
+        cdata = (cdata ^ (crc & 0xff)) & 0xff;
+        crc >>= 8;
+    
+        if (oddparity[cdata & 0xf] ^ oddparity[cdata >> 4]) crc ^= 0xc001;
+    
+        cdata <<= 6;
+        crc ^= cdata;
+        cdata <<= 1;
+        crc ^= cdata;
+    }
+    
+    return crc;
+}
+

diff -r 0ef2ced1f02d -r 5213bee8158e DS18B20Multiple/OneWireCRC.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DS18B20Multiple/OneWireCRC.h	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,138 @@
+/*
+* OneWireCRC. This is a port to mbed of Jim Studt's Adruino One Wire
+* library. Please see additional copyrights below this one, including
+* references to other copyrights.
+*
+* Copyright (C) <2009> Petras Saduikis <petras@petras.co.uk>
+*
+* This file is part of OneWireCRC.
+*
+* OneWireCRC is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+* 
+* OneWireCRC is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with OneWireCRC.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*
+Copyright (c) 2007, Jim Studt
+
+Updated to work with arduino-0008 and to include skip() as of
+2007/07/06. --RJL20
+
+Modified to calculate the 8-bit CRC directly, avoiding the need for
+the 256-byte lookup table to be loaded in RAM.  Tested in arduino-0010
+-- Tom Pollard, Jan 23, 2008
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Much of the code was inspired by Derek Yerger's code, though I don't
+think much of that remains.  In any event that was..
+    (copyleft) 2006 by Derek Yerger - Free to distribute freely.
+
+The CRC code was excerpted and inspired by the Dallas Semiconductor 
+sample code bearing this copyright.
+*/
+//---------------------------------------------------------------------------
+// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY,  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES
+// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+// Except as contained in this notice, the name of Dallas Semiconductor
+// shall not be used except as stated in the Dallas Semiconductor
+// Branding Policy.
+//--------------------------------------------------------------------------
+
+#ifndef SNATCH59_ONEWIRECRC_H
+#define SNATCH59_ONEWIRECRC_H
+
+#include <mbed.h>
+
+// Select the table-lookup method of computing the 8-bit CRC by setting this to 1
+#ifndef ONEWIRE_CRC8_TABLE
+#define ONEWIRE_CRC8_TABLE 1
+#endif
+
+typedef unsigned char BYTE;    // used to be uint8_t : something a byte wide, whatever ....
+
+enum eSpeed {OVERDRIVE, STANDARD};
+
+class OneWireCRC
+{
+public:
+    OneWireCRC(PinName oneWire, eSpeed);
+    
+    // reset, read, write functions
+    int reset();
+    void writeByte(int data);
+    int readByte();
+    int touchByte(int data);
+    void block(BYTE* data, int data_len);
+    int overdriveSkip(BYTE* data, int data_len);
+    
+    // address functions
+    void matchROM(BYTE rom[8]);
+    void skipROM();
+
+    // address search functions
+    void resetSearch();
+    BYTE search(BYTE* newAddr);
+
+    // CRC check functions
+    static BYTE crc8(BYTE* addr, BYTE len);
+    static unsigned short crc16(unsigned short* data, unsigned short len);
+
+private:
+    const int* timing;
+    
+    BYTE address[8];
+    int searchJunction;        // so we can set to it -1 somewhere
+    bool searchExhausted;
+    
+    DigitalInOut oneWirePort;
+    
+    // read/write bit functions
+    void writeBit(int bit);
+    int readBit();
+};
+
+#endif

diff -r 0ef2ced1f02d -r 5213bee8158e DS18B20Multiple/OneWireDefs.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DS18B20Multiple/OneWireDefs.h	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,66 @@
+/*
+* OneWireCRC. This is a port to mbed of Jim Studt's Adruino One Wire
+* library.
+*
+* Copyright (C) <2009> Petras Saduikis <petras@petras.co.uk>
+*
+* This file is part of OneWireCRC.
+*
+* OneWireCRC is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+* 
+* OneWireCRC is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with OneWireCRC.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef SNATCH59_ONEWIREDEFS_H
+#define SNATCH59_ONEWIREDEFS_H
+
+// device ids
+#define DS18B20_ID        0x28
+#define DS18S20_ID        0x10
+
+#define ALARM_CONFIG_SIZE 3
+#define THERMOM_SCRATCHPAD_SIZE    9
+#define THERMOM_CRC_BYTE  8
+#define ADDRESS_SIZE      8
+#define ADDRESS_CRC_BYTE  7
+
+// One Wire command codes
+#define OVERDRIVE_SKIP    0x3C
+// ROM commands
+#define SEARCH_ROM        0xF0
+#define READ_ROM          0x33
+#define MATCH_ROM         0x55
+#define SKIP_ROM          0xCC
+#define ALARM_SEARCH      0xEC
+// Functions Commnds
+#define CONVERT           0x44
+#define WRITESCRATCH      0x4E
+#define READSCRATCH       0xBE
+#define COPYSCRATCH       0x48
+#define RECALLE2          0xB8
+#define READPOWERSUPPLY   0xB4
+
+// temperature read resolutions
+enum eResolution {nineBit = 0, tenBit, elevenBit, twelveBit};
+const int CONVERSION_TIME[] = {94, 188, 375, 750};    // milli-seconds
+
+// DS18B20/DS18S20 related
+#define TEMPERATURE_LSB    0
+#define TEMPERATURE_MSB    1
+#define HIGH_ALARM_BYTE    2
+#define LOW_ALARM_BYTE     3
+#define CONFIG_REG_BYTE    4
+#define CONFIG_READ_END    5
+#define COUNT_REMAIN_BYTE  6
+#define COUNT_PER_DEG_BYTE 7
+
+#endif

diff -r 0ef2ced1f02d -r 5213bee8158e DS18B20Multiple/OneWireThermometer.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DS18B20Multiple/OneWireThermometer.cpp	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,154 @@
+/*
+* OneWireThermometer. Base class for Maxim One-Wire Thermometers. 
+* Uses the OneWireCRC library.
+*
+* Copyright (C) <2010> Petras Saduikis <petras@petras.co.uk>
+*
+* This file is part of OneWireThermometer.
+*
+* OneWireThermometer is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+* 
+* OneWireThermometer is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with OneWireThermometer.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "OneWireThermometer.h"
+#include "OneWireDefs.h"
+//#include "DebugTrace.h"
+
+//DebugTrace pc(OFF, TO_SERIAL);
+
+// constructor specifies standard speed for the 1-Wire comms
+// Used to have params for CRCon and useAddress, can't see why you wouldn't use CRC and you have to use address since there could be more than one.
+OneWireThermometer::OneWireThermometer(PinName pin, int device_id) :
+    oneWire(pin, STANDARD), deviceId(device_id), resolution(twelveBit)
+{
+    // NOTE: the power-up resolution of a DS18B20 is 12 bits. The DS18S20's resolution is always
+    // 9 bits + enhancement, but we treat the DS18S20 as fixed to 12 bits for calculating the
+    // conversion time Tconv.
+    deviceCount = 0;
+}
+
+bool OneWireThermometer::initialize()
+{
+    // get all the device addresses for use in selectROM() when reading the temperature
+   // pc.traceOut("\r\n");
+    //pc.traceOut("New Scan\r\n");
+
+    oneWire.resetSearch();    
+    while (oneWire.search(address))   // search for 1-wire device address
+    {
+        //pc.traceOut("Address = ");
+        for (int i = 0; i < ADDRESS_SIZE; i++) 
+        {
+            //pc.traceOut("%x ", (int)address[i]);
+            devices[deviceCount][i] = address[i];
+        }
+        //pc.traceOut("\r\n");
+        deviceCount++;
+    }
+    
+    if (OneWireCRC::crc8(address, ADDRESS_CRC_BYTE) != address[ADDRESS_CRC_BYTE])   // check address CRC is valid
+    {
+        //pc.traceOut("CRC is not valid!\r\n");
+        wait(2);
+        return false;
+    }
+
+    if (address[0] != deviceId)
+    {                    
+        // Make sure it is a one-wire thermometer device
+        if (DS18B20_ID == deviceId){}
+            //pc.traceOut("You need to use a DS1820 or DS18S20 for correct results.\r\n");
+        else if (DS18S20_ID == deviceId){}
+            //pc.traceOut("You need to use a DS18B20 for correct results.\r\n");
+        else{}
+         // pc.traceOut("Device is not a DS18B20/DS1820/DS18S20 device.\r\n");
+        
+        wait(2);
+        return false;   
+    }
+    else
+    {
+        if (DS18B20_ID == deviceId){} //pc.traceOut("DS18B20 present and correct.\r\n");
+        if (DS18S20_ID == deviceId){} //pc.traceOut("DS1820/DS18S20 present and correct.\r\n");            
+    }
+    
+    return true;
+}
+
+// NOTE ON USING SKIP ROM: ok to use before a Convert command to get all
+// devices on the bus to do simultaneous temperature conversions. BUT can 
+// only use before a Read Scratchpad command if there is only one device on the
+// bus. For purpose of this library it is assumed there is only one device
+// on the bus.
+void OneWireThermometer::resetAndAddress()
+{
+    oneWire.reset();                // reset device 
+    oneWire.matchROM(address);  // select which device to talk to
+}
+
+bool OneWireThermometer::readAndValidateData(BYTE* data)
+{
+    bool dataOk = true;
+    
+    resetAndAddress();
+    oneWire.writeByte(READSCRATCH);    // read Scratchpad
+
+   // pc.traceOut("read = ");
+    for (int i = 0; i < THERMOM_SCRATCHPAD_SIZE; i++) 
+    {               
+        // we need all bytes which includes CRC check byte
+        data[i] = oneWire.readByte();
+       // pc.traceOut("%x ", (int)data[i]);
+    }
+    //pc.traceOut("\r\n");
+
+    // Check CRC is valid
+    if (!(OneWireCRC::crc8(data, THERMOM_CRC_BYTE) == data[THERMOM_CRC_BYTE]))  
+    {  
+        // CRC failed
+       // pc.traceOut("CRC FAILED... \r\n");
+        dataOk = false;
+    }
+    
+    return dataOk;
+}
+
+float OneWireThermometer::readTemperature(int device)
+{
+    BYTE data[THERMOM_SCRATCHPAD_SIZE];
+    float realTemp = -999;
+
+    // need to select which device here.
+    for (int i = 0; i < ADDRESS_SIZE; i++) 
+    {
+        address[i] = devices[device][i];
+    }
+
+    resetAndAddress();
+    oneWire.writeByte(CONVERT);     // issue Convert command
+    
+    // Removed the check for parasitic power, since we waited the same time anyway.
+    wait_ms(CONVERSION_TIME[resolution]);
+
+    if (readAndValidateData(data))    // issue Read Scratchpad commmand and get data
+    {
+        realTemp = calculateTemperature(data);
+    }
+    
+    return realTemp; 
+}
+
+int OneWireThermometer::getDeviceCount()
+{
+    return deviceCount;
+}
\ No newline at end of file

diff -r 0ef2ced1f02d -r 5213bee8158e DS18B20Multiple/OneWireThermometer.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DS18B20Multiple/OneWireThermometer.h	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,57 @@
+/*
+* OneWireThermometer. Base class for Maxim One-Wire Thermometers. 
+* Uses the OneWireCRC library.
+*
+* Copyright (C) <2010> Petras Saduikis <petras@petras.co.uk>
+*
+* This file is part of OneWireThermometer.
+*
+* OneWireThermometer is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+* 
+* OneWireThermometer is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with OneWireThermometer.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef SNATCH59_ONEWIRETHERMOMETER_H
+#define SNATCH59_ONEWIRETHERMOMETER_H
+
+#include <mbed.h>
+#include "OneWireCRC.h"
+#include "OneWireDefs.h"
+
+typedef unsigned char BYTE;    // something a byte wide
+typedef unsigned char DEVADDRESS[8];   // stores the address of one device
+
+class OneWireThermometer
+{
+public:
+    OneWireThermometer(PinName pin, int device_id);
+    
+    bool initialize();
+    float readTemperature(int device);
+    virtual void setResolution(eResolution resln) = 0; 
+    int getDeviceCount();
+
+protected:
+    OneWireCRC oneWire;
+    const int deviceId;
+    
+    eResolution resolution; 
+    BYTE address[8];
+    DEVADDRESS devices[10];
+    int deviceCount;
+   
+    void resetAndAddress();
+    bool readAndValidateData(BYTE* data);
+    virtual float calculateTemperature(BYTE* data) = 0;    // device specific
+};
+
+#endif
\ No newline at end of file

diff -r 0ef2ced1f02d -r 5213bee8158e SEN11301P/DHT.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SEN11301P/DHT.cpp	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,201 @@
+
+#include "DHT.h"
+
+#define DHT_DATA_BIT_COUNT 40
+
+DHT::DHT(PinName pin,int DHTtype) {
+    _pin = pin;
+    _DHTtype = DHTtype;
+    _firsttime=true;
+}
+
+DHT::~DHT() {
+}
+
+int DHT::readData() {
+    int i, j, retryCount,b;
+    unsigned int bitTimes[DHT_DATA_BIT_COUNT];
+
+    eError err = ERROR_NONE;
+    time_t currentTime = time(NULL);
+
+    DigitalInOut DHT_io(_pin);
+
+    for (i = 0; i < DHT_DATA_BIT_COUNT; i++) {
+        bitTimes[i] = 0;
+    }
+
+    if (!_firsttime) {
+        if (int(currentTime - _lastReadTime) < 2) {
+            err = ERROR_NO_PATIENCE;
+            return err;
+        }
+    } else {
+        _firsttime=false;
+        _lastReadTime=currentTime;
+    }
+    retryCount = 0;
+
+    do {
+        if (retryCount > 125) {
+            err = BUS_BUSY;
+            return err;
+        }
+        retryCount ++;
+        wait_us(2);
+    } while ((DHT_io==0));
+
+
+    DHT_io.output();
+    DHT_io = 0;
+    wait_ms(18);
+    DHT_io = 1;
+    wait_us(40);
+    DHT_io.input();
+
+    retryCount = 0;
+    do {
+        if (retryCount > 40)  {
+            err = ERROR_NOT_PRESENT;
+            return err;
+        }
+        retryCount++;
+        wait_us(1);
+    } while ((DHT_io==1));
+
+    if (err != ERROR_NONE) {
+        return err;
+    }
+
+    wait_us(80);
+
+    for (i = 0; i < 5; i++) {
+        for (j = 0; j < 8; j++) {
+
+            retryCount = 0;
+            do {
+                if (retryCount > 75)  {
+                    err = ERROR_DATA_TIMEOUT;
+                    return err;
+                }
+                retryCount++;
+                wait_us(1);
+            } while (DHT_io == 0);
+            wait_us(40);
+            bitTimes[i*8+j]=DHT_io;
+
+            int count = 0;
+            while (DHT_io == 1 && count < 100) {
+                wait_us(1);
+                count++;
+            }
+        }
+    }
+    DHT_io.output();
+    DHT_io = 1;
+    for (i = 0; i < 5; i++) {
+        b=0;
+        for (j=0; j<8; j++) {
+            if (bitTimes[i*8+j+1] > 0) {
+                b |= ( 1 << (7-j));
+            }
+        }
+        DHT_data[i]=b;
+    }
+
+    //if (DHT_data[4] == ((DHT_data[0] + DHT_data[1] + DHT_data[2] + DHT_data[3]) & 0xFF)) {
+        _lastReadTime = currentTime;
+        _lastTemperature=CalcTemperature();
+        _lastHumidity=CalcHumidity();
+
+    //} else {
+       // err = ERROR_CHECKSUM;
+    //}
+
+    return err;
+
+}
+
+float DHT::CalcTemperature() {
+    int v;
+
+    switch (_DHTtype) {
+        case DHT11:
+            v = DHT_data[2];
+            return float(v);
+        case DHT22:
+            v = DHT_data[2] & 0x7F;
+            v *= 256;
+            v += DHT_data[3];
+            v /= 10;
+            if (DHT_data[2] & 0x80)
+                v *= -1;
+            return float(v);
+    }
+    return 0;
+}
+
+float DHT::ReadHumidity() {
+    return _lastHumidity;
+}
+
+float DHT::ConvertCelciustoFarenheit(float celsius) {
+    return celsius * 9 / 5 + 32;
+}
+
+float DHT::ConvertCelciustoKelvin(float celsius) {
+    return celsius + 273.15;
+}
+
+// dewPoint function NOAA
+// reference: http://wahiduddin.net/calc/density_algorithms.htm
+float DHT::CalcdewPoint(float celsius, float humidity) {
+    float A0= 373.15/(273.15 + celsius);
+    float SUM = -7.90298 * (A0-1);
+    SUM += 5.02808 * log10(A0);
+    SUM += -1.3816e-7 * (pow(10, (11.344*(1-1/A0)))-1) ;
+    SUM += 8.1328e-3 * (pow(10,(-3.49149*(A0-1)))-1) ;
+    SUM += log10(1013.246);
+    float VP = pow(10, SUM-3) * humidity;
+    float T = log(VP/0.61078);   // temp var
+    return (241.88 * T) / (17.558-T);
+}
+
+// delta max = 0.6544 wrt dewPoint()
+// 5x faster than dewPoint()
+// reference: http://en.wikipedia.org/wiki/Dew_point
+float DHT::CalcdewPointFast(float celsius, float humidity)
+{
+        float a = 17.271;
+        float b = 237.7;
+        float temp = (a * celsius) / (b + celsius) + log(humidity/100);
+        float Td = (b * temp) / (a - temp);
+        return Td;
+}
+
+float DHT::ReadTemperature(eScale Scale) {
+    if (Scale == FARENHEIT)
+        return ConvertCelciustoFarenheit(_lastTemperature);
+    else if (Scale == KELVIN)
+        return ConvertCelciustoKelvin(_lastTemperature);
+    else
+        return _lastTemperature;
+}
+
+float DHT::CalcHumidity() {
+    int v;
+
+    switch (_DHTtype) {
+        case DHT11:
+            v = DHT_data[0];
+            return float(v);
+        case DHT22:
+            v = DHT_data[0];
+            v *= 256;
+            v += DHT_data[1];
+            v /= 10;
+            return float(v);
+    }
+    return 0;
+}
+

diff -r 0ef2ced1f02d -r 5213bee8158e SEN11301P/DHT.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SEN11301P/DHT.h	Mon Apr 14 02:15:32 2014 +0000
@@ -0,0 +1,63 @@
+
+#ifndef MBED_DHT_H
+#define MBED_DHT_H
+
+#include "mbed.h"
+
+enum eType{
+        DHT11     = 11,
+        SEN11301P = 11,
+        RHT01     = 11,
+        DHT22     = 22,
+        AM2302    = 22,
+        SEN51035P = 22,
+        RHT02     = 22,
+        RHT03     = 22
+    } ;
+
+enum eError {
+    ERROR_NONE = 0,
+    BUS_BUSY =1,
+    ERROR_NOT_PRESENT =2 ,
+    ERROR_ACK_TOO_LONG =3 ,
+    ERROR_SYNC_TIMEOUT = 4,
+    ERROR_DATA_TIMEOUT =5 ,
+    ERROR_CHECKSUM = 6,
+    ERROR_NO_PATIENCE =7
+} ;
+
+typedef enum {
+    CELCIUS =0 ,
+    FARENHEIT =1,
+    KELVIN=2
+} eScale;
+
+
+class DHT {
+
+public:
+
+    DHT(PinName pin,int DHTtype);
+    ~DHT();
+    int readData(void);
+    float ReadHumidity(void);
+    float ReadTemperature(eScale Scale);
+    float CalcdewPoint(float celsius, float humidity);
+    float CalcdewPointFast(float celsius, float humidity);
+
+private:
+    time_t  _lastReadTime;
+    float _lastTemperature;
+    float _lastHumidity;
+    PinName _pin;
+    bool _firsttime;
+    int _DHTtype;
+    int DHT_data[6];
+    float CalcTemperature();
+    float CalcHumidity();
+    float ConvertCelciustoFarenheit(float);
+    float ConvertCelciustoKelvin(float);
+
+};
+
+#endif

diff -r 0ef2ced1f02d -r 5213bee8158e ds18b20/DS18B20.cpp
--- a/ds18b20/DS18B20.cpp	Sat Apr 12 20:07:15 2014 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,71 +0,0 @@
-#include "DS18B20.h"
-#include "DS1Wire.h"
-#include "mbed.h"
-#include <stdint.h>
-
-// Device byte commands over 1-wire serial
-enum COMMANDS { READ_ROM = 0x33, CONVERT = 0x44, READ_SCRATCHPAD = 0xBE,  SKIP_ROM = 0xCC };
-
-// device onboard register layout
-typedef struct {
-    uint8_t    LSB;
-    uint8_t    MSB;
-    uint8_t    Th;
-    uint8_t    Tl;
-    uint8_t    config;
-    uint8_t    reserved0xFF;
-    uint8_t    reserved0xCH;
-    uint8_t    reserved0x10;
-    uint8_t    CRC;
-} ScratchPad_t;
-
-
-DigitalOut conversionInProgress(LED4);  // conversion in progress
-DigitalOut resetFailure(LED1);          // for error reporting
-extern DigitalInOut sensor;     // sensor pin
-
-static void inError() {
-    while (1) {
-        resetFailure = !resetFailure;
-        wait(0.2);
-    }
-}
-
-void DoConversion() {
-    if (Reset(sensor) != 0) {
-        inError();
-    } else {
-        conversionInProgress = 1;       // led on
-        WriteByte(sensor, SKIP_ROM);            // Skip ROM
-        WriteByte(sensor, CONVERT);             // Convert
-        while (ReadBit(sensor) == 0) {
-            // wait for conversion to complete
-        }
-        conversionInProgress = 0;       // led off
-    }
-}
-
-uint32_t GetTemperature() {
-    uint32_t result = 0;
-    if (Reset(sensor) != 0) {
-        inError();
-    } else {
-        ScratchPad_t scratchpad;
-        WriteByte(sensor, SKIP_ROM);    // Skip ROM
-        WriteByte(sensor, READ_SCRATCHPAD);    // Read Scrachpad
-        scratchpad.LSB = ReadByte(sensor);
-        scratchpad.MSB = ReadByte(sensor);
-        Reset(sensor);    // terminate read as we only want temperature
-        result = ((scratchpad.MSB << 8) | scratchpad.LSB);
-    }
-    return result;
-}
-float mytemp(void) {
-    DoConversion();
-    uint32_t temp = GetTemperature();
-    float f = (temp & 0x0F) * 0.0625;    // calculate .4 part
-    f += (temp >> 4);    // add 7.0 part to it
-    return f;
-    //s.printf("Temp is %2.1fC\n\r", f);    // display in 2.1 format
-}
-

diff -r 0ef2ced1f02d -r 5213bee8158e ds18b20/DS18B20.h
--- a/ds18b20/DS18B20.h	Sat Apr 12 20:07:15 2014 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,23 +0,0 @@
-#ifndef _DS18B20_
-#define _DS18B20_
-
-#include <stdint.h>
-#include "mbed.h"
-
-// Device Faimly ID and Setial number information
-typedef union {
-    uint8_t rom[8];
-    struct {
-        uint8_t    familyCode;
-        uint8_t    serialNo[6];
-        uint8_t    CRC;
-    } BYTES;
-} ROM_Code_t;
-
-ROM_Code_t ReadROM() ;
-
-// temperature is store as 7.4 fixed point format (assuming 12 bit conversion)
-void displayTemperature(Serial& s) ;
-float mytemp(void);
-
-#endif
\ No newline at end of file

diff -r 0ef2ced1f02d -r 5213bee8158e ds18b20/DS1Wire.cpp
--- a/ds18b20/DS1Wire.cpp	Sat Apr 12 20:07:15 2014 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-#include "DS1Wire.h"
-#include "mbed.h"
-#include <stdint.h>
-
-// Timing delay for 1-wire serial standard option
-enum DELAY { A = 6, B = 64, C = 60, D = 10, E = 9, F = 55, G = 0, H = 480, I = 70, J = 410 };
-
-   
-int Reset(DigitalInOut& pin) {
-    pin.output();
-    pin = 0;    // drive bus low
-    wait_us(H);
-    pin.input(); // release bus
-    wait_us(I);
-    uint32_t result = pin;  // read bus value
-    wait_us(J);
-    return result;
-}
-
-void WriteBit(DigitalInOut& pin, uint32_t bit) {
-    pin.output();
-    if (bit) {
-        pin = 0;        // drive bus low
-        wait_us(A);        // delay A
-        pin.input();      // release bus
-        wait_us(B);        // delay B
-    } else {
-        pin = 0;    // drive bus low
-        wait_us(C);    // delay C
-        pin.input();  // release bus
-        wait_us(D);    // delay D
-    }
-}
-
-uint32_t ReadBit(DigitalInOut& pin) {
-    uint32_t bit_value;
-    pin.output();
-    pin = 0;        // drive bus low
-    wait_us(A);        // delay A
-    pin.input();      // release bus
-    wait_us(E);        // delay E
-    bit_value  = pin;    // master sample bus
-    wait_us(F);
-    return bit_value;
-}
-
-void WriteByte(DigitalInOut& pin, uint32_t byte) {
-    for (uint32_t bit = 0; bit < 8; ++bit) {
-        WriteBit(pin, byte & 0x01); // lsb to msb
-        byte >>= 1;    // right shift by 1-bit
-    }
-}
-
-uint32_t ReadByte(DigitalInOut& pin) {
-    uint32_t byte = 0;
-    for (uint32_t bit = 0; bit < 8; ++bit) {
-        byte |= (ReadBit(pin) << bit);    // Reads lsb to msb
-    }
-    return byte;
-}
\ No newline at end of file

diff -r 0ef2ced1f02d -r 5213bee8158e ds18b20/DS1Wire.h
--- a/ds18b20/DS1Wire.h	Sat Apr 12 20:07:15 2014 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,15 +0,0 @@
-#ifndef __DS_1_WIRE__
-#define __DS_1_WIRE__
-#include <stdint.h>
-#include "mbed.h"
-
-int Reset(DigitalInOut& pin);
-
-void WriteBit(DigitalInOut& pin, uint32_t bit);
-uint32_t ReadBit(DigitalInOut& pin);
-
-void WriteByte(DigitalInOut& pin, uint32_t byte);
-uint32_t ReadByte(DigitalInOut& pin);
-
-
-#endif
\ No newline at end of file

diff -r 0ef2ced1f02d -r 5213bee8158e main.cpp
--- a/main.cpp	Sat Apr 12 20:07:15 2014 +0000
+++ b/main.cpp	Mon Apr 14 02:15:32 2014 +0000
@@ -8,16 +8,19 @@
 #include "pumps_pindefs.h"
 #include "weight.h"
 #include "weight_pindefs.h"
+#include "DHT.h"
 
-Serial pc(USBTX, USBRX); // tx, rx
-DigitalOut te1(PTD7);
-DigitalOut te2(PTD6);
+DHT sensor(PTD3,SEN11301P); // Use the SEN11301P sensor
 
+//Serial pc(USBTX, USBRX); // tx, rx
+//DigitalOut te1(PTD7);
+DigitalOut backlight(PTD6);
+float desire_temp;
 
 /*
 AnalogIn ain(p19);
 DigitalOut led(LED1);
- 
+
 int main() {
     while (1){
         if(ain > 0.3) {
@@ -41,42 +44,77 @@
 
 }
 int main(void)
-{te1=1;
-te2=1;
-    while(1) {
-        read_weight();
-        calc_weight();
+{
+    backlight=1;
+    tempinit();
+    desire_temp=40;
+    /*te1=1;
+    te2=1;*/
+    //-------------------------
+    int err;
+    pc.printf("\r\nDHT Test program");
+    pc.printf("\r\n******************\r\n");
+    wait(1); // wait 1 second for device stable status
+    while (1) {
+        //  myled = 1;
+        err = sensor.readData();
+        if (err == 0) {
+            pc.printf("Temperature is %4.2f C \r\n",sensor.ReadTemperature(CELCIUS));
+            pc.printf("Humidity is %4.2f \r\n",sensor.ReadHumidity());
+            if (dsen_temp_in<desire_temp) {
+                peltier(true,true,false,true,90);
+            }
+            if (dsen_temp_in>=desire_temp) {
+                peltier(true,true,false,true,0);
+            }
+        } else
+            printf("\r\nErr %i \n",err);
 
-        
-        
-        
-        //peltier_auto(20);
-        //led_test();
+        wait(15);
+    }
+    //------------------------------
+    // while(1) {
+    /*     read_weight();
+         calc_weight();
+
+         */
+
 
-   // pc.printf("wait20");
-   /*
-    te2=1;
-    wait(1);
-     te1=0;
-    wait(10);
-        peltier(true,true,false,false,10);
-       te1=1;
-       wait(1);
-        te2=0;
-        wait(10);
-            peltier(true,true,false,false,10);*/
-            
-    wait(1);
-      /*  wait(10);
-        pumps(true,false,false,false);
-        wait(2);
-        pumps(false,true,true,false);
-        wait(2);
-        pumps(false,false,false,true);
-        wait(2);
-        pumps(false,false,false,false);
-        wait(20);*/
+    // peltier_auto(30);
+    //  led_test();
+
+    // pc.printf("wait20");
+    /*
+     te2=1;
+     wait(1);
+      te1=0;
+     wait(10);
+         peltier(true,true,false,false,10);
+        te1=1;
+        wait(1);
+         te2=0;
+         wait(10);
+             peltier(true,true,false,false,10);*/
 
-    }
+    //wait(1);
+    //void peltier(bool fan_in,bool fan_out,bool cold,bool hot,int pwm_procent);
+    /*   if (dsen_temp_in<desire_temp) {
+           peltier(true,true,false,true,90);
+       }
+       if (dsen_temp_in>=desire_temp) {
+           peltier(true,true,false,true,0);
+       }
+    */
+    /*  wait(10);
+      pumps(true,false,false,false);
+      wait(2);
+      pumps(false,true,true,false);
+      wait(2);
+      pumps(false,false,false,true);
+      wait(2);
+      pumps(false,false,false,false);
+      wait(20);*/
+
+    // }
 
 }

diff -r 0ef2ced1f02d -r 5213bee8158e peltier/peltier.cpp
--- a/peltier/peltier.cpp	Sat Apr 12 20:07:15 2014 +0000
+++ b/peltier/peltier.cpp	Mon Apr 14 02:15:32 2014 +0000
@@ -1,9 +1,23 @@
 #include "mbed.h"
 
 #include "TextLCD.h"
-#include "DS18B20.h"
+//#include "DS18B20.h"
 #include "peltier.h"
-//Serial pc(USBTX, USBRX); // tx, rx
+//----------------------------------
+#include "DS18B20.h"
+#include "OneWireDefs.h"
+
+#define THERMOMETER DS18B20
+
+float temp;
+float dsen_temp_in;
+float dsen_temp_out;
+// device( mbed pin )
+THERMOMETER device(PTE0);
+
+
+//-----------------------------------
+Serial pc(USBTX, USBRX); // tx, rx
 
 unsigned int peltier_hot_pulsewidth=1000;
 unsigned int peltier_cold_pulsewidth=1000;
@@ -17,7 +31,7 @@
 bool alarm_lo_temp_out=false;
 
 TextLCD lcd(PTE29, PTE30, PTC12, PTD0, PTD5, PTA13, TextLCD::LCD20x2);   // rs, e, d4-d7 ok
-
+//DigitalOut backlight(PTD6);
 //unsigned int peltier_hot_pulsewidth=1000;
 //unsigned int peltier_cold_pulsewidth=1000;
 //unsigned int peltier_period =1000;
@@ -29,6 +43,21 @@
 //bool alarm_lo_temp_out=false;
 float dsen_temp;
 
+void readTemp(int deviceNum)
+{
+    temp = device.readTemperature(deviceNum);
+    // pc.printf("Device %d is %f\n\r",deviceNum, temp);
+    wait(0.5);
+}
+void tempinit(void)
+{
+    while (!device.initialize());    // keep calling until it works
+
+    int deviceCount = device.getDeviceCount();
+    pc.printf("Found %d sensors\n\r",deviceCount);
+
+    device.setResolution(twelveBit);
+}
 unsigned int pwm_cold_peltier(int brightness )
 {
     if (brightness==1) {
@@ -55,8 +84,10 @@
 }
 void peltier(bool fan_in,bool fan_out,bool cold,bool hot,int pwm_procent)
 {
-    sensor.mode(PullUp);
-    dsen_temp=mytemp();
+    //tempinit();
+    //sensor.mode(PullUp);
+   // readTemp(1);
+   // dsen_temp_in=temp;
     //  ROM_Code_t ROM_Code = ReadROM();
     //  lcd.setCursor(TextLCD::CurOff_BlkOn);
     //  lcd.locate(0,0);
@@ -92,10 +123,15 @@
         peltier_hot_pulsewidth=pwm_procent*10;
         peltier_hot.pulsewidth_us(peltier_hot_pulsewidth);
     }
-    //pc.printf("Temp is %2.1fC,dsen temp= %d \n\r", dsen_temp,10);
-            lcd.cls();
-        lcd.locate(0,1);
-        lcd.printf("Temp is %2.1fC\n\r", dsen_temp);
+
+        readTemp(1);
+        dsen_temp_in=temp;
+        readTemp(0);
+        dsen_temp_out=temp;
+        pc.printf("inside Temp is %2.1fC, outside temp plate is %2.1fC\n\r", dsen_temp_in,dsen_temp_out);
+    lcd.cls();
+    lcd.locate(0,1);
+    lcd.printf("Temp is %2.1fC\n\r", dsen_temp_in);
 
 }
 void pel_c(int pwm)
@@ -111,27 +147,30 @@
     peltier_hot_pulsewidth=pwm*10;
     peltier_hot.pulsewidth_us(peltier_hot_pulsewidth);
 }
-void peltier_auto(int degree)
-{
-    sensor.mode(PullUp);
+void peltier_auto(float degree){
+//tempinit();
+
+   // backlight=1;
+
     en_drv1=1;
     en_drv2=1;
     fan_in_peltier=1;//enable
     fan_out_peltier=1;//enable
     while(1) {
 
-        dsen_temp=mytemp();
+        readTemp(1);
+        dsen_temp_in=temp;
 
-        if (degree>dsen_temp) {
+        /* (degree>dsen_temp) {
             pel_h(0);
-            pel_c(100);
-        }
-        if (degree<dsen_temp) {
+            pel_c(90);
+        }*/
+        if (degree<dsen_temp_in) {
             pel_c(0);
-            pel_h(100);
+            pel_h(90);
 
         }
-        if (degree==dsen_temp) {
+        if (degree==dsen_temp_in) {
             pel_c(0);
             pel_h(0);
 
@@ -139,8 +178,13 @@
 
         lcd.cls();
         lcd.locate(0,1);
-        //pc.printf("Temp is %2.1fC,dsen temp= %d \n\r", dsen_temp,degree);
-        lcd.printf("Temp is %2.1fC\n\r", dsen_temp);
+
+        readTemp(1);
+        dsen_temp_in=temp;
+        readTemp(0);
+        dsen_temp_out=temp;
+        pc.printf("Temp is %2.1fC,dsen temp= %2.1f , outchamber plate temp =%2.1fC\n\r", dsen_temp_in,degree,dsen_temp_out);
+        // lcd.printf("Temp is %2.1fC\n\r", dsen_temp);
 
 
 

diff -r 0ef2ced1f02d -r 5213bee8158e peltier/peltier.h
--- a/peltier/peltier.h	Sat Apr 12 20:07:15 2014 +0000
+++ b/peltier/peltier.h	Mon Apr 14 02:15:32 2014 +0000
@@ -1,4 +1,4 @@
-extern DigitalInOut sensor;                                              // sensor inside E0
+//extern DigitalInOut sensor;                                              // sensor inside E0
 extern PwmOut peltier_cold;
 extern PwmOut peltier_hot;
 extern DigitalOut en_drv1;
@@ -16,10 +16,14 @@
 extern bool alarm_lo_temp_in;
 extern bool alarm_hi_temp_out;
 extern bool alarm_lo_temp_out;
+extern float dsen_temp_in;
+extern float dsen_temp_out;
+extern Serial pc; // tx, rx
 
 unsigned int pwm_cold_peltier(int brightness );
 unsigned int pwm_hot_peltier(int brightness);
 
+void tempinit();
 void peltier(bool fan_in,bool fan_out,bool cold,bool hot,int pwm_procent);
-void peltier_auto(int degree);
+void peltier_auto(float degree);
 

diff -r 0ef2ced1f02d -r 5213bee8158e peltier/peltier_pindefs.h
--- a/peltier/peltier_pindefs.h	Sat Apr 12 20:07:15 2014 +0000
+++ b/peltier/peltier_pindefs.h	Mon Apr 14 02:15:32 2014 +0000
@@ -1,4 +1,4 @@
-DigitalInOut sensor(PTE0);                                              // sensor inside E0
+//DigitalInOut sensor(PTE1);                                              // sensor inside E0
 PwmOut peltier_cold(PTA12);
 PwmOut peltier_hot(PTA4);
 DigitalOut en_drv1(PTC13);