Raspberry Pi Weather Station

My latest Pi project involves creating a weather station in a way very different from most others. I will cover various parts of this project in my next several posts.

The weather station completed and mounted outdoors.

The  most common way that a Raspberry Pi (or any other computer) is interfaced is via a pre-built system that has a serial or USB connection. This is the fastest and easiest way to do this. But what fun is doing things the way everyone else does?

I had an old weather station that was relatively cheap (less than $100) and did not have any drivers for Linux. I ran it on an old PC for several years, but it finally stopped working. The wireless part was never very reliable and it was a pain to keep replacing batteries. I was able to salvage the anemometer (wind speed) and rain gauge and hack them into my new system.

For temperature and humidity readings I use the AM2315 from adafruit. For barometric pressure I use the MPL115A2, also from adafruit. Both of the devices interface via the I2C bus. I have to give a plug for adafruit. It's a great place to get parts to connect to the Raspberry Pi.

The interface board and Pi on a mounting plate.

The anemometer and rain gauge are simple contact closure interfaces. Each tiny bucket of rain and each rotation of the anemometer produce a single pulse. These are connected simply through GPIO pins and drive interrupts which count the pulses.

The interface board that connects to the Pi is actually very simple. It mostly just passes GPIO pins to screw terminals. The MPL115A2 is the tiny blue board next to the ribbon connector.

Adafruit also provided the perfect weatherproof enclosure. I will have to drill holes to feed wires in, but those will be sealed with silicone.

In the near future I will write up posts on some of the problems I had to overcome to complete this project.

• Handling GPIO interrupts
• Interfacing to the AM2315 via I2C
• Interfacing to the MPL115A2 via I2C
• Calibrating the rain and wind sensors
• Logging to my MySQL database server
• Logging to Weather Underground
• Providing a nice web interface to display the weather data

Also, I will post my source code for others to use and/or learn from.

This has been a very fun project and I expect to use the weather station for many years to come.

Of course, Murphy had to strike - when I went to mount the system outdoors, it was raining!

My New System Checklist

I recently had need to create a new Raspbian system for a project and decided to record all the things I did after the system image first boots. Frequently, I forget one or two of these, so this will become a checklist that I follow when I create a new system.

There are many guides to creating a system for the Raspberry Pi and this post is not an attempt to create another. I am putting this here for my own reference as much as to share.  To make it helpful to beginners, I have added some explanations.  You may prefer nano over vi as the file editor.

Please feel free to use the comments section to let people know what customization you like to make for your Pi systems.

Load image as usual
raspi-config runs first time
- expand file system
- Internationalization -> set locale -> TZ = US-Eastern
- Internationalization -> Keyboard = English(US)
- advanced -> hostname (RasPi-##-Purpose)
- advanced -> mem split 16 for GPU
- advanced -> enable SPI and I2C and Serial
reboot, and log in as pi (raspberry)

CPU overclocking would also be set up in raspi-config, but I haven't had any need to do this.

All of the following commands require root privilege.  You can either put sudo before each command or enter sudo -i and run a shell as root.

Create a new user for myself, give it sudoer privilege.
adduser ted 
echo "ted ALL=(ALL) NOPASSWD: ALL" >>/etc/sudoers

Update the package database and upgrade all installed packages.
apt-get update 
apt-get upgrade

Install some new packages.
apt-get install samba screen libmysqlclient-dev libi2c-dev

Configure Samba (Windows file sharing)
vi /etc/samba/smb.conf
uncomment "socket options = TCP_NODELAY"
delete all shares and add:
[opt]
   comment = opt
   writable = yes
   locking = no
   path = /opt
   public = yes

Restart the Samba service
service samba restart  

Edit the SSH server config.  Turning off DNS reverse lookups will speed up the connection process when to log in through SSH.
vi /etc/ssh/sshd_config
add "UseDNS no"

Edit the netwrok configuration and set static IP address and wifi config.  The interface name for the wifi will be used below in the supplicant file.
vi /etc/network/interfaces
iface eth0 inet static
   address 192.168.0.51
   netmask 255.255.255.0
   gateway 192.168.0.1
   
iface home inet static 
   address 192.168.0.53
   netmask 255.255.255.0
   gateway 192.168.0.1

Edit the wifi supplicant file.  The "id_str" setting connects back to the name used above.
vi /etc/wpa_supplicant/wpa_supplicant.conf
network={
        id_str="home"
        ssid="NOTMYSSID"
        psk="NotMyPassword"
        proto=WPA
        key_mgmt=WPA-PSK
        pairwise=TKIP
        auth_alg=OPEN
}

Install Gordon's WiringPi library.  I use this extensively in my C programming.
cd ~
git clone git://git.drogon.net/wiringPi
cd wiringPi
git pull origin
./build
gpio -v
gpio readall

Edit the kernel module configuration to enable SPI, I2C, and 1-Wire.
vi /etc/modprobe.d/raspi-blacklist.conf
uncomment SPI and I2C devices

vi /etc/modules
add this
# SPI devices  
spi-dev  
# I2C devices  
i2c-dev  
i2c_bcm2708
# 1-Wire devices  
w1-gpio  
# 1-Wire thermometer devices  
w1-therm  

Finally, reboot the system again.  Then log on as the new user you created and  remove the default user.
userdel pi

If you don't do this last step and your system is accessible from the internet, then it will not be long (sometimes only hours or minutes) before a hacker finds it and does bad things.  My firewall log shows constant attempts to brute force a login via SSH and "pi" is a common user name that is tried.

Wifi Router Case Mod

In my previous post I showed how to use the case from an old LinkSys router as a case for a Raspberry Pi.  Today I decided that it needed a little improvement.  Bring on the blinking lights.  Isn't everything better with blinking lights?

I showed in the posts Server Box with Utilization Displays and CPU and I/O Utilization Display - Details how to use LEDs for a utilization display.  This project is a little smaller scale - only six LEDs instead of twenty.



The circuit is very simple.  The positive lead to each LED is connected to a resistor.  All of the resistors are connected to 5V.  The negative lead of each LED is connected to a GPIO pin.  A low signal on the GPIO pin turns the LED on.

This inverts the logic, but that can be handled in software.  This has the benefit of being able to push more current through the LEDs than would be possible if the GPIO line was connected to the positive lead of the LED.


This PCB layout shows a close approximation of how I made the circuit.  I didn't make a printed circuit board, but I have been designing some for work this week, so I did this drawing using PCB Artist.  I definitely plan to create some PCBs for my Pi hobby, once I decide what to make next.


All the wires are connected directly to a ribbon cable. I created a real power plug while I was at it.

The LED circuit is pushed into the front part of the case and through some holes that I drilled.  It is held in place by friction and a little tape.






My latest Raspberry Pi creation is stacked with the modem and router with all their blinking lights.

Now maybe it will not feel inadequate.

Raspberry Pi Case From Wifi Router

You have most likely seen one of these somewhere before.

This case style is very common.  If you happen to get your hands on one, you can make a great case for the Raspberry Pi.

(Or, you can re-load the router firmware.  See dd-wrt.org for more information.)

I had two in my huge pile of junk, so I though I'd have some fun. This was literally a ten minute project.


The case pops apart easily, if you know the trick.  Grab the blue front part and pull apart from the rear part.  After that, the top and bottom will come apart. A couple of screws later and you have prime case material.



I drilled two holes to mount the Pi and trimmed the rear opening just a little. It needs a better power connector.














One good thing about these cases, they stack very nicely.

Now to search the pile of junk for a hard drive. There is enough room to add one in this case.













Works Great!

Debouncing GPIO Input

Reading the state of a GPIO pin is very simple.  There are several methods to do this.  But what if you need to detect a very short pulse on a GPIO line or you need to respond very quickly to a state change without using a lot of the CPU to poll the state of the pin? This is exactly what interrupts are designed for.  I will cover how to use interrupts in a future post.  This post will show you how to deal with a common problem that must be addressed before interrupts will work correctly.

When the contacts of a mechanical switch close, they will almost always bounce a little.  This causes multiple spikes up and down on the connected line until the contact is firmly made.  The result is a series of pulses when a single state change was expected. This is, for obvious reasons, called "bouncing" and must be corrected either with hardware or software.

If that wasn't clear enough, maybe a picture will help. Imagine a push-button connected to a GPIO line. When the button is not pressed, a pull-up resistor holds the GPIO at 3.3 volts so that it reads a value of 1.  When the button is pressed, the line is connected to ground and the GPIO will read 0.  But on closer inspection, something else really happens. As this graph shows, the bouncing of the voltage level causes spurious state changes to the GPIO input. If you use an interrupt to increment a counter when the state changes on the GPIO, then a single button press can result in the counter incrementing two, three, or more times when the programmer is expecting only a single increment.

This can be dealt with in software, but that method tends to be unreliable in many instances. It is much better to correct for the bouncing using a simple hardware circuit.  This is called debouncing and one simple solution is shown below.

By connecting a capacitor as shown here, the result is a "smoothing" of the voltage curve. Before the button is pressed, the capacitor is fully charged and the GPIO will read 1. When the button is pressed, the capacitor will start draining through R2 at a rate determined by the size of the C1 and the R2.  The voltage on the GPIO pin will smoothly curve down from 3.3V to 0V and the GPIO will sense a single state change.

The values for C1 and R2 will determine how quickly the state changes.  If they are too small, then there could still be some bouncing.  If they are too large, then the circuit may respond too slowly for the application needed.  This could result in state changes being missed. You may need to experiment to find the proper values for a specific application. The values shown in this circuit are a good place to start.

A digital circuit that is also commonly used for debouncing is called the set/reset latch and can be constructed from two nand gates. To learn more about this option and everything else you might want to know about debouncing, read this paper.   A Guide to Debouncing

Now that you input is properly debounced, you can go on to using it to reliably drive an interrupt.

Improved Home Brewing Controller

This post is an update to my Automated Home Brewing post. See that post for more details on the project. After adding some new features haphazardly, I had an ugly conglomeration of old and new parts. It worked, but it wasn't pretty, and I sure didn't want to show it on this blog. So, I decided to build a whole new interface and include the new items:

• thermocouple interface for flame detection
• relay control for refrigerator
• relay control for heater (these two are used for controlling lagering temperature during fermentation)
• digital input for counting the bubble rate in the airlock during fermentation.
• battery level monitor, since I usually run this on a small 12V battery

I also kept all the original controls:

• relay for propane valve
• relay for igniter
• 1-wire bus for multiple temperature inputs
• relay for circulation pump

The item that I struggled with the most was how to make a reliable flame sensor. This is covered in the Flame Sensor Update post. Note - the drawing for the amplifier circuit in that post has the resistor values reversed. Here is the corrected drawing.

The gain formula for a LM358 non-inverting circuit is

               gain = 1 + R2/R1

In this case, R1 = 1K and R2 = 200K, resulting in a gain of 201. This means that a thermocouple output of 5mv will produce an output of just over 1V. Using a gain of 500 would allow for better resolution of the temperature, but 200 is adequate for this purpose. I don't care about the actual temperature. I just need to see if the value is increasing to verify that the flame actually lighted.





I decided to build the interface on a circuit board that would plug directly into the GPIO pins on the Raspberry Pi and mount it with a Pi permanently in a project box. Here is the completed circuit board, in its enclosure, installed on the Raspberry Pi

Here is the project box with the Pi mounted inside. There are holes cut for the USB, network, and HDMI connections. I like this arrangement a lot and will use it again in the future.












Finally, this is the completed system with all the connectors labelled.








The "bubble detector" input was a last minute addition. I haven't actually built the detector yet but the design is straight forward. It will use an infrared LED and detector (sometimes called an IR gate) to see when a section of the airlock changes from water to air. Water is mostly opaque to IR light.

The pulses from the bubble detector will be very short and difficult to accurately count using a simple polling loop. I expect that it will need to be done using GPIO interrupts. I will post the code when I get that working.

Monitoring the "bubble rate" won't really produce any useful numeric data. It is only good for determining when the fermentation has completed. This is important since fermentation can stop early for various reasons and steps must be taken to correct the problem.

Finally, a warning: Working with flammable gas and boiling liquids can be hazardous. I take no responsibility for your use of the advice provided in this post.
BE CAREFUL!  And drink responsibly.

Flame Sensor Update

This is a follow up to the post on Automated Home Brewing.  There were several good ideas in the comments to that post about how to create a flame sensor.  Some require an analog input, which I describe in this post.  I have experimented now with a few methods for detecting a flame and here is what I found.

Plasma Conductance

Cool Fact - flame is a plasma and will conduct current.  I tried using two wires stuck into the flame.  The flame has a fair amount of resistance.  One of the wires was connected to 5V.  The other was connected to a voltmeter.  There were dozens of mV present when the flame was on and zero when it was not.
I think this could be used with an analog input as a flame sensor.

Thermocouple 

Thermocouple

I got a type K thermocouple and tested that directly with a voltmeter.  It only show a couple of mV with a flame on the tip.  I added a simple 100X amplification circuit and connected that to the analog input.  Now I see a range around 300-400mV and see a clear increase when the flame is on it.  One problem I saw is that the sensor has a fair amount of mass, mostly stainless steel.  Once it heats up, it takes a while for it to cool off.  As long as there is a distinct increase when the flame comes on, this could also be used for the flame sensor.

100X Amplification Circuit for Thermocouple

Digital IR Flame Detector

IR Flame Detector

Sensors are available that detect the IR signature of a flame.  Most of these provide analog output only, but I found some that also include a digital output.  This is provided by a built in level compare circuit with an adjustable level.  Because this method is so simple to interface with, this is what I decided to use.  One big problem quickly became apparent - the sensor is triggered by incandescent lights and sunlight.   It worked fine under florescent lights.




I was successful in using this configuration for brewing.  The IR sensor works, but has the false trigger problem.  It works for me but won't work in many environments.  My plan is to rebuild the brewing interface with analog input capability and try one of the other methods.

IR sensor mounted on a small block of wood and placed under the flame.

Interface to the Internet of Things with SkyNet

The Internet of Things (IoT) refers to the many servers that store data uploaded from various devices (things) connected to the Internet, which can range from weather stations, to home appliances, or a farm animal with a biochip transponder.  Even dancing robotic quad choppers.

There are many services that provide IoT support.  After experimenting with some, I settled on the SkyNet.im IoT server.  It provides several simple ways to allow machine to machine communications, including MQTT, REST, and WebSockets.  There are Python and JavaScript libraries to support it.  The API for SkyNet is fairly simple, as is using the REST protocol.  With the curl utility, you can interface to SkyNet from shell commands.

First you need to install the curl program and since I will also be calling this from a C program, I also need the development support.

sudo apt-get install curl libcurl4-gnutls-dev

To create a new device on Skynet, issue the following command (changing the parameters as you see fit)

curl -X POST -d "type=raspberry-pi-example&myvariable=12345" http://skynet.im/devices

SkyNet returns a UUID and a security token.  Save this info.  The device id is used to identify the new device and the security token allows a little security so that only someone with the token can update the data for this device.  If you really need to maintain security for the device, be sure to always update it using HTTPS.  If you use HTTP, then the session is not encrypted and someone could intercept the token and use it themselves.  Also, be aware that anyone can read your data.

To update the data for the device, issue this command.  (All one line.)

curl -X PUT -d "token=PUT-YOUR-TOKEN-HERE&myvariable=5678online=true" http://skynet.im/devices/PUT-YOUR-UUID-HERE

To view the data for a device, issue this command.

curl –X GET http://skynet.im/devices/PUT-YOUR-UUID-HERE

The function listed below provides a simple interface to SkyNet, in C, using libcurl.

Schematic for Analog Interface

A commenter asked for the schematic of the analog interface I made using an MPC3008.  I seldom include schematics with my posts for several reasons.  I don’t expect anyone to duplicate exactly what I have done, so if I post anything, it is just partial drawings of the most important concepts.  But the biggest reason is that I almost never create true schematics and I am too busy to do it just for the blog.  Something that I do frequently do is a simple drawing that helps me lay out the components onto the perf board.  Then I use that as my guide when I build the device.  These are seldom complete enough to be useful to others.  In this case, however, the entire circuit is shown.


This is what I created for the analog interface.  The 7-pin header connects to my main circuit board where I have two SPI ports – one with CE0 connected and the other with CE1.  The 3-pin header allows me to select the reference voltage for the MCP3008.  The blocks along the bottom are screw terminals.  See the post Analog Interface for a picture of how this looked when built.

I will probably be pulling this old board out again to experiment with a thermocouple that I just received.  I need it for the flame detection on my Home Brewing Automation setup.

CPU and I/O Utilization Display - Details

In the  post Server Box With Utilization Displays I showed a system which displays CPU and I/O utilization in real time.  If you are using the Raspberry Pi in GUI mode, then there are numerous tools to display this type of data on your screen, such as gnome-system-monitor or Conky.

However, when the system is used in an embedded mode (sometimes called head-less because it uses no monitor) you need alternative methods for tracking this information.  I sometimes will open an SSH connection and use shell utilities to provide this information.  Some of the options are: top, mpstat, iostat, and sar. 

I really wanted the “lots of blinking lights” effect for my server, so I developed the software below to provide that. The basic concept is to periodically (once per second, or more) read files in the /proc and /sys file systems to collect data and then update banks of LEDs appropriately.

CPU Utilization

The file /proc/stat provides a lot of information about the system, including CPU utilization.  The first line is a total for all CPUs in the system.  This is followed by lines for each individual CPU.  For the Raspberry Pi, reading the first line is all that is needed.  There are four values that we will be interested in:

• User mode CPU time – this is the time the CPU spends running programs that are in user mode at standard execution priority.
• Nice mode CPU time – this is the time the CPU spends running programs that are in user mode at a priority other than standard.  See the nice command for more info on this.
• Kernel mode time – this is the time the CPU spends running in kernel mode.  This is the protected mode that the operating system uses.  This will include things such as device drivers and system API calls as well as the core OS itself.
• Idle mode CPU time – this is the time the CPU spends doing nothing.

These values will be constantly updated, so the utilization program must track the changes over time.  It will store the values each time it computes CPU utilization and compute the change for each.  The CPU percentage utilization will be 100 x (user + nice + kernel) / (user + nice + kernel + idle)

I/O Utilization

The file /sys/block/DEVICENAME/stat provides information about the specified DEVICENAME.  The device sda is my external hard drive but you may want to use mmcblk0, the SD card.  I decided to keep this simple and only track the number of sectors read and written.  Like the CPU data, this data is constantly updated, so the change over time is what is tracked.  One difficulty with I/O utilization is that the program has no way of knowing what value 100% should be.  I provide a function to set this value, but you can simply let the program track it dynamically.  100% percent will always be the maximum usage seen so far.

Displaying the Utilization

The next challenge is to display this data.  If your system has an LCD display, you could just show the percentages directly.  Alternatively, you could make this data available via a web interface.  I chose to use 10-LED bar graphs controlled via GPIO.  You could use a single LED that lights up when a threshold is passed.  You could use 10 separate LEDs, but the multi-segment LEDs are easier to connect and take up less space.  A good compromise might be three LEDs to indicate low, medium, high and very high utilization.  The software below supports 10-segment LED displays.  I will leave the other options as an exercise for the reader.

Software

The software I am using can be obtained from google code using the git command.

git clone https://code.google.com/p/raspberrypi-utilization-display/

See the included README file for further instructions.

If you just want to browse the source code, you can do that at this address:
https://code.google.com/p/raspberrypi-utilization-display/source/browse/

This is still a very rough version of the software but should still prove useful to some.  In the future I hope to add a configuration file that will define the update rate, the number of LEDs to use, and what GPIO pins the LEDs are connected to.

Automated Home Brewing

Brewing Controller User Interface

I have been a “home brewer” in the electronic hobbyist sense for decades, but I am also a “home brewer” of beer.  I mentioned this in my post on Reading Temperature With Thermistors.

I now use digital temperature sensors (typically the DS18B20) read over an I2C bus.  Adafruit has a good tutorial on how this is done located at http://learn.adafruit.com/adafruits-raspberry-pi-lesson-11-ds18b20-temperature-sensing/overview

It is fairly common to control a refrigerator and heater to keep a constant (or slowly changing) temperature during the fermenting process, especially with lagers.  I have done this using the Raspberry Pi, thermistors, and an A/D convertor.  Now, I decided to get a lot more ambitious.

I won’t go into all the details of the brewing process since there are many resources on the web to provide that.  For a quick look at this process, see the article on my photo blog.  I wanted to be able to control at least the following items for one of the simpler methods of brewing (called partial mash.) 

• Valve to a tank of propane
• Grill ignitor to light the burner
• Sensor to detect if the burner actually did light
• Temperature sensor for the wort (the brew of water, malt extract, and hops)
• Pump for circulating water through the wort chiller

What I needed to do this:

• A relay to output 12V to control the propane valve
• Another relay to output much higher amperage of 12V to run the pump
• A relay connected in place of the button on the grill ignitor
• A connection for one or more DS18B20 temperature sensors

The hardware is described below.  I also wrote software for the Raspberry Pi (in C, my language of choice) to manage this hardware and the brewing logic.  C# .Net provides the user interface on a Windows laptop. That is the image at the top of this post. The laptop and the Pi communicate via socket calls over wifi.

There were three major problems that had to be overcome once I started testing.  One is that I tried using a DS18B20 to detect the flame.  Well, the maximum for that sensor is 125°C and I did not use a high temperature version.  The flame is VERY hot (duh!) and the sensor eventually melted, shorting 5V to ground and shutting down the Pi.  Fortunately it was not damaged.  I doubt changing to a high temperature version will help, but I will try that next.  Another option is to do what every furnace, stove, and hot water heater does for its pilot light – use a thermocouple to detect the heat.  I may have to investigate this to see if I can devise a simple interface for one.

The second problem was that the wiring for the ignitor kept shorting out and creating a spark too far from the flame to light it.  Additional insulation and a change in how it was mounted solved this problem.

The third problem was that the EMI created by the ignitor caused massive interference on the I2C bus that made it unusable.  This was corrected by re-wiring my temperature probes with well shielded cables.  I used shielded audio cables commonly used for microphones.  I am also a musician so I had some of this already.  If you have to buy a small reel you may find that it is rather expensive.  Cat-5 cable may also work well.  That is what I use for my hot tub controller, but it is not subjected to the massive EMI of this system.

I disabled the flame detection logic. This is a critical safety feature and must be corrected for this system to be trusted.  However, this did allow me to successfully use this system to brew.

This is a good place to state that working with flammable gas and boiling liquids can be hazardous.  I take no responsibility for your use of the advice provided in this post.  BE CAREFUL!  And drink responsibly.

Hardware

Control of all of the above components is pretty straight-forward.  Search my blog or the web and you will find how to control relays.  The Adafruit link above will show you how to connect the I2C temperature sensors.

I used audio connectors since they are cheap and readily available.  ¼ inch mono for the relays and stereo for the I2C bus.  Using an audio connector for the I2C bus gives the added benefit of being able to use pre-made splitters and extension cables and these tend to be well shielded and relatively inexpensive.

The 5V line from the GPIO connection is only used for the I2C bus.  I already required 12V (which is actually 13.8V) for the valve and pump.  However, the relays I used were controlled with 5V.  This voltage does not need to be accurate, so I made a simple voltage divider using three 100Ω resistors.  Two 100Ω resistors are used for R1 and one 100Ω resistor is used for R2.  This divides the input voltage by 3 to provide 4.6V, which is adequate to control the relays.

The final interface box looks like this. The red and black power connector you see is called an Anderson Power Pole.  I chose to use this since I already have 12V supplies for my HAM radio equipment.  (I think maybe I have too many hobbies.)

Modified Grill Ignitor

The ignitor can be found in many hardware stores as a replacement for repairing gas grills.  The cheaper versions of these use a spring and a piezoelectric voltage generator to create the spark.  These are not suitable for this application.  You must get the more expensive type that uses a battery.  I removed the push button and made my own connection that runs to the relay in the interface box.

I still have a few kinks to work out in this system, but I am sure that this automation will make the process of brewing much easier and more consistent.  This is definitely the most enjoyable project that I have done so far with the Raspberry Pi, and that is not just because I end up with great beer.

The system set up for brewing

The temperature sensor is a water-proof high temperature DS18B20 covered in food grade shrink tubing.  These are available at Adafruit.com

Here, the system is set up for chilling the wort.  

The cooler has water and 10 pounds of ice cubes.

Stupid Simple Tip #4

Murphy was an optimist. I have repeatedly had problems with USB cables.  USB cables are held in place only by the friction of the connector.  Repeated insertions and removals WILL wear out a USB connector.  Anyone with an old laptop has probably encountered this problem.

Another problem is in systems that get moved around a lot or are subjected to a lot of vibrations.  Here is what I did to eliminate this problem in a recent project.  Zip ties are wonderfully useful.

Server Box with Utilization Displays

A while back I built a server with the system root moved to an external hard drive.
Blog Post - Running From an External Hard Drive

That system has now failed. I shouldn't be surprised since it was built with very used parts. I decided to rebuild it and put it into a nice enclosure this time, rather than just having parts all stuck together. I also decided to add LED bar graphs to show CPU and I/O utilization.



The first step was to build the LED interface. This was accomplished using two 10-segment LED bar graphs and a GPIO extender. The GPIO extender is needed in order to drive all 20 LEDs. I used a MCP23017 I2C GPIO extender which provides 16 GPIO bits. Another 4 GPIO bits were taken directly from the Raspberry Pi.

The LED board is shown here before the GPIO lines were attached.



The next step was to attached the LED board and a Raspberry Pi to the top of the case.  The LED board is attached using epoxy with the LEDs showing through holes cut in the plastic case.  The Pi is attached using
plastic offsets and machine screws.

Notice that the analog video output connector has been removed from the Pi.  The case was just a little to tight a fit for it to work with that in the way.

A power connector will supply 5V to the LED board and to the USB hub and will use the power supply that was included with the hub.  The Pi is powered through the GPIO pins.

A hard drive salvaged from an old laptop is placed in the bottom of the case.  It is connected using an IDE to
USB adapter.  The USB cable is fed out of the case and then back in to the USB hub.  This part is a little odd, but is the only way I could get it to fit in a case this small.

Here, the power connector has been  mounted, the USB hub has been added, and all other connections have been made.  It's time to squeeze it all inside this plastic enclosure.












Here are a couple of pictures of the completed server.


















Below is a video which shows how the utilization LEDs look in action.

Stepper Motors

Stepper motors are unlike ordinary motors.  A simple motor will spin when current is applied to the coils.  Reverse the polarity of the current, and the motor spins in the opposite direction.  Stepper motors, however, contain multiple coils which can be energized individually to provide precise "stepping" of the motor.

This precise control makes them perfect for a variety of applications.  They are commonly used in floppy drives, hard drives and CD/DVD drives to precisely control the speed that the disc turns as well as where the read/write heads are positioned.  They are also used in scanners to position the scanning optics and in ink jet printers to move the paper and position the print head.  Any application that requires precise positioning is likely to use stepper motors.

For more details on the many varieties of stepper motors, see the following pages:

http://en.wikipedia.org/wiki/Stepper_motor

http://www.engineersgarage.com/articles/stepper-motors

Quick Start for Beginners - http://www.freescale.com/files/microcontrollers/doc/app_note/AN2974.pdf

Stepper Motor Basics - http://www.solarbotics.net/library/pdflib/pdf/motorbas.pdf

There are two basic methods for controlling a stepper motor.  One is to use an IC specifically designed as a stepper motor controller.  The other option is to use a microprocessor (the Raspberry Pi, in this case) to directly control the individual coils of the stepper motor.  This is the method that I demonstrate in the following video.

The code for the program used in this demo follows.

Stupid Simple Tip #3

The ribbon cable connector used for floppy disk drives on PCs can be used as a GPIO connector.

They are larger than than the Pi GPIO connector (34 vs 26 pins) so they overlap some.  These are cheap (free if you have old PCs to scavenge from.)  One problem - they won't fit in a case made for the Pi, but I have used them in cases that I built that held the Pi as well as other hardware.  If you do use this cheapskate trick, I recommend trimming the unused lines from the ribbon cable to prevent confusion.  It is also a good idea to plug the unused holes on the connector so that you don't accidentally plug it in wrong.

Stupid Simple Tip #2

The body of an old ball point pen can be easily made into a standoff of any size.  And it's hard to beat the price.

Stupid Simple Tip #1

A rubber band and a pair of pliers make an quick and easy clamp for holding components while soldering.

Interface to Wireless Driveway Sensor

I have a driveway that is over 300 feet long and it is nice to have some advance notice that someone is driving or walking in.  Previously, I have used a very expensive IR beam-break detector.  It gave a lot of false alarms and eventually failed due to a lightning strike.  It also required that I run a very long cable that could survive outdoors, which added more expense.  It’s time to switch to a wireless sensor.

I found this inexpensive one at Harbor Freight ($17 with coupon.)  It is a simple, stand-alone alarm with a receiver that just flashes some LEDs and emits a tone.  It claims to work up to 400 feet and I verified that it works to at least 350 feet, which is good enough for my application.  I created the circuit described below to interface this to my Raspberry Pi based home alarm system.

The receiver can use 3 C-batteries or a 6V adapter (not included) and I found that it would work fine on 5V.  The simplest way to get a wired signal out of the receiver is to connect to one of the LEDs.  This picture shows how I soldered a wire to the positive side of the LED.

This will provide a very brief pulse of 5V, but I need to simulate a normally open switch that connects to ground when triggered.  Also, that signal needs to lasts for at least a second to guarantee that the Raspberry Pi will see it when polling the GPIO states.

I use a 555 timer IC in monostable configuration to provide the longer pulse.  The 555 is triggered by a low pulse, so I also need an inverter.  I chose a 7404 IC because I have a stock of these reclaimed from salvage many years ago.  The output of the 555 is a high pulse that lasts 2.2 seconds with the capacitor and resistor values in this circuit.  This is used to control an NPN transistor that will provide a connection to ground as the signal output.

This circuit uses three wires to connect to the wireless receiver to provide power and read the LED state.  Put it all into a project box with some screw terminals and it is ready to connect.  I will find out over the next several days how reliable this motion detector is.  I am sure it will trigger when any deer come by it.  I am hoping that it doesn't produce a lot of false alarms.  Otherwise I will probably end up disconnecting it.

Here is the interface circuit connected to the receiver.  The white wire on the receiver is the antenna.

And here it is all put together.

Fail-Safe Circuit Using Discrete Logic Chips

When controlling a device that can present a danger to people or property, it is important to include adequate safeguards, in both software and hardware.  I now have a Raspberry Pi controlling the heater and circulation pump on my hot tub because the existing controller failed.  If the heater is left turned on indefinitely or if it is turned on without the circulation pump running, then bad things can happen.  It could produce scalding hot water or even a possible steam explosion.  Therefore, I have built in multiple safeguards in both software and in hardware.

The system has two temperature probes:  one in the water and one directly on the outlet pipe from the heater.  If the software detects the heater temperature above a certain point it will enter a failure mode and turn the heater off.  The software also assures that the circulation pump runs whenever the heater is on.  The hardware interface uses discrete logic chips to add an additional layer of protection.  An “and gate” is used to prevent the heater relay from being enabled if the pump is not also enabled.

Another more complex circuit solves another problem.  The software or the computer hardware could fail, leaving the heater turned on indefinitely.  A “clock failure detection” circuit is used to handle this issue.  For the heater relay to remain turned on, a GPIO pin must be pulsed regularly.  If this “heartbeat” is not detected, then the failsafe circuit shown below will turn the relay off. 

555 in astable mode which produces a pulse every 2.079 seconds.

Here are the components used:

• A clock source, provided by a 555 chip configured in astable mode, produces a pulse approximately once every two seconds.  Many sources on-line describe how to use this very common chip.  My configuration is shown here.

• An AND Gate, which does exactly what its name implies.

• An inverter, which changes a hi signal to low and a low signal to high.

• Four D-flops, which can be thought of as a single bit memory device.  A D-flop will store the value on its data input line when the clock line is pulsed.  It can also be set to one or cleared to zero using the PRESET and CLEAR inputs.  These are active low, which means they should normally be kept high and briefly set to low to activate the preset or clear function.  The Q pin is the output.  An inverse of this is also provided but is not used in this circuit.

Here is the complete block diagram of the fail-safe circuit.

Fail-safe circuit

I used TTL (5V) chips because I have a stock of these from long ago. 

• 555 – Monostable/Astable timer
• 7404 – Inverter (six on one chip)
• 7408 – two input AND Gate (four on one chip)
• 7474 – D-Flop (two on one chip)

Today it may be more appropriate to use CMOS (3V) chips and equivalents to the TTL chips I used can easily be found.