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.
temperature logging sensor jig above in fermentor…
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.
STEP #2
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).
#include <OneWire.h>
#include <Time.h>
int DS18S20_Pin = 2; //DS18S20 Signal pin on digital 2
//Temperature chip i/o
OneWire ds(DS18S20_Pin); // on digital pin 2
void setup(void) {
Serial.begin(9600);
}
void loop(void) {
float temperature = getTemp();
Serial.println(temperature);
delay(5000); //just here to slow down the output so it is easier to read
}
float getTemp(){
//returns the temperature from one DS18S20 in DEG Celsius
byte data[12];
byte addr[8];
if ( !ds.search(addr)) {
//no more sensors on chain, reset search
ds.reset_search();
return -1000;
}
if ( OneWire::crc8( addr, 7) != addr[7]) {
Serial.println("CRC is not valid!");
return -1000;
}
if ( addr[0] != 0x10 && addr[0] != 0x28) {
Serial.print("Device is not recognized");
return -1000;
}
ds.reset();
ds.select(addr);
ds.write(0x44,1); // start conversion, with parasite power on at the end
byte present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad
for (int i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
}
ds.reset_search();
byte MSB = data[1];
byte LSB = data[0];
float tempRead = ((MSB << 8) | LSB); //using two's compliment
float TemperatureSum = tempRead / 16;
TemperatureSum = (TemperatureSum * 9.0)/ 5.0 + 32.0; // Convert to F
return TemperatureSum;
}
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.
import serial, datetime
from datetime import datetime
LOGFILE_FORMAT = '%Y-%m-%d.dat' # could also contain a path: '/home/brewery/temperatures/%Y-%$
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S' # better make them human readable
LOGFILE_FORMAT_FILE_NAME = '/home/pi/python/datalog_onefile.dat'
def logTemperature(temperature):
if not temperature:
return; # no need to go further
now=datetime.now() # get it only once to insure consistency
logFilename=now.strftime(LOGFILE_FORMAT_FILE_NAME)
loggedTimestamp=now.strftime(TIMESTAMP_FORMAT)
logFile=open(logFilename,'a')
logFile.write(loggedTimestamp+'\t'+temperature)
logFile.close()
#define for the USB serial connection between the Raspberry Pi/Arduino Uno
ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
ser.close()
ser.open()
while True:
temperature = ser.readline()
print temperature
logTemperature(temperature)Version #2 of this code is available – https://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.
