Beeruino // An Intelligent beer data logger and controller

Featured

20160911_170421

Beeruino – is an #arduino based data logger and controller project that I dreamt up after my second pint of #homebrew.  The difference between most people and I, are that I actually write down my ideas and later I look at them clear-headed to see if they still make sense, hence the Beeruino was born.

 

What is it made of ?

  • Black project box (Radio Shack), donated to me by a fellow brew head
  • Originally using Arduino UNO R3 // Recently upgraded to the Mega 2560 R3 (more memory!)
  • Ethernet Sheild (gives Ethernet and SD card capability)
  • Prototyping shield
  • RTC (real-time-clock) using I2C bus (give accurate date/time)
  • dual 10 amp relay module (120 volt x 10 amp = 1200 watts)
  • dual A/C sockets, independent of each other (so different things can be controlled out of each socket)
  • 4×20 LCD screen using the I2C bus (not to be confused with 420, that’s something different)
  • ON/OFF switch
  • Arduino sketch C++ code
  • USB Cable
  • Power Cable to power the A/C sockets
  • Analog buttons to change the set goal temperature UP or DOWN on the control relay

Beeruino now has control buttons and Version 2 of the code has been released.  They allow you to control the target goal temperature without the need to change the value manually and no need to recompile the program using the computer, making it more and more independent.

All the versions of the code are maintained GitHub: https://github.com/rompstar/beeruino

 

Beer Fermentation Beer Data Logger // Beer Analytics

Update: since this blog was written, the Project was transferred to a more professional looking project box and is now called the Beeruino, please search to see that blog – also code has been posted to Git.

parts used:

  1. empty cigar box (smaller plastic project boxes also are ideal, but cigar box was free)
  2. Arduino UNO R3
  3. Arduino UNO R3 compatible ethernet shield + SD card that plugs into the SD slot
  4. two Dallas 1-wire temperature sensors (1 meter long, internal cable length was extended)
  5. 4×20 blue LCD Screen – works over I2C
  6. an RTC (real-time-clock), also works over I2C
  7. miscellaneous: wires, shrink wraps, hot glue, plastic wire ties and some light soldering

If you are one of those people – who is reading this and inside your head you are saying “why the hell should I do any of this shit, I just buy!!” – guess what, you are not a Maker and you will learn nothing from buying things that others have created.  Once you learn, you have full control over your creation and any future ideas/goals, you are not tied to a product that someone else has created.

In this quick blog I wanted to share a quick story about how I converted an empty cigar box into a data logger.  It uses the Arduino Uno and two Dallas 1-wire sensor to capture and record both the internal temperature inside the fermentor and the external temperature (outside the fermentor), so that we have a base to compare against.  You should see a higher temperature inside, because when yeast ferments, that is considered an exothermic process – https://en.wikipedia.org/wiki/Exothermic_process

The primary goal was to create a small, portable system (small size and weight wise) and also for it to be independent, meaning be able to do everything on its own without external dependencies like the internet, or some network, at this stage we don’t want to send live data to the internet or log to a database // but those things can certainly be done and in the future can be nice to have.

To have this system somewhat nice, I have added a 4×20 blue LCD screen – it uses the I2C interface to make the hook up easy.  Also an RTC (real-time-clock) was installed to work on the same I2C bus, this adds date+time.

In addition I have used 4-pin aviation plugs to make the sensors connection modular, so that they can be easily unplugged (cleaning or swapping) without messing with the internal electronics or wires…

Hot glue was used to stick things in place inside the cigar box, along with some limited soldering, and shrink-wrap, and wire ties to keep things organized and properly connected for solid connections.

The programming code is not super complex, and it being shared below:

It assumes that the external temp. sensor is being pulled from index(0) and internal from index(1).  Having the temp sensors assigned to a static index will allow you to switch the aviation plugs and still have them assigned correctly and display from the right sensor without having to worry about which plug which should be.

A quick video and Arduino C++ code below…

The data is recorded on an SD card (inside the ethernet shield) which is plugged-in on top of the Arduino UNO R3.

 

 

Version 2.0 // Python temperature logging script Arduino + Raspberry Pi

temp_jig

Above is a temperature probe jig, it captures and logs the temperature from inside of the fermentor.

beer_sample_plot2

Plotting the data using a web API:

The plot above was generated using sample data and the service – https://plot.ly ( once you capture the data, you can upload your data_file.dat there and with a few clicks, make the graph ) – until you learn how to manually write the plot code in python.

Plotting the data using python code:

In the python code for the log – if you use this line to capture the data, then you can manually run the python code and it should generate a plot if you installed python right with all the necessary modules – this is considered machine readable the way that time.time is written to the file.  If you use the DATE/TIME instead, then I haven’t figured this out yep, so we use the web API (above) and upload the data and generate the graph like that.

a quick python plot example below:

plot

sample code to generate a plot from the sample data.

 

Dynamic Temperature Python script…

Version 2.0 // logging of temperature code with appended date.  This version checks to see if the previous recorded sample is the same, if it is, it is skipped and not recorded.  This is useful to have when you are wanting to monitor and record temperatures over a long time, like months or a year and not waste data space on repeating values.

This code can be pretty much used with any temperature sensor, we use it with the Dallas DS18S20.

Let me briefly explain what the code is doing ( from top to bottom ), but I strongly recommend that you take some basic classes on Python, we are still learning it too :- ) that is the only way to take full advantage of it and learn a new skill – Python is a good thing to have on your resume these days too :- )

Special thanks go to “Ofnuts” (the person who helped up with the syntax to get this done from the python help forum)!

  1. we are importing some modules
  2. we are setting up some variables like LOGFILE_FORMAT & TIMESTAMP
  3. def – means defining a function, so we are defining a function called: logTemperature() – it does the logging of the temperature with an appending timestamp to a text file
  4. setup the serial connection from the Arduino over the USB cable
  5. last_temp_reading = – 273 (we are setting up a unrealistic condition for comparison temperature)
  6. the rest of the code checks for a clean string coming from the Arduino and converting it into a float so that an inequality check can be done
  7. a lot of the extra Printing was also done to test, you can take those out if you are not going to be looking at the screen and running the command in the background using nohup.
  8. If you know Python remove and add whatever you need and share with us if you end up doing something cool

 

 

Arduino + Raspberry Pi to measure fermentation temperature

This is the original Version #1 // it will get you going – please see Version #2 for the dynamic sensor processing and more on plotting the data using an API and code.

temp_jig

temperature logging sensor jig above in fermentor…

IMAG0398

Above on the left (Raspberry Pi), middle (breadboard), right (Arduino UNO) – this web site runs on the Pi and you are reading this article right now from it :- )

Home Brewing is more than just the act of beer brewing at home to many people // it is a hobby filled with lots of creativity, ideas and passion.  One of our goals was to capture accurate temperature measurements of the fermentation – once you capture the data you can do things with it.

We decided to use a digital 3 wire temperature sensor also referred to as a 1-wire system, because the data is sent over 1 wire, the other two are the volt and ground cable.

We used a DS18S20 Dallas 1-Wire digital thermometer, this sensor is digital and fairly accurate and the program can delivery the data in C or F or whatever you can program for, and it can send the signal over longer distances than an analog thermister.  Also you can have multiple digital readers on the same wire, since each one is identified with a digital ID and you can separate the sensors within the programming code.

http://pdfserv.maximintegrated.com/en/ds/DS18S20.pdf

STEP #1

Setup the Arduino + Raspberry driver software // Google this and do it on your own…

So in our setup we used an Arduino UNO connected via the USB cable to a Raspberry Pi B, and the Pi also powers the Arduino, get a better 2.0+ Amp power supply for the Pi, ours is 2.5 Amp. You also have to install drivers that allow the two to communicate over the USB cable (serial) connection of the cable.

STEP #1.1

You need to connect the sensor correctly to a 4.7K ohm pull-up resistor, we used a breadboard to help us with the connections, but you can prototype it better.  The breadboard will connect to the Arduino, below a simple way to show the connections of the cables.  The C code is setup to receive the input on pin 2.

DS18S20-hookup

STEP #2

Arduino

Get a program working in C (language) on the Arduino loaded correctly through the IDE, to read the temperature from the sensor – you will have to learn how to do this part and be overall familiar with the basics of how to use the Arduino.    If you never done this before, (go learn that and then come back to do this step), we are sharing the code that we use below, it compiles fine, you might have to install some dependencies, like the OneWire and Time libraries (learn that too).

 

 

STEP #3

Use a Python script on the Rasberrpy Pi to read the signal data being sent by the Arduino, see examples of what we actually use right now below.  This script not only reads the data from the Arduino over the (serial USB) cable but also logs the data to a (tab delimited) text file while appending date/time stamp for each point reading, it does this every 5 seconds.  5 seconds could be an overkill for your project, maybe you want it every 30 seconds, it all depends what you are after and the resolution of the data capture that you need.

Version #2 of this code is available – http://kodiakbrewing.com/wordpress/?p=4172 // it ignores a temp sample if it incoming the same as the one just recorded, saving space if you are recording remotely over long time.

STEP #4

Do a test and record some data for a few days or a few weeks in the background using (nohup), you will have to learn Linux as well.  Run the script basically for a few days or weeks and then learn how to graph the data captured in whatever you see fit best way.  Once you have the data in a flat-file, you can transfer it over network and open the data with many different programs to create a temperature/date-time graph.  You can also use Python to create the graphs as well, etc…

We used a free program (Plot2) on a Mac to open the flat text file to read the data and it would actually automatically plot a graph.  Keep in mind that if you record a test sample of say 2 weeks (of stable temperature that don’t vary much), you will see mostly a flat line, but during fermentation you will see a spike of a few days and then a slow decline as the fermentation finishes off – but as tests go for (code and the sensor) – this is a good start.

So think about it, here you learn about the Arduino, and the Raspberry Pi and Linux, and text files to capture the data and C/Python programming languages, and how to graph the data, this is just scratching the surface.   You can take this much further, from displaying the temperature live on an LCD screen, to graphing it live on a LCD screen, to writing more program code and maybe even regulate a heater band over the fermentor to control the fermentation temperate after the yeast finishes its job, to deal with off-flavors for example and many other things, not just temperature.

You also see the min() and max() ranges the yeast temperature was reached during the reaction time of the fermentation to see if you hit the manufacturers recommended temp ranges, just yet another example of the data’s value.

Bottom line is that you not only learn new things, but capture useful data that you can analyze on and take action with – to in the end improve and make great beer.

Updates will come later with additional data, all our future beers will come with a fermentation charts of the overall process of the yeast used.

Also check out the – https://wizbrewery.wordpress.com/  Waldy the Wiz, also makes a great project and he shares all of his hard work – his is a little bit more advanced than our example.

Screen Shot 2015-10-19 at 7.40.50 PM