Friday, November 16, 2012

Project 1: Home Energy Monitor with Arduino, Part 1/3: HW

The first sensor project at SensorBay.com covers a simple introductory project, which utilizes a PC, an Arduino microcontroller board, and a custom made sensor box for monitoring home electricity usage. The idea is to use an optical sensor to read current energy consumption from home electricity meter, and send this information to a PC for post-processing.


LEVEL: Beginner


Motivation


Everyone wishes to save energy and money. Minimizing your monthly electricity bill is a good place to start. What makes it difficult, is that your bill only tells the total amount of electric energy that was consumed during a long time window, typically one month. Hence, testing the effect of a change in behavior as an energy consumer is not practical. For example, if you lower the temperature in your house by one degree to save energy, what is the effect - how much will you save? What about two degrees? Or, what about 3 degrees in bedrooms but only 1 degree in living room? Waiting a month to see the result each time is not an option, as other things like weather changes come in to play.

A working solution would be to frequently log the values from your energy meter to a notebook, and then draw a graph to reveal the before-after effect. But things like this need to be automated to become practical. So we will use a home PC, and build a measurement device that can be simply attached on top of the electricity meter. To keep it completely harmless and safe, we will use an optical sensor. The measurement device continuously observes energy consumption and logs it into a file on your PC's hard drive. Then, you can easily draw graphs with a spreadsheet app.



Home Energy Meter


In order to measure how much electric energy your house consumes (and how big your electricity bill should be), an electrician has installed an energy meter to your house. There are two common types:
  • Old analog models have a big rotating disk and a mechanical number display
  • New digital models have a blinking LED and an LCD display
You should first check which one you have (see example images below). Note that we can read the energy consumption from either one, but the sensor box needs to be slightly different.


Analog home energy meter.
Image: Ali@gwc.org.uk at en.wikipedia
Digital home energy meter.

Electric energy is measured (and counted by energy meter) as kWh (kilowatt hour). For example, if you have a 1000 W radiator heating a room for one hour, that's one kWh of electric energy consumed.


WARNING: It is not only dangerous but strictly forbidden to make any electrical connections to the energy meter, or to even to open the box. And there's no need for either, so leave it alone!


Sensor: Photoresistor


Since we can't connect to the energy meter itself, we have to rely on what can be seen through its box - i.e. we'll use light. While we could use a camera as a sensor, it is clearly an overkill for our need. We just need a sensor that responds to visible light e.g. by alternating its resistance. Such a component is called LDR (Light-Dependent Resistor), whose alternative names are photoresistor, photoconductor and photocell. In this article, I use the short term LDR from now on.

An LDR sensor.
Image: (c) BenTheWikiMan at dutch Wikipedia


Digital meters with a blinking LED


If you examine the writings on the meter, you should find a text that indicates how many times the LED blinks per each kWh of electricity consumed. For example, the meter in my house (see the image above right) says "P 10000 imp/kWh", meaning that power P is indicated with 10.000 impulses per kWh of energy with the yellow LED beside the text.

So the problem of monitoring energy usage becomes a problem of measuring the number of LED flashes per second, and calculating the rest from this measured value. Basically we just need to put an LDR on top of the LED, and connect it to an analog input for reading its values.

Analog meters with a rotating disk


Well, it is slightly more complicated, but not much. There's a rotating metallic disk that has a mark in the edge, made e.g. with red paint. When you observe the disk carefully, once per each revolution a different color appears momentarily in view - this is your "blinking LED"! Read the labels from the meter to find out how many revolutions indicate a kWh of energy, and then measure the number of revolutions per second (or minute, because the disk moves rather slowly).

So the problem of monitoring energy usage becomes a problem of measuring the number of disk revolutions per second, and calculating the rest from this measured value. But we can't measure disk revolutions with a light sensor, because the disk is not a light source, right? We need to add one, and install it in such a way that it points to the edge of the disk, so that the disk reflects part of the light back to our LDR sensor. Obviously, this requires careful tuning, because the color spot in the disk edge won't create much difference to the reflection - but it works. Due to sensitivity of the measurement, we'll need to block other light sources from distracting it. Hence, the sensor, the LED and the rotating disk edge must be covered with something.


About LEDs and Resistors


Two resistors, a visible light LED (red color) and an infrared (IR) LED.

Since we'll be using a LED in our design, here's a couple of things to understand about LEDs:

  • In order to work, the voltage across the legs of the LED must be greater than the LED's so-called forward voltage (remember that a LED is a diode). This is typically 1.6-3.0V, so one 1.5V battery is not enough but two in series usually works. However, blue, violet and white require higher voltage: 4-5V.
  • LEDs have two legs and polarity matters: if you put it the wrong way, it won't lit but it won't break either (unless you pass reverse breakdown voltage and current is not limited). Positive side (anode) has longer leg and smaller part inside the plastic cover, and the negative side (cathode) has a flat spot in the ring of the plastic cover.
  • The more current goes through the LED, the brighter it will be. However, since the LEDs internal resistance for forward direction is very small you MUST limit current with a resistor, otherwise the LED will overheat and burn immediately! Suitable amount of current depends on the LED type, for example 20 mA is safe for the standard type shown in the picture but miniature ones are usually rated for 2mA.
  • If you make a LED blink shortly instead of continuous lighting, you can use much greater current i.e. get brighter light. This is frequently used with IR LEDs, for example in remote control units.

Also some notes about resistors:

  • A resistor works against electric current, i.e. it "tries to prevent current from flowing". The bigger the resistor is (in Ohms), the less current goes through.
  • A resistor converts electricity to heat. How much heat it can dissipate depends on the resistor type. For example, the ones shown above are rated for 1/4 W. Too much heat and they will burn.
  • Resistors have two legs, but polarity does not matter. You can put it either way.
  • You should become familiar with the equation U = R * I, or R = U / I, or I = U / R. For example, if you have a 9V battery and you want to limit current to a LED to 20 mA, a suitable resistor size would be R = U/I = 9V/0.020A = 450 Ohm.
  • Also learn formula power P = U * I. In the above example, power dissipated by the 450 Ohm resistor would be 9V * 0.020A = 0.18 W, i.e. a single resistor rated for 1/4 W should be fine.

Arduino Microcontroller Board


Now that we have some idea of the sensor part, we'll have to find a way to connect the sensor to a PC. One good method is to use a microcontroller (MCU, kind of a miniature computer in a single silicon chip). MCU has typically many digital input/output pins (which are handy for controlling on-off things such as LEDs) and a few analog input pins that are combined with A/D converters (which actually convert an analog signal to digital so that we can process it with software). 

In our setup, we probably want to control LEDs with digital output pins, and connect our LDR sensor to an analog input pin. MCUs also have RX/TX lines for serial communication, which can be used for talking to a PC. And that's all we need for this project.

However, putting an MCU into our design makes our electronic circuit much more complex, since the MCU needs many additional components itself. Also, setting up the development environment for writing software to an MCU can be quite a task itself. Fortunately, we don't have to worry about such things when we use an MCU prototyping board that is targeted for hobbyists. The most popular one is Arduino, so we'll use that in our design. You can easily find online stores that sell Arduino or its clones, for example Sparkfun.com.


Arduino Diecimila microcontroller prototyping board.

Arduino is nice because it is fully open source (including HW schematics), reasonably priced at ~20€, has built-in USB communication to a PC and even takes the power from the USB port. There's also a very active community, lots of board variants and easy-to-use development environment. Moreover, if some HW feature is missing, there's a good chance that it can be added with an expansion board (can be stacked on top of Arduino). So there's plenty of reasons to use Arduino in hobby projects!

I've chosen to use the "standard" Arduino board model, revision Diecimila. It uses 5V logic in digital I/O pins, and samples analog inputs (0-5V) with 10-bit precision i.e. maps 0V to value 0 and 5V to value 1023, which is more than enough for our purposes.

Another article here at SensorBay.com discusses using Arduino for a sensor project in more detail. Check it out if you're not familiar with Arduino already.


Connecting the Sensor


So we wire the LDR sensor straight to an analog input in a similar manner that we connected a temperature sensor in the previous article? Is it suppose to work just like that? Well, no. The temperature sensor we used previously had three legs: power, GND, output - but an LDR has only two! So if you apply a voltage over it using power and GND, where do you get the output? Clearly we need to add another component to the circuit.

How about the sensitivity of the sensor? You know that there's a huge difference in the amount of light produced by a single candle and the Sun. In this application, we wish to target to the lower end of the scale and measure very slight changes of light intensity - how do we do that?

Here's the trick: in order to tune the sensor's range, we'll need to add a so-called preset resistor. More specifically, by connecting a suitable resistor in series with the sensor, we can adjust our setup's sensitivity to light. Remember that an LDR itself is a resistor too, so we are effectively connecting two resistors in series.


An LDR and a preset resistor.


As a side effect, now that we have two components in series, we also have an additional connection point between them. What could be the voltage in this point? Obviously it is something between GND (0V) and +5V. By measuring the voltage over the sensor, i.e. between GND and the point between the two resistors, we have actually found a connection point where voltage changes along light intensity. This is a signal that we can connect to an analog input - we now have "three legs".

So we needed to add only one component to solve both problems. Neat.


Wiring Diagram


Sensor box wiring diagram for analog meters. If you have a digital meter, simply leave out LED1 and R2.

This is our wiring diagram (schematic). On the left side of the Arduino's MCU, you can see the LDR sensor (R1) and its preset resistor (R3). The point between the sensor and the preset resistor is connected to an analog input (here Arduino's pin A2). This is the minimum that is needed for reading the sensor.

If you have an analog energy meter, you also need LED1 and R2 for generating light that will be reflected from the edge of the rotating disk to the LDR sensor. In case of a digital meter these are not needed, but during prototyping/tuning phase it is a good idea to have them anyway: use a visible light LED of same color that you have in your meter, so you can try out the design without going to the actual meter.

Later when you're adjusting the sensor in front of the electricity meter, it would be great to have some kind of indication whether the measurement is working, i.e. if the sensor is correctly positioned or not. We'll add some (useful but completely optional) visible light LEDs to indicate that 1) power is on and everything is fine (with a continuously burning LED), and 2) we are getting readings (with a blinking LED). Hence, on the right side there are two visible light LEDs (LED2, LED3) and their current-limiting resistors (R4, R5). Since they are connected to digital pins D12 and D11, they can be turned on/off from software. 

WARNING: Arduino Diecimila can provide 40 mA current per digital I/O pin. Since our LEDs won't need more than 20 mA, we can connect them directly to I/O pins. Not so with many other components - be aware of maximum current output and check that you stay within limits! Hint: if you need more current, take it from Vin and use digital output as a switch using a transistor.


Component Sizing


Before we can build a prototype, we must define the resistor sizes in Ohms. Personally, I've always struggled to understand how these values are somehow pulled from sleeve... hence, I try to be helpful and elaborate a little more about how and why I've come up with the values I have. If you don't care, just check out the values from the end of the section.

Let's start from the LDR sensor. An LDR is a semiconductor that has high resistance in dark and much lower resistance when lit, i.e. it conducts more when photons of the light aggravate electron flow from one side to the other.

As an example, I used a digital multimeter to measure the resistance of one LDR in a particular setting: I first covered its sensitive side with a finger: approximately 220 kOhm. Then again finger removed: about 22 kOhm (10% of the original value). Then lit with a bright desktop lamp close to component surface: about 220 Ohm (only 0.1% of the original value). This is how LDRs are suppose to work; they are very sensitive to light and their resistance depends on the amount of light they get.


Using a digital multimeter to measure the resistance of an LDR sensor.

So with Arduino Diecimila, we have a 5V system. Remember that when resistors are connected in series, the current through all of the resistors is the same, but the voltage across each resistor will be in proportion to its resistance. Now, let's consider a few simple examples:

  • Let's say U=5V and there is no preset resistor at all. In dark, LDR sensor has 220 kOhm resistance and formula I=U/R yields 5V/220,000 = 22.7uA. When brightly lit, resistance is 220 Ohm and current becomes I = U/R = 5V/220 = 22.7mA. So current through the sensor changes along the amount of light received. It will be way below Arduino's max current output 40mA. Moreover, in the wiring diagram we have taken power directly from +5V, so we don't need a resistor for limiting the current unless the LDR itself can't dissipate the power P=U*I =5V*0.0227=0.114W. Based on a few LDR component specifications, seems that small LDRs (diameter ~5mm) tolerate 80-100mW and larger ones (diameter ~10mm) 200-400mW. This means that its actually a good idea to limit the current with a resistor. Moreover, if we connect it this way, the voltage over the sensor will be 5V all the time, and measuring something with Arduino's analog input needs a change in voltage while now we have a change in current. So we add a preset resistor in series with LDR sensor. See what happens:
  • Let's say U=5V and our preset resistor is 220 kOhm i.e. same than LDR in dark. In dark, both resistors have equal resistance and hence equal voltage over them: both have 5V * 50% = 2.5V. But when lit, the LDR sensor would have, say, 1% of its resistance left, and 99% of the voltage drop would occur over the preset resistor. Hence, voltage over the LDR would be 5V * 1% = 0.05V. So the LDR operates between 0.05-2.5V, depending on the amount of light received. Now we have a change in voltage, but we're using only the lower half of the Arduino's 0-5V analog input and hence missing half of its dynamic range!
  • Let's say U=5V and our preset resistor is 2.2 kOhm i.e. same than LDR in light. In dark, the LDR sensor's resistance would be 100-fold and hence it would get 99% of the voltage: 5V * 99% = 4.95V. When lit, resistances would be equal and voltage as well: 5V * 50% = 2.5V. Now the LDR operates between 2.5-4.95V i.e. just the opposite than above. You can guess what we'll try next...
  • Let's say U=5V and our preset resistor is 22 kOhm i.e. middle from the LDR range. In dark the LDR has 10-fold resistance compared to the preset resistor, hence it gets 90% of voltage i.e. 5V * 90% = 4.5V. When lit, it gets 10% of the voltage i.e. 5V * 10% = 0.5V. Now the LDR operates between 0.5V-4.5V. We have found a good preset resistor value so that we can maximize the dynamic range. In addition, the preset resistor guarantees that max current I=U/R=5V/22,000=0.227mA as resistance will be at least 22kOhm, independent of the LDR value. As a consequence, max power in preset resistor (and the LDR as well) will be below P=U*I=5V*0.000227=1.14mW, which both components tolerate with ease.


To get better understanding of using a preset resistor with an LDR, check out this link. If you didn't quite catch the voltage drops explained above, check out this link. Now, to summarize the procedure:


Measure the maximum and minimum resistance of the LDR in a setting similar to your use case, then pick a preset resistor from the middle of the scale. Check that you don't draw too much current from Arduino I/O pins nor dissipate too much heat from the resistors, i.e. stay below their rated max values.



Now that we have determined the size of the preset resistor, we'll need to find out the values for the current-limiting resistors for the three LEDs as well. The size of R2, R4 and R5 can be calculated easily: as LEDs can be safely driven with I=20mA and we have U=5V, formula R=U/I yields 250 Ohms. However, I didn't want to make them that bright, so I have selected slightly larger resistor values (more resistance -> less current -> less light).

There's one more selection to be made: what color LED1 should be? Specifications for an LDR sensor typically contain a graph of its spectral response, which tells how sensitive it is to each color of light (see the image below). If you compare the graph to a plot of LED spectra, you'll notice that yellow or green match with the most sensitive area. However, if you have a digital energy meter, pick the same color that the meter has for tuning the system.

Spectral response of one LDR sensor. Most sensitive to yellow/green LEDs (~570nm).
Notice that it is not suitable for IR light (750-1000nm).


Finally, here's a list of components needed for building a prototype on a breadboard:
  • R1 = LDR sensor (rated as 5-10kOhm at 10lux/2856K light; in dark >200kOhm)
  • R2 = 383 Ohms
  • R3 = 22 kOhms (preset resistor size)
  • R4 = 464 Ohms
  • R5 = 464 Ohms
  • LED1 = yellow
  • LED2 = red
  • LED3 = yellow


The prototype


Now that we know what components to use, we should test that the design actually works. This can be achieved by building a prototype on a breadboard.

In the image below I have designed how to build a prototype on a breadboard. When you get a little bit of experience, you can build simple sketches like this without planning them in advance. However, this kind of image is great for documenting the prototype design. It was made with a tool called Fritzing.



Prototype design for breadboard.

In order to design and build this, you need to understand how those holes in the breadboard are connected to each other. For example, in this board columns are connected vertically, but as an exception the two top and two bottom rows are connected horizontally and thus are handy for example for carrying 5V and GND signals across the board. There are also gaps at horizontal and vertical center lines, so I needed to add one jumper wire to the center of the bottom row to carry GND to the other side. The board should have some documentation when you buy one, but if not, you can always test how it's been wired using a digital multimeter e.g. by measuring a resistance between two points: if its close to zero, points are connected.

Prototype build on a breadboard.

Here's the same thing actually built. In this image I have already powered it using a USB cable connected to a PC.

WARNING: Before you turn the power on / connect the Arduino to a PC, remember to double check all connections! Also beware of shortcuts with components that have long exposed legs!

If you built the same thing, you'll notice one difference: your LEDs aren't showing any light. Why's that? Because there's no software to turn on the LEDs! We'll do that next.

If you haven't already, download Arduino IDE from here and install it to your PC. Connect your Arduino board to the PC using a USB cable. Start Arduino IDE, select your board type from the menu, load some example sketch (such as the classic blinking LED example), compile it with CTRL+R and upload to board with CTRL+U. The program code will be stored to MCU, and after automatic reset it will run. The Arduino's internal LED starts blinking. Now, whenever Arduino is powered e.g. with an external power source, the same software begins to run, even if the USB cable is detached. This should be very simple, but if something went wrong, you should look for help from Arduino community before proceeding, or read introduction to Arduino article here at SensorBay.com.

Now, create a new sketch and write this program code:

void setup() {
  // Configure pins as input/output:
  pinMode(11, OUTPUT); // Yellow LED
  pinMode(12, OUTPUT); // Red LED
  pinMode(A2, INPUT);  // LDR sensor

  // Turn power LED on:
  digitalWrite(12, HIGH);

  // Start serial communication with a PC:
  Serial.begin(9600);
}


void loop() {
  // Read LDR sensor (0-1023 = 0-5V)
  int val = analogRead(A2);

  // Print value to PC:
  Serial.println(val);

  // Notify relevant change with yellow LED:
  if (val < 600)
  {
    digitalWrite(11, HIGH);
  }
  else
  {
    digitalWrite(11, LOW);
  }

  // Wait 100 ms before next read (10 Hz sampling rate)
  delay(100);
}


Compile (CTRL+R) and upload to Arduino (CTRL+U). Red power LED should turn on, and maybe also the yellow signal LED. Why 'maybe'? It partially depends on your room lighting: the brighter it is, the lower is LDR's resistance and the voltage over it and the values read from the analog input. Before proceeding, make the room dark so that room lighting won't effect to our measurements!

Now, open the serial console from Arduino IDE, and you can actually observe how the values change when you cover the LDR sensor, or when you let the LED shine towards it. Then compare the printed values to our selected limit 600 that was set in the code, and you'll see why the yellow LED turns on/off.

This already proves that the setup works for digital energy meters: instead of LED1 you just use the LED in the energy meter to light the LDR sensor. You'll see that the printed values clearly change as the LED blinks, and may choose a suitable value between the minimum and maximum readings to become the threshold value for triggering LED3 on/off.

However, in case of an analog energy meter, we need further proof. We will simulate the energy meter's rotating metal disk with a painted mark. Find some reflective metal and paint a mark on it, like in the image below - I used a marking pen on a pair of tweezers.

A pair of tweezers with a painted spot simulates analog energy meter's rotating disk.

Next, find the "sweet spot" above the sensor and the LED. This is where the metal reflects light from the LED to the sensor, making the measured value clearly decrease and the yellow LED to turn on. For example, initially I got readings around 700, but when using the tweezers to reflect the light from the LED, the values became close to 530, well below set limit 600. Note: You probably need to tune the prototype by bending the legs of the sensor and the IR LED, until you get this this to work.

Then, slightly move the metal away so that the painted part comes to the "sweet spot". As it won't reflect light as well as the shining metal surface, measured value will be higher again and the yellow LED will turn off. In this situation, my readings were about 650. Note: You probably need to tune the software value from 600 to something specific to your setup, until you get this to work.

Up: Pure metal reflects light well to the sensor.
Down: Painted spot on the metal does not reflect light well.


Now we have proved that successful measurements from both digital and analog energy meters are possible with this design, using an LDR sensor. However, this is just a prototype and not suitable to be attached in front of the meter. Next, we will build a more practical version i.e. the actual sensor box.


The Sensor Box


I like to use the board type with copper bands and holes for building simple circuits. The procedure goes something like this:

  1. Make a design using pencil and paper, Fritzing or whatever tool you prefer
  2. Cut as small piece of board as possible
  3. Use a miniature drill to cut bands where connection must be broken, test with multimeter (Ohm)
  4. Solder the components on the board
  5. Check everything twice, test with multimeter (Ohm)
  6. Apply power, test with multimeter (voltage)
  7. Write the software and test that everything works OK

Remember that in case you have a digital energy meter, you need to leave out LED1 and R2!

Sensor box design for copper band board.
The design is illustrated above. Notice that actually the components are placed on the other side - their legs come through the holes to the side shown in the image. The legs are soldered to the copper bands, and cut. The illustration shows both on the same side so that one can see where each component should be placed, and how it will be connected via the copper bands and jumper wires.

Sensor Box actually built. Component side.
Board is glued inside an empty, squeezed plastic tape roll and a cable is attached.
There are many possibilities to organize the components on the board. The way I built it (see the image above) is slightly different from the design presented before: the left side in the image is mirrored vertically. It doesn't matter. During the design phase it is easy to place the components on paper/screen, but when building the device minor modifications frequently need to be made to fit the components.

Soldering side. Not so pretty, eh.
Soldering side is shown above. To minimize the number of jumper wires, I have combined multiple copper bands to one (from conductivity point of view). This way I have larger areas of the board in the same potential, and hence more room for component placement.

Soldering side with plastic cap on. I simply cut it from 1mm black plastic and glued to place.
The sensor should be covered to prevent room lighting from distracting the measurements. I have used a piece of 1mm black plastic as a front plate. It was simply cut with a knife. The white body (tape roll) passes quite a lot of light through - if that becomes a problem, it can be painted over.

Cable attached to Arduino.
Arduino uses female headers as connectors. I have used small pieces of breakaway male headers as connectors, and simply soldered the wire ends to them. Now I can plug the cables to/from Arduino with ease.

Testing the actual sensor box with tweezers.
Finally, I repeated the test with the tweezers using the same software code than in the prototype. Everything worked just fine. It means that the sensor box is now finished and it can be attached in front of the energy meter, using blue sticker / glue / tape / whatever.


Of course, correct position needs to be found. Perhaps the LDR sensor's legs need to be slightly bent as well, to get the meter's blinking LED / rotating metallic disk to the sensor box's "sweet spot". That shouldn't be too hard, as the LEDs are there to assist and sensor values can be read from computer screen continuously.



WARNING: You should put the Arduino inside a box as well, to prevent damage / shortcuts if metallic parts accidentally get into contact. Boxes made just for Arduino are available.


While the hardware part is now ready, you probably already wish for a bit smarter software to Arduino, and some backend to PC that actually reads you sensor stream and stores it somewhere. I think that the software side is quite important and easy to generalize to other projects, hence it deserves its own article. And, this one is pretty long already...


Alternative Designs


This was just one way to build the sensor box. Here are a couple of options to consider:
  • Use IR light. Consider that traditional incandescent bulbs produce lots of IR light (heat), but modern compact fluorescents not that much (check out this comparison, and remember that IR wavelength range is from 750nm to 1mm). If you use the latter one in the room where the power meter is located, it might be a good idea to use infrared range to minimize the effect of room lighting, i.e. an IR LED instead of a visible light LED. However, then you also need a sensor that responds to IR light, for example an IR phototransistor. These are just simple replacements and do not make the system more complex at all, although preset resistor needs to be re-calculated.
  • Use phototransistor instead of an LDR. There are models that include a small lens, which might make the system more precise or easier to tune especially for the analog energy meter.
  • Make the LED that lights the sensor controllable with a digital I/O pin, similar to the other LEDs. This way you can easily use the same sensor box for both analog and digital energy meters - handy if you ever move or if your meter gets upgraded.
  • Try to use the same sensor box for other meters as well. There are blinking LEDs everywhere!



Summary


In this article, I have presented motivation for monitoring energy consumption at home, different energy meter models, a suitable optical sensor for monitoring them, the basics of using LEDs and resistors, Arduino microcontroller prototyping board, complete design for a sensor box, a breadboard-based prototype and design verification, and finally the real sensor box implementation.

In the next article, I will discuss writing proper software for Arduino-based sensor systems, and use this sensor box as an example. Furthermore, I will present a simple method to get your data to the cloud and how to get nice plots from the data to be viewed via a web browser. Stay tuned!

4 comments:

  1. Just had to say, this is a really high quality tutorial. There is as much or as little info as could be required. Thanks for taking the time to create these.

    ReplyDelete
  2. This comment has been removed by the author.

    ReplyDelete
  3. This is an excellent and extremely informative tutorial. Thank you!
    I have written a similar tutorial on using an Arduino to monitor power consumption:

    http://www.smartofthehome.com/category/arduino/

    (but I must say no where near as good as yours!)

    Keep up the great work!

    Jim

    ReplyDelete