About kevinmkessler

Blogs about my Electronic projects

RHT22 / RHT03

Over the last year my Garduino project has morphed into more of simply a weather station.  While I still have plans to activate a water valve with the Arduino, my failure in creating a reliable moisture sensor has led me to more or less indirectly guess the soil moisture my measuring the temperature, rain, and humidity.

To measure the temperature and humidity, I’m using the RHT03 (referred to as an RHT22 and DHT-22 as well), available from Sparkfun, and on eBay.


RHT03 in breadboard connected to the Saleae Logic Analyzer

Most of my work on the RHT03 is based on the work of Craig Ringer and Nethoncho.   The RHT03 is a bit of an odd device, with kind of a non-standard signalling protocol.  All signalling is done over 1 data line, and the Arduino sets that signal line to an OUTPUT and pulls the line low for about 3ms, and then high for about 30us.  At that point, the Arduino sets the data line pin to an INPUT, and the RHT03 takes control of that pin; pulling the line low for 80us, then high for 80us, and then sending the temperature and humidity in a series of pulses.  High pulses of 26us represent a 0 and 80us represents a 1.  You can try to decipher the whole protocol by reading the datasheet, if you are not too picky about grammar (and if you are reading my blog, you must not be). The following is the code I am using:

#define RHT22_PIN 7
unsigned int temp;
unsigned int humidity;
void setup()
void loop()
 Serial.println("Reading sensor...");

 boolean success = readRHT03();
 if (success) {
   char buf[128];
   sprintf(buf, "Unit 1 Reading: %i.%i degrees C at %i.%i relative humidity", temp/10, abs(temp%10), humidity/10, humidity%10);
boolean readRHT03()
 unsigned int rht22_timings[88];


 pinMode(RHT22_PIN, OUTPUT);
 digitalWrite(RHT22_PIN, LOW);

 digitalWrite(RHT22_PIN, HIGH);
 pinMode(RHT22_PIN, INPUT);

 int state=digitalRead(RHT22_PIN);
 unsigned int counter=0;
 unsigned int signalLineChanges=0;
 while (counter!=0xffff)
     rht22_timings[signalLineChanges] = TCNT1;
 boolean errorFlag=false;
 if (signalLineChanges != 83)

 return !errorFlag;
void initRHT03()
 //for (int i = 0; i < 86; i++) { rht22_timings[i] = 0; }


// DEBUG routine: dump timings array to serial
void debugPrintTimings(unsigned int rht22_timings[]) { // XXX DEBUG
for (int i = 0; i < 88; i++) { // XXX DEBUG
 if (i%10==0) { Serial.print("\n\t"); }
 char buf[24];
 sprintf(buf, i%2==0 ? "H[%02i]: %-3i " : "L[%02i]: %-3i ", i, rht22_timings[i]);
 Serial.print("\n"); // XXX DEBUG
boolean getHumidityAndTemp(unsigned int rht22_timings[])
  // 25us = 400, 70us = 1120;
  for(int i=0;i<32;i+=2)

      humidity|=(1 << (15-(i/2)));
  for(int i=0;i<32;i+=2)


  int cksum=0;
  for(int i=0;i<16;i+=2)


  int cChksum=((humidity >> 8)+(humidity & 0xff) + (temp >> 8) + (temp &0xff)) & 0xFF;  
  if(temp & 0x8000)
    temp=(temp & 0x7fff)*-1;
  if(cChksum == cksum)
    return true;
  return false;

Signal handling is done in the readRHT03 function.  After sending the start sending signal, the Arduino uses Timer/Counter 1 to time the incoming pulses.  Originally, I was trying to use micros() to measure the timing, but I got some very erratic results.  This gave me the opportunity to use my new Saleae Logic Analyzer.  As you can see in the code, I have Pin 6 follow the state of the data input from the RHT03.  Normally, there is a 15us delay between the time the RHT03 changes state and the time Pin 6 changes state (the time to execute the if statement and the digitalWrite()), but sometimes it is longer.  The highlighted pulse on Channel 1, though, shows the delay is at least 10us longer.  To make a long story short, this is caused by interrupts in the Arduino, and turning off the interrupts before I start timing the pulses fixes that problem.  Functions like millis() and micros() need interrupts to be update, though, so I could not use them with the interrupts disabled.  This means I had to use the hardware timer/counter to time the pulse length, which is what the references to the TCCR1A, TCCR1B and TCNT1 do.  Additionally, to measure the time the interrupts are disabled, I set Pin 5 (Channel 2) to go high when the interrupts are disabled and low when they are re-enabled, which gave me about 4ms of “interrupt-less” time.  Since my weather station is going to be polled at 60 second intervals, I now know that the timers won’t be running for about 4ms of that time, so I have to set my timers to 59996 to get a 60 second poll.

Anyone using this code should pull out all the references to Pin 5 and 6, unless they want to use them for debugging as well.

Note the short pulse caused by the Arduino handling other interrupts.

The other thing to note is the temperature is pretty inaccurate when the device is in direct sunlight.  My original design had the RHT03 sharing the waterproof container of my MAX44009 light sensor, but even though it is open to the air at the bottom on the container, the temperature inside the container got well above 110°F on bright sunny 90°F+ days.  I’m now extending the cable to the RHT03 and putting it in it’s own container, shaded by the solar cell.  I will update on how well that works.

RHT03 Mount

Mount for the RHT03 to keep it out of the rain and the sun.


Sunny Location

The RHT03 is in the container on the left with the blue top. This container also houses the MAX44009 sun sensor.

Shade RGT03

New location of the RHT03, under the black cover.

Logger Shield and FreqCounter for the Mega 2560

In order to allow me to use the XBee radios to remotely download the logged data to my PC, I’m going to have to use an Arduino Mega 2560.  The Uno just doesn’t have the interrupts to use with the frequency counter, as well as a software serial port for the XBee, so the extra UARTs on the Mega are required.  While the Logger Shield from ladyada.net physically fits into the Mega, the SPI and I2C pins are different between the Uno and the Mega.

You must first lop off the pins for the Uno’s I2C interface (A4 and A5), and the SPI bus ( D10,11,12, and 13):

Modified Logger Shield

Solder wires to DO, DI, CS, CLK, SDA and SCL pads on the Logger Shield and connect as follows:

DO – D50

DI – D51

CS – D53

CLK – D52

SDA – D20

SCL – D21

The libraries the run unmodified.

Mega 2560 Logger

I will incorporate this into a new PCB at some point.

One other change I had to make in order to support the Arduino Mega 2560 was a change to the FreqCounter Library.  While the Uno version of the FreqCounter Library uses T1 on the D5 pin, this pin is not available on the Mega.  You have to use T5 on the Mega which means you input your pulse into pin D47 of the Mega.  FreqCounter.cpp , must be modified as follows to use the correct control registers for the Mega (note the new defines for the control registers depending on the type of Arduino):

  FreqCounter.h -
  Using Counter1 for counting Frequency on T1 / PD5 / digitalPin 5
  Using Timer2 for Gatetime generation

  Martin Nawrath KHM LAB3
  Kunsthochschule für Medien Köln
  Academy of Media Arts

  	Dec/08 - V1.0
  	Oct/10 - V1.1    removed occasional glitches through interference with timer0
  	                 set intterrupt timebase to 1ms
  	                 works with atmega328 

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#include <FreqCounter.h>

unsigned long FreqCounter::f_freq;

volatile unsigned char FreqCounter::f_ready;
volatile unsigned char FreqCounter::f_mlt;
volatile unsigned int FreqCounter::f_tics;
volatile unsigned int FreqCounter::f_period;
volatile unsigned int FreqCounter::f_comp;

void FreqCounter::start(int ms) {

// The Mega2560 does not have T1 connected to anything, so it must use T5, on pin 47, as the counter input
#if defined (__AVR_ATmega168__) || defined (__AVR_ATmega48__) || defined (__AVR_ATmega88__) || defined (__AVR_ATmega328P__) || (__AVR_ATmega1280__)
	#define TCCRXA TCCR1A
	#define TCCRXB TCCR1B
	#define TCNTX TCNT1
	#define CSX0 CS10
	#define CSX1 CS11
	#define CSX2 CS12
	#define TIFRX TIFR1
	#define TOVX TOV1
#elif defined (__AVR_ATmega2560__)
	#define TCCRXA TCCR5A
	#define TCCRXB TCCR5B
	#define TCNTX TCNT5
	#define CSX0 CS50
	#define CSX1 CS51
	#define CSX2 CS52
	#define TIFRX TIFR5
	#define TOVX TOV5

    TIMSK0 &=~(1<<TOIE0);       // disable Timer0  //disable  millis and delay
    delayMicroseconds(50);      // wait if any ints are pending


    if (f_comp ==0) f_comp=1;  // 0 is not allowed in del us

    // hardware counter setup ( refer atmega168.pdf chapter 16-bit counter1)
    TCCRXA=0;                  // reset timer/counter1 control register A
    TCCRXB=0;              	   // reset timer/counter1 control register A
    TCNTX=0;           		   // counter value = 0
    // set timer/counter1 hardware as counter , counts events on pin T1 ( arduino pin 5)
    // normal mode, wgm10 .. wgm13 = 0

    TCCRXB |=  (1<<CSX0) ;// External clock source on T1 pin. Clock on rising edge.
    TCCRXB |=  (1<<CSX1) ;
    TCCRXB |=  (1<<CSX2) ;

    // timer2 setup / is used for frequency measurement gatetime generation

    // timer 2 presaler set to 128 / timer 2 clock = 16Mhz / 256 = 62500 Hz
    TCCR2B |=  (1<<CS20) ;
    TCCR2B &= ~(1<<CS21) ;
    TCCR2B |=  (1<<CS22) ;

    //set timer2 to CTC Mode with OCR2A is top counter value
    TCCR2A &= ~(1<<WGM20) ;
    TCCR2A |=  (1<<WGM21) ;
    TCCR2A &= ~(1<<WGM22) ;
    OCR2A = 124;                // CTC divider by 125

    f_ready=0;                  // reset period measure flag
    f_tics=0;                   // reset interrupt counter
    GTCCR = (1<<PSRASY);        // reset presacler counting
    TCNT2=0;                    // timer2=0
    TCNTX=0;                    // Counter1 = 0

    TIMSK2 |=(1<<OCIE2A);       // enable Timer2 Interrupt

                                // External clock source on T1 pin. Clock on rising edge.
    TCCRXB |= (1<<CSX2) | (1<<CSX1) | (1<<CSX0);        //   start counting now     

//  Timer2 Interrupt Service is invoked by hardware Timer2 every 1ms = 1000 Hz
//  16Mhz / 128 / 125 = 1000 Hz
//  here the gatetime generation for freq. measurement takes place: 

										// multiple 2ms = gate time = 100 ms
if (FreqCounter::f_tics >= FreqCounter::f_period) {
                            			// end of gate time, measurement ready

   										// GateCalibration Value, set to zero error with reference frequency counter
    //  delayMicroseconds(FreqCounter::f_comp); // 0.01=1/ 0.1=12 / 1=120 sec
    TCCRXB = TCCRXB & ~7;   			// Gate Off  / Counter T1 stopped
    TIMSK2 &= ~(1<<OCIE2A);    			// disable Timer2 Interrupt
    TIMSK0 |=(1<<TOIE0);     			// enable Timer0 again // millis and delay

                                        // calculate now frequeny value
    FreqCounter::f_freq=0x10000 * FreqCounter::f_mlt;  // mult #overflows by 65636
    FreqCounter::f_freq += TCNTX;      	// add counter1 value

    FreqCounter::f_ready=1;             // set global flag for end count period

    FreqCounter::f_tics++;            	// count number of interrupt events
    if (TIFRX & 1) {          			// if Timer/Counter 1 overflow flag
    FreqCounter::f_mlt++;               // count number of Counter1 overflows
    TIFRX =(1<<TOVX);        			// clear Timer/Counter 1 overflow flag
    // PORTB = PORTB ^ 32;  				// int activity test

Garduino Software

I’ve broken the sketch for the Garduino into 4 separate files.  The main module, called Garduino, is the flow control of the sketch, and contains the setup and loop methods.  The DataGather file contains the methods related to reading the sensors, and the OutputFormat source focuses on creating the output of the sensor data to the SD card.  The SDFunctions pde file contains the functions to read and write to the SD card.


#include <Wire.h>
#include "RTClib.h"
#include <SdFat.h>
#include <SdFatUtil.h>
#include <FreqCounter.h>

int count=0;
char buffer[101];
int bufIdx=0;

#define ADDR_0 7
#define ADDR_1 8
#define ADDR_2 9
#define ANALOG A0
#define TEST_PAUSE 60000
#define PAUSE_ADJUST 6500
#define DO_FILE

char fileName[] = "LOGGER00.CSV";
boolean debug=false;
unsigned long curTestTime=millis();
unsigned long preTestTime;
unsigned long testTimeDiff=0;


Sd2Card card;
SdVolume volume;
SdFile root;
SdFile file;

void setup()


#if defined DO_FILE

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));


#if defined DO_FILE





void loop()


  int temp;
  float reading;


#if defined DO_FILE
  DateTime now = RTC.now();
  String ts=timeStamp(now);











//  if(debug)
//    mySerial.print("");

#if defined DO_FILE
    Serial.println("Sync Error");



boolean wait()

  if(testTimeDiff >= (TEST_PAUSE-PAUSE_ADJUST))
    return false;

  return true;
unsigned long diff_time(unsigned long *cur,unsigned long *pre)
  unsigned long tm_diff;


  if(*cur >= *pre)
    tm_diff=(*cur + (34359737 - *pre));

  return tm_diff;

This project uses both the SD card in the logger shield, and the FreqCounter library, so the .h files are included at the top.  Most of the setup() is pretty straightforward; it is concerned with initializing the SD card and Real Time Clock (also part of the log shield).   The DO_FILE define allows me to test the code on Arduinos without the SD Logger Shield, and turns off all the SD card related code on demand.  The loop() simply waits for the wait function to return false, and then calls the data gathering commands and prints out the data.  The wait function is the only place where there is any trickiness to the code.  The variable testTimeDiff keeps track of the number of milliseconds from start of the previous test by calling the diff_time function.  The diff_time function normally just subtracts the time from the previous time the function was called, but it also compensates for the rollover of the millis counter, which occurs every 9 hours or so.  There is also the PAUSE_ADJUST define which is subtracted from the TEST_PAUSE.  TEST_PAUSE is set to 60000 milliseconds, or 1 minute, so the polling of the sensors occurs every minute.  When the frequencies are read for the moisture and light sensor, though, the clock is stopped, so I need to subtract the amount of time spent in the frequency counters to accurately pause for 1 minute between each sensor poll.


int readAnalog(int S0, int S1, int S2)

  return analogRead(ANALOG);


float readFrequency(int S0, int S1, int S2)
  unsigned long freqValues[5];


  for (int n=0;n<FREQ_MEASUREMENTS;n++)

    while(FreqCounter::f_ready == 0);



  float freqReading=processValues(freqValues,5);

  return freqReading;


float processValues(unsigned long values[],int valSize)
  unsigned long max=0;
  int maxIndex;
  unsigned long min=4294967295;
  int minIndex;
  unsigned long total=0;

  for (int n=0;n<valSize;n++)
    if (values[n]>max)


  for (int n=0;n<valSize;n++)

  float ave=(float)total/(float)(valSize-2);

  return ave;


The readAnalog function sets the address pins for the analog multiplexer (4051) and then reads the value of the analog pin (A0).  The various combinations of the 3 address pins select the 4 temperature sensors.  The readFrequency also uses the address pins to select the digital input on the digital multiplexer (74151) to put the pulse train on pin 5.  It then takes 5 measurements, each 250 ms long, and stores them in an array.  The array is passed to the processValues function, where the low and high value is thrown out, and the remaining 3 values are averaged.  During the 250 ms the frequency test is running, the millis() is not accumulating.  Since there are 5 tests for each frequency sensor, and there are 5 frequency sensors tested, a total of 6250 ms is “lost” to the millis() because the timer is turned off, and that value must be removed from the TIME_PAUSE to keep the test running at exactly 1 minute intervals.


void printFloatData(float data)
  // 250ms Gatetime so frequency is 4 times the count
#if defined DO_FILE

void printIntData(int data)
#if defined DO_FILE

String timeStamp(DateTime stamp)
  String time=String("")+int(stamp.year())+"/"+int(stamp.month())+"/"+int(stamp.day())+":"+int(stamp.hour())+":"+int(stamp.minute())+":"+int(stamp.second());
  return time;

These functions output the values from the sensors to the Serial port and the SD card.  Note the float data, which comes from the frequency counter, is multiplied by 4.  This is because the frequency tests are 1/4 of a second long, and I want the output value to be in Hertz.


boolean initSD(void)
    // initialize the SD card at SPI_HALF_SPEED to avoid bus errors with
  // breadboards.  use SPI_FULL_SPEED for better performance.
  if (!card.init(SPI_HALF_SPEED))
    Serial.println("card.init failed");
    return false;

  // initialize a FAT volume
  if (!volume.init(&card))
    Serial.println("volume.init failed");
    return false;

  // open root directory
  if (!root.openRoot(&volume))
    Serial.println("openRoot failed");
    return false;

  return true;

boolean openFile(void)

  // create a new file
  for (uint8_t i = 0; i < 100; i++) {
    fileName[6] = i/10 + '0';
    fileName[7] = i%10 + '0';

    if (file.open(&root, fileName, O_CREAT | O_EXCL | O_WRITE)) break;
  if (!file.isOpen())
    Serial.println("failed on file.create");
    return false;
  Serial.print("Logging to: ");

  return true;

These functions are simply stolen from the SDFat examples, and initialize the SD card and the log file.

The Sensor PCB

This Garduino takes input from various sensors and logs it to an SD card on a Logger Shield.  The moisture sensors and light sensors both generate a frequency of pulses as their output, and there is only 1 timer input on the Arduino Uno that can measure this (pin 5), so I use a 74LS151 Multiplexer to put these signals on pin 5 and use Pins 7 (D0),8 (D1), and 9 (D2) to addresses the various inputs.   The LM335 temperature sensor is an analog device which I can simply plug into the analog pins of the arduino and do an analogRead, but the SD shield uses A4 and A5, which leaves me with 4 free analog inputs.  Although I am only supporting 4 temperature sensors now, I decided to use an 4051 analog multiplexer to put all the temperature signals onto A0, leaving A1-A3 free for future purposes.  Pins 7-9 are also used to set the address on the 4051 as well.  Because the electrolysis that occurs on the probes of the moisture sensors when sending a direct current through the damp soil, the moisture readings will change over time, so it is best to test the soil resistance (the de facto measure of soil moisture) with an alternating signal.  The 556 and 555 supply this alternating signal to the 3 moisture probes.  This is the schematic of the complete circuit board.

Garduino Schematic

The left hand ribbon cable connector leads to another ribbon cable connector soldered onto Logger Shield.  Pins 1 & 2 connect to the  Arduino +5V and GND, pin 3 connects to the timer pin 5 on the Arduino, pins 4, 5 and 6 connect to Arduino pins 7, 8, and 9 for the multiplexer addressing, and pin 7 on the connector leads to the A0 pin on the Arduino pin to read the analog values of the temperature sensors.  The 20 pin ribbon cable on the right is to interface to the sensors, which will be discussed in a later blog entries.

I decided to use the EAGLE software to build my first PCB, which was produced by BatchPCB.  It took about 3 weeks to get the board after ordering it, which was apparently fairly fast, but BatchPCB trades time for cost, and the total cost of the board was about $30; far less than you would pay for other services.

This is a picture of the completed board attached to the Arduino Logger Shield.

PCB And Arudino with the Logger Shield

Somehow 2 connections which where on the Schematic did not make it on the Layout and onto the PCB, but luckily, it was fixable.  I still have a lot to learn about EAGLE.

Fixed mistakes in the PCB design

Solar Power

Since the location of the Garduino has no access to power, I decided to Solar Power it.

I bought this 12 V 10 Watt Solar Panel off eBay for about $50.  Since mounting brackets for these panels cost nearly as much as the panel, I decided to make my own with a piece of Home Depot Aluminum, a coupe of U Bolts, and some small L Brackets.

Normally, from what I’ve read, you want to angle the panel at the same angle as your latitude, but it was a whole lot easier for my band saw to cut the aluminum at a 45 degree angle, rather than the 39 degree angle my latitude would indicate.  I’ll have to live with that inefficiency.

Since I want the device to run even when the sun is down, I also needed a battery.  I just picked up a cheap 12 V 7Ah battery off the internet somewhere for that job.  To tie the Arduino, battery and panel together, I bought a solar charge controller off Amazon.  The Kintrex SPC0601 was the cheapest, lowest power one I could find, but it fits the power levels that I am working with.  It basically has 3 connections, one for the battery, one for the panel and one for the load, and it’s job it to manage charging the battery during the day, and running the load off the battery or the panel as appropriate.

This picture shows the Kintrek and the Battery in the water proof box.  It also shows the wires to the various sensors as well as the sensor controller board, which I will discuss in a later post.

One thing to note is the 2.1mm power jack in the picture.  I originally plugged the Arduino Uno directly into that jack, but the voltage regulator on the Arduino got very warm. It got warm because the voltage regulator is very wasteful of my limited power.  Assume that my Arduino and sensor circuitry draws 100mA (probably a little high, but it makes the math easy).  Since the Arduino runs off of 5 V, the voltage regulator has to drop 7 volts (12 – 5 volts) at 100mA, and it has to throw off 7 V X 100mA = .7 Watts of power as heat to supply the Arduino with 5V X 100mA = .5 Watts of power.  That means my efficiency is .5 W/1.2 W (.5 W+ .7 W) or about 42% power efficiency.  That isn’t going to cut it, considering that this setup will also end up powering an XBee that has a max draw of around 200mA.

I started looking into building a DC switching power supply of some sort when I ran across these Universal 12 Volt USB Car Chargers for about $2 on Amazon.   Tearing one open, I saw a nifty little switching power supply with the added bonus of a USB connector so that I could simply use a USB cable to the Arduino for power.

For $2 you don’t get a detailed datasheet that describes things like the maximum current capacity, but the D34063 chip at the center of the supply is rated at 1.5 A, so I feel pretty comfortable that this should be able to handle the load.  Since a switching power supply is turning on and off the current at a pretty high frequency, it is difficult to determine an effective current input to the device, so it is hard to calculate the efficiency of the power supply.  When I’m bored, I might try to hook up my oscilloscope to it to try to get an idea of the efficiency of the device, but I’m sure it is way better than 42%, because the device does not get even a little warm in use.

The final thing I’d like to discuss is the water proof container.  I initially used a Tupperware, some glue and electrical tape, but it was a complete failure.  A couple of rainy days later,  I had water pooling in the container, and a ruined Solar Charge Converter.  Luckily the Arduino stayed dry, but I had to find a better container for the Garduino.

This is the $20 Dri-Box Waterproof Connection Enclosure, and it has been working pretty well so far.  If you notice the earlier picture, where you can see the inside of the box, you can see the channels that the cables run through are filled with a soft rubber which seal around the cables.  I have yet to see any evidence of water inside the container, and we have had some deluges in the time it has been out there.

Project Garduino

In the Spring of 2011, I bought a small greenhouse from Costco so I could plant some veggies early and maybe get some more productivity. About that same time, a friend sent me a link about using an Arduino to control a camera for high speed photography, and I thought that the Arduino would be the perfect tool to understand how effective this new greenhouse is. I currently have drip irrigation in my other vegetable gardens running off a timer and I’ve put the greenhouse on the same water line. Unfortunately, the greenhouse needs a lot more water than the outside garden, so eventually I will be operating a water value with the garduino to control the water going to the 2 gardens.Costco Greenhouse and Garden B

I currently have the Arduino setup to take 2 light readings and 2 soil moisture (1 each inside and outside the greenhouse), and 4 temperature readings (1 soil and 1 air temperature both inside and outside the green house). I’ve already taken some data, and this is what it looks like:

Here are a few things I’ve learned.  First the TSL235 I’m using are too sensitive to use to measure sunlight.  They saturate, and I will have to replace them with TSL230 (the light sensor output frequency is plotted on the left axis).  The moisture sensors are pretty much worthless right now, but I’m going to be trying several designs to hopefully find one that works well.  The temperature sensors are the only thing I’m happy with at this point (they are LM335’s).  What I learned from them is interesting.  During the day, the air temperature inside the greenhouse is up to 20 F warmer than outside (the Temperature is plotted on the right axis), but at night, the air temperature both inside and outside the greenhouse is the same.  The ground temperature, though, is alway about 5 F warmer in the greenhouse than outside it.

Future posts will discuss all the sensors and other elements of my Garduino in detail, and hopefully the improvements I make along the way.