GarData Aeroponics

GarData Aeroponics

Project description

After tons of trial and error, combined with research and talking with various sources I settled on the Aeroponics form of Hydroponics. It is a great way to conserve water and energy while maintaining robust plants. The idea is to get as much oxygen to the roots as possible, while at the same time atomizing the nutrient rich water solution into the root chamber. When the nutrients are sprayed out of nozzles at high pressure a very fine mist is formed and allows plants to uptake the nutrients much easier (the micron size in smaller, and thus more readily available to the roots).

The plants will react by adjusting their root structure to a larger surface area adsorption root (known as “hairs”). After a certain balance of absorption roots vs standard water seeking tap roots, the plants go into a hyper growth state and can process nutrients and light much faster then normal, on top of that they produce more fruiting sugar in their night “sleep” periods!

GarData is an OSHW modular approach to hydroponic garden automation and data collection. After seeing all the various offerings of the market I set out to put the Auto in Automation in an open source way. In this sense the main goal of this project is to bring cost effective automation to the makers and DIYers out there. By building an open set of hardware and software tools we hope to contribute to the growing group of high tech gardeners out there!

As shown above, GarData consists of 3 layers that form the system as a whole. The main section is the Main Control Module, and can be thought of as the brain of the system. The presentation layer provides a clean front end for data display and logging, in addition to exposing control structures of the MCM. Finally there is the interface layer, that forms an abstraction for the various types of sensors and outputs that can be controlled. Pumps, Auxiliaries, Lights, Fans, Valves and many other objects can be controlled via the various modules that can be plugged in depending on needs.

By combining COTS modules to fit the requirements, a system can be quickly and cost effectively created to automate basically any type of garden. Since time is a very integral part of a system such as this RTC and GPS time modules are considered core and therefor part of the MCM layer.

An easy way to conceptualize GarData is to use a simple example. A good start is to gather requirements and start looking at what modules are needed. This example really only has a couple requirements which are time based, we need a light to turn on at X:XX and off at Y:YY. We also will control a pump that will run about half the time or less during the night schedule, while the main feeding schedule will be during the day.
A simple Arduino and a couple relay modules is really all that is needed to cover the requirements above, to show how flexible this can be we will use an Arduino/relays combo and our Smart Relay controller to show how it can be done with varying hardware!

As the above diagrams show both examples interface the Light and pump, but where they differ is the onboard relays. On the software end these will be abstracted out through a class and delegate methods, and therefor only pin usage may differ! Also both show use of an RTC module we really like the Chronodot and Deadon modules (Macetech and Sparkfun). Alternatively a GPS unit can be used for timekeeping as well.

Lets take a quick look at each piece and see how they fit together. The RTC modules will provide an accurate time source for the Time and TimeAlarms libraries. These libraries form part of the core of the GarData firmware, and will give us a very stable and accurate time reading for a long time. The Main Control Modules will handle the programming and main collection of IO. The MCMs run Arduino bootloaders this allows a very wide range of peripherals and makes programming extremely easy. The Relay Modules hook up to a digital pins on the MCM and can control HV/HC sources such as a pumps, lights, fans, filters(these modules are very effective, and have been tested driving 1000W HID lighting).

There really isn’t much to a simple system like this, and why it makes a great example and introduction to Aeroponics. but while the hardware may be straightforward the software end of things can be a bit tricky as more modules and control options are added.

For our test setup we will be using High Pressure Aeroponics (see our build tutorial) are our main system type. By feeding with a fine mist we can eliminate the need for medium. This does mean that our cycles must be very controlled and allow accurate timing to ensure our plants get all the food and moisture they need. This may be true for many system as well, which is why this part of the software is core to GarData.

By using a RTC module paired with a well written and easy to use Time.h and TimeAlarms.h libraries we are able to create a flexible timing base that can be used by a variety of garden types. while there is overhead with using libraries such as this it makes the tasks much easier. Also by breaking out tasks to our individual modules we can offload processing to them while still allowing central control via a main “brain” module. Lets take a look at some time code.

#include <Time.h>
#include <TimeAlarms.h>
#include <DS3231RTC.h> //our RTC module
void setup()
{
 Serial.begin(57600);
 //Our RTC actually sets up the I2C interface so no need to do here
 setSyncProvider(RTC.get); // the function to get the time from the RTC
}

void loop()
{
 digitalClockDisplay(); //Display a clock msg on the serial port
 Alarm.delay(1000);
}

void digitalClockDisplay(){
 // digital clock display of the time
 Serial.print(hour());
 printDigits(minute());
 printDigits(second());
 Serial.print(" ");
 Serial.print(month());
 Serial.print(" ");
 Serial.print(day());
 Serial.print(" ");
 Serial.print(year());
 Serial.print(" ");
 Serial.print(RTC.getTemp());
 Serial.println();
}

void printDigits(int digits){
 // utility function for digital clock display
 Serial.print(":");
 if(digits < 10)
 Serial.print('0');
 Serial.print(digits);
}

Provided the RTC module has the right time(and BBU) then even after powering off or resetting we know what time it is and can carry out timers as usual! We will use the TimeAlarms library to create some timers that will allow use to trigger some actions based on delegate functions. the concept is really straightforward, since our memory is very limited in embedded systems we must conserve where we can and timers is no exception. There are many ways to improve mem usage here, one could even uses expiring timer once for everything. Although for simplicity I use the standard alarm for light actions(if needed), repeat timers for steady repetitive tasks and rolling timer once for recycle type timers that vary. Lets take a look at some code to switch on a light for 12 hours a day.

void setup()
{
//Add our timers, and initialize
Alarm.alarmRepeat(6,30,0, LightOn);  // 6:30am every day
Alarm.alarmRepeat(18,30,0,LightOff); // 6:35pm every day
}

//Finish defining our delegates
void LightOn()
{
//switch on our relay, turning a pin high for example
digital.write(PinRelayConnected,HIGH)
}

void LightOff()
{
//switch off our relay, turning a pin low for example
digital.write(PinRelayConnected,LOW)
}

Good question, and that really depends on the type of system you are trying to create. In this case we are going to use High Pressure Aeroponics, meaning we will be misting small amounts of air rich nutrients to the roots allowing plants to grow very fast when correctly tuned in. Since the misting periods are short but repeat quite often it makes sense to control this with a micro controller or some sort of control device to get accurate and repeatable results.

In this example we have created a very simple table out of 2×4’s a small piece of plywood and a compressed foam insulation piece(4×8 feet). The idea is to create a frame that will support a thick mil poly (or pond style) liner which will provide some light protection and keep the mist contained. This type of construction allows the most amount of volume for root development and seems to be quite effective at growing most plants. So far in tests we have taken a tomato and cabbage plants to fruiting without too much trouble.

Another advantage of a table like this is when placed on wheel is can be moved to well lit or direct sunlight areas, or brought into safety should stormy weather pop up!

As you can see the frame really is just a frame, the bottom slope will be strong enough to hold some excess water and roots should they make it that far. The next step is to drape the liner in, secure it and then make sure the corners and sides gently slope in and help facilitate the drain. Although there will be some water at the bottom, we don’t want too much standing water or the root style will change.

Now we just need to build our top, reservoir and hook up our plumber and controller! The top is made out of 2″ rigid foam insulation, this stuff is pretty cheap very flexible(versatile), light and easy to work with and it handles the moisture really well.

We are using a high pressure pump to generate enough pressure to create a fine mist, its the point of Aero after all 🙂 To make to table most efficient and to use the least amount of energy we need to run the pump as little as possible, the best way to accomplish this is to use an expansion tank (or a accumulator tank in well water areas). This lets you use a larger volume of water without running the pump. The air pressure and diaphragm in the tank provide a steady squeezing force of the exiting water!

It’s a bit of a mess right now but after some work it will turn out to be a handy little Aeroponics setup. There are many way to go about this, and this was meant to be a quick cheap test build. I really should clean up some of the wiring and organize it better but as you will see it works pretty well!

Well its not perfect but its working lets get some plants loaded in and begin the long process of tuning the mist and nutrient levels!

After some trial and error and a few days of rest to make sure everything settled down I loaded in some more plants and decide to let it run for a while. Some issues did pop up every once in a while. While I sorta left some of the details a little thin(I plain on adding much more detail as this is a WIP and is intended to be my MakerFaire2013 project, well at least scaled down!)

Update: Maker Faire was a huge success!! The plants and table performed exceptionally and drew quite the crowd! A big thank you to those who stopped by and showed support! Thank You!!

And here is a shot after a couple weeks of veg time, I had to make some tweaks to the nutrients and noticed that the pH will drift as they feed down, At this point I decide to add in some more sensors to help monitor everything. One of the really cool things about this build which may not be apparent from the pictures is everything including the lights are ran through an inverter and thus are “off-grid” one could very easily use solar or wind to keep this system running, of course I am using a solarium which will help augment with natural light!

GarData by Sparky’s Widgets is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.Based on a work at http://www.sparkyswidgets.com/portfolio-item/gardata/.