Welcome!

I created this blog to document the progress of my beer brewing and automation project.

I began by learning to brew 1-gallon batches of beer by hand, and then created a heating automation setup to control the temperature as I brewed. With this setup, I brewed a few more batches in order to test and improve the process. My posts range from informative posts on my setup to tastings and calorie information.

Here are a few of the automation highlights:

Detailed Wiring of Full Setup
Heater Cable Rewiring and Added Safety Elements
Arduino Code

Please keep in mind, the posts appear from newest to oldest, so feel free to check out some of the links on the sidebar to find the information you are looking for!

Grapefruit IPA Tasting and Code (8/29/16)

Finally my last batch (for now) is finished:

Unfortunately, I don't think the seal on some of the bottles was very good, so it did not carbonate very well. It's possible something went wrong with my bottle capper after my last batch when it went on crooked and broke a bottle, or maybe I was just too timid this time with using it. Otherwise, the beer was pretty clear and fresh tasting with the grapefruit flavoring, but wasn't my favorite flavor. Of the people who tried it, some liked it and some didn't, so who knows if it turned out the way it was supposed to. I'll have to try again one day to make sure.

I also wanted to include the code I used when brewing this batch. It is pretty similar to my original code, but I changed the alerts to be specific to this recipe, and changed the heating mechanism during the boil - I also added this change in as an edit to my old code post from 7/4/16. This served to turn off the heater until the water fell a few degrees, so that less liquid was lost during the boil as compared to having the heater on the whole time.
  #include <Time.h> #include <TimeLib.h> #include <OneWire.h> // Adapted from "OneWire DS18S20, DS18B20, DS1822 Temperature Example" by Sonia Holar and Christian Volz - July 2016 // Procedure for Grapefruit IPA // // http://www.pjrc.com/teensy/td_libs_OneWire.hTimel // // The DallasTemperature library can do all this work for you! // http://milesburton.com/Dallas_Temperature_Control_Library OneWire ds(2); // probe on pin 2 #define RELAY_PIN 10 //relay pin 10 const int buzzerPin = 9; //piezo buzzer on pin 9 int x = 0; int y = 0; int SteepStart = 50000; //steep and boil starts set high so that timing if-statements //later cannot be true until these get set to actual reasonable values later int Stage1 = 1; int Stage2 = 0; int reachBoil = 0; int boilStart = 50000; //my added variables void setup(void) { pinMode(RELAY_PIN, OUTPUT); pinMode(buzzerPin, OUTPUT); Serial.begin(9600); tone(buzzerPin,1000,1000); //beep once on startup } void loop(void) { byte i; byte present = 0; byte type_s; byte data[12]; byte addr[8]; float celsius, fahrenheit; if ( !ds.search(addr)) { Serial.println("No more addresses."); Serial.println(); ds.reset_search(); delay(250); return; } Serial.print("ROM ="); for( i = 0; i < 8; i++) { Serial.write(' '); Serial.print(addr[i], HEX); } if (OneWire::crc8(addr, 7) != addr[7]) { Serial.println("CRC is not valid!"); return; } Serial.println(); // the first ROM byte indicates which chip switch (addr[0]) { case 0x10: Serial.println(" Chip = DS18S20"); // or old DS1820 type_s = 1; break; case 0x28: Serial.println(" Chip = DS18B20"); type_s = 0; break; case 0x22: Serial.println(" Chip = DS1822"); type_s = 0; break; default: Serial.println("Device is not a DS18x20 family device."); return; } ds.reset(); ds.select(addr); ds.write(0x44,1); // start conversion, with parasite power on at the end delay(1000); // maybe 750ms is enough, maybe not // we might do a ds.depower() here, but the reset will take care of it. present = ds.reset(); ds.select(addr); ds.write(0xBE); // Read Scratchpad Serial.print(" Data = "); Serial.print(present,HEX); Serial.print(" "); for ( i = 0; i < 9; i++) { // we need 9 bytes data[i] = ds.read(); Serial.print(data[i], HEX); Serial.print(" "); } Serial.print(" CRC="); Serial.print(OneWire::crc8(data, 8), HEX); Serial.println(); // convert the data to actual temperature unsigned int raw = (data[1] << 8) | data[0]; if (type_s) { raw = raw << 3; // 9 bit resolution default if (data[7] == 0x10) { // count remain gives full 12 bit resolution raw = (raw & 0xFFF0) + 12 - data[6]; } } else { byte cfg = (data[4] & 0x60); if (cfg == 0x00) raw = raw << 3; // 9 bit resolution, 93.75 ms else if (cfg == 0x20) raw = raw << 2; // 10 bit res, 187.5 ms else if (cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms // default is 12 bit resolution, 750 ms conversion Time } celsius = (float)raw / 16.0; fahrenheit = celsius * 1.8 + 32.0; Serial.print(" Temperature = "); Serial.print(celsius); Serial.print(" Celsius, "); Serial.print(fahrenheit); Serial.println(" Fahrenheit"); //MY CODE: if (Stage1 == 1) { //stage1 = heating up and then steeping grains Serial.println(x); Serial.println(y); Serial.println(Stage1); Serial.println(Stage2); Serial.println(now()); //just for our information/to make sure everything works properly if (fahrenheit >= 160){ digitalWrite(RELAY_PIN, LOW); //turn off heat Serial.println("Relay off"); if (x==0){ x=1; } } else if (fahrenheit <= 155){ digitalWrite(RELAY_PIN, HIGH); //turn on heat Serial.println("Relay on stage 1"); } } if (y!=x){ SteepStart = now(); tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.print("NEW SteepStart: "); Serial.println(SteepStart); y=x; Serial.println("Add grains");//alert us to add grains } if (now() >= (SteepStart+1200) && now() < (SteepStart+1210)){ //at 20 min mark Stage1 = 0; Stage2 = 1; tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("Remove grains");//alert us to remove grains } if (Stage2 == 1){ //stage2 = bring to boil and maintain 60 mins Serial.println(x); Serial.println(y); Serial.println(Stage1); Serial.println(Stage2); Serial.println(now()); if (fahrenheit <= 203){ digitalWrite(RELAY_PIN, HIGH); //heat on Serial.println("Relay on stage 2"); } else if (fahrenheit >= 205){ digitalWrite(RELAY_PIN, LOW); //heat off - want to prevent losing too much water by just leaving heat on during all of boil if (reachBoil == 0){ tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) reachBoil = 1; boilStart = now(); Serial.print("boilStart set to "); Serial.println(boilStart); Serial.println("Add DME and first hops"); //alert us to add DME } } } if (now() >= (boilStart+2400) && now() <= (boilStart+2410)){ tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("40 min have passed, add next hops");//alert us 40 min mark } if (now() >= (boilStart+3000) && now() <= (boilStart+3010)){ tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("10 min have passed, add next hops");//alert us 10 min mark } if (now() >= (boilStart+3300) && now() <= (boilStart+3310)){ tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("5 min have passed, add spice pack");//alert us 5 min mark } if (now() >= (boilStart+3600) && now() <= (boilStart+3610)){ digitalWrite(RELAY_PIN, LOW);//heat off tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("5 min passed, Relay off"); //alert us 5 min mark Stage2 = 0; //end stage 2 } }

This will be my last post for now, although I do plan to keep brewing when I have the time, and hopefully improve my automation and even add new elements to it (I have a few more ideas to explore). I hope this blog was informative and helpful to anyone trying something similar!

Bottling IPA and Cider Tasting (8/9/16)

I bottled my grapefruit IPA today:

This beer should have 170 calories in 12 oz, and is 5.1% ABV.

As usual, I used my auto-siphon to do so. However, as you may have seen in an earlier post, I was using the tubing as a blowoff tube for the IPA while it fermented, and because of this it got very dirty inside.

The siphon looks like this:

Just pumping water through the tube did not clean all the sediment and debris off the sides, so what I did to clean it was cut a corner off of a sponge, insert it into the tubing at the connection indicated by the arrow, reattach the connection, and pump the sponge all through the tubing, then remove it at the second connection of tubing on the right. This pulled all the debris right out so I could sanitize the siphon and begin my bottling.

I also tried the cider today! It was good, especially considering I didn't use much at all to make it (see my cider post). I think priming with apple juice was a good idea, it tasted sweet and apple-y.

Mandarina Pale Ale Tasting (8/3/16)

Today I tasted the finished Mandarina pale ale. It was really good - a light flavor, with some subtle citrus tones. It was a pretty normal pale ale, and although I think I liked the red ale better, I think this one turned out really well. 

We drank it along with a meal of schnitzel and potatoes, which it went really well with. 

I don't have much to post about since summer is coming to an end and I can't make more batches as they won't be ready before I have to go back to school. Next week I'll bottle the IPA and taste the cider, and then later taste the IPA - after that we'll see what I can get going back at school.

I also recently tried "frozen beer" at a restaurant I went to, and it was pretty good!

I ordered a summer shandy and was told they had a frozen version, so I tried it. It was basically a glass of beer with a frozen foam-looking topper. The topper is made from the beer itself, lemon liquor, and some other things the waiter didn't mention, I assume - I'd love to learn to make it though! The beer was fruity to start with, so this drink was pretty lemony and sweet, which I liked for a frozen drink, but they did also have another type that was not so sweet which would be cool to try. 

Fermentation Overflow (7/26/16)

Yesterday, I started the fermentation of my grapefruit IPA. I previously edited my heat control code to turn the heater off during the boiling stage until the temperature dropped too far, which I think caused less water to boil off during the process. This meant I had more wort to fill my 1 gallon carboy compared to with previous batches. Yay, more beer - but today I noticed that the fermenter had overflowed into the airlock:

I cleaned out the airlock, refilled it with water, and put it back on the bottle, but a couple hours later it had overflowed again. So, I rigged up a blow off tube:

This functions the same way as the airlock, but leaves more room in the tubing for foam to escape without clogging.

You can see the bubbles coming out as the beer continues to ferment.

Bottling Hard Cider - Priming with Juice (7/26/16)

Today I am bottling my hard cider, which has been fermenting for two weeks.

Normally, I prime my beer with sugar right before bottling so that the yeast eat the extra sugar and carbonate the beer over the next two weeks. For the cider, I will be priming with apple juice instead to give the final cider a more apple-y, sweet flavor.

For a 1-gallon batch of beer I use 1 oz of priming sugar, which is ~28 g. The apple juice I purchased has 28 g sugar per 8 fl oz (1 cup) so I will be adding that much juice to my cider before bottling it and letting it carbonate for two more weeks.

The cider's FG was 1.011 (and the OG was 1.063), so the cider is around 6.8% alcohol and 211 calories per 12 oz bottle.

However, the calorie count isn't exact because this was before I added the cup of apple juice - adding it changed the FG to 1.013, making a 12 oz bottle 212 calories according to the calculator from my last post. This is odd because the apple juice has 110 calories per cup, which should have added 10 calories to each of my 11 bottles. I'm not sure how that works since some of the sugars will be consumed in carbonation, so maybe I can take a final specific gravity reading on a finished bottle and find out. Still, we know it is somewhere around this level of calories.

Also, this is what happens when your bottle capper goes on crooked - don't keep pushing! To save some of the cider, I filtered it twice to make sure there was no glass in it and used a new bottle.

Calories in my Beer (7/25/16)

I heard that craft and homebrewed beers tend to be higher in calories than mass produced beers and I was curious and decided to look up how to calculate the calories in my beer.

I found this calculator which uses OG and FG - original and final specific gravity - to calculate the calories in beer. This calculation combines the calories from alcohol and unfermented sugars in the final product.

There are about 7 calories per gram of ethanol, and 4 cal/g of carbohydrates, and the OG and FG can be used to determine the ethanol and sugar content of the beer.

For more information on the formulas, check out these two sources - the first is very detailed and the second is easier to follow and calculate but it is less clear where the values in the formulas come from.

For my two batches of beer, here are the results for a 12 oz bottle:

American Red Ale = 207 cal

Mandarina Pale Ale = 179 cal

This graph from this article shows the calories in 12 oz of some popular beer brands:

Compared to these beers, it looks like mine are on the high end calorie-wise, but that may not be true for all homebrewed beer. Anyway, the first batch was delicious so I can't complain!

Also, today I brewed my next batch, a grapefruit IPA, which is now fermenting.The new setup with grounding worked with no issues. My mandarina pale ale should be done next week, and the cider the week after, so there is lots of good beer to come!

Full Setup with Added Safety Elements (7/21/16)

Today I finished setting up my new safety measures (adding junction boxes and grounding). Here is the whole setup:

Grounding Procedure: 

The supplies:

• 14/3 cable (I purchased 10 ft)
• I chose this gauge because my required current for the heater is power/voltage = 1000 W/120 V = 8.333 A and according to this chart (http://www.amplepower.com/primer/gauge/) 14 gauge seemed reasonable
• Grounding plug with clamp
• Metal 4x4 outlet box
• Soldering iron and electric solder
• Optional: aluminum foil tape to cover solder points on metal objects

1. Attach the plug to the cable: 

I stripped the cable and screwed each wire into its respective spot on the plug.

The finished plug, with a clamp to hold the cable in place.

I also tested it with a digital multimeter to make sure that none of the wires inside were touching and each wire on the other end of the cable led to the correct prong.

2. Attach the other end of the cable to the heater and junction box:

• Neutral wire soldered to neutral wire coming from heater and electric taped
• Hot wire connected to heater through relay (heater end on 1 and plug end on 2)
• Ground wire screwed into junction box

*I checked the connection between the ground prong on the plug and the metal box with a DMM.

3. Connect kettle and heater via ground wire to outlet box:

• Solder wire to top metal section of heater and cover with foil tape
• Solder another wire to the pot and cover with foil tape
• This tape is supposed to hold at up to 200 F, so we will see how it fares on the pot during the boil stage
• Solder the two wires (green coming from heater and white coming from pot) together and screw into junction box 

*I also checked the connection between the ground prong and both the heater and pot

Last, here is a picture of the new junction box for the arduino and breadboard:

I am really excited to test this out on my next batch!

SAFETY (7/15/16)

After completing my temperature automation setup, I discovered (thanks Reddit) that it is not as safe as it should be. Here is a schematic of what I plan on implementing safety-wise:

• Use GFCI outlet (I have been all along, just never mentioned it) - these measure difference in current running in the hot and neutral wires, which should always be zero, and shuts off the power if there is any difference, which would be caused by the current flowing through an alternate path such as a person or water
• Junction boxes around wired elements to protect people from shock and the wires from water or other damage (probably plastic for the arduino/breadboard and metal around the relay because it can get hot)
• Ground the metal box and brew pot/kettle so that if they become electrified the electricity has somewhere to go - I also may ground the heater by soldering a wire to the upper exposed metal

I based the grounding technique on this setup from The Electric Brewery (Step 6): 

http://www.theelectricbrewery.com/node/9?page=show

After I finish researching and actually set this up I will make another post with the results.

Full Detailed Explanation of Temperature Automation Setup (7/14/16)

IMPORTANT: See my upcoming post on safety before actually running this setup! 

I wanted to make a post with an overview of my whole setup at this point, in case anyone out there is looking to do something similar and has as little experience with electronics as I did. 

Here is my brew automation setup:

1. Arduino Uno: 
• USB connection to laptop for uploading code
• Power and ground connected to breadboard
• Pins connected to temperature probe, heater (via relay), and piezo buzzer
2. Temperature Probe:
• Red wire connected to power on breadboard
• Black to ground on breadboard
• 4.7k ohm resistor between power on breadboard and row containing white wire (data) and another wire to pin on arduino
3. Relay/Heater:
• Cord cut, hot and neutral wires separated 
• Neutral wire reconnected with wire nut
• End of hot wire connected to heater attached to 1 on relay
• End of hot wire connected to plug attached to 2 on relay
• 4- on relay attached to ground
• 3+ on relay attached to pin on arduino
4. Piezo Buzzer:
• Red wire connected to pin
• Black wire to ground

Using this setup, I can write code (in the free Arduino software) that is specific to my brew process. It automatically controls the temperature for any period of time and alerts me with the buzzer when it is time to add the next ingredient.

You can see an example of the code for a mandarina pale ale in one of my previous posts ("Heating Automation Code...").

Note: Adding ingredients must still be done by hand, as must the ice bath to cool the wort and the pumping to the fermentation vessels and bottling. I may partially automate these in the future by adding a wort chiller or a pump.

Making Cider and Tasting First Batch (7/12/16)

Today I decided I wanted to try making some hard cider since I had extra ale yeast and an open fermentation bucket (I have a bucket and a carboy, for primary and secondary fermentation, and the mandarina pale ale is in the carboy now). There are better yeasts out there for cider but since I already had this kind from my other beer kits I figured I'd use it on some cheap apple juice.

Ingredients:

• 1 gallon apple juice (NO preservatives - they inhibit yeast activity)
• ~1 cup light brown sugar (can use dark or light, different recipes call for either)
• 1 tsp ale yeast

I also put vodka in the airlock because I read a tip online: bacteria can't grow in it and if you get some vodka in your cider who cares? Who knows how this will turn out - I will let you know!

(Note to self: starting specific gravity was 1.063)

Also, my first batch, the american red ale, is finished carbonating. Here are a couple pictures of how it turned out:

 

I'm happy to say it was really good! It carbonated well and tasted slightly sweet. I'm not too good with beer descriptions but it was pretty smooth and somewhat light, but still had body. It was somewhere between a lager and a pale ale I would say. Overall a success. 

Heating Automation Code and Brew Day Test (7/4/16)

In order to automate the heating during the brew, I modified the existing code for the temperature probe, which I got from an Arduino example (see my post about the temperature probe). Basically, I kept the temperature probe functionality and just added in some conditions for the stages of my next brew, which is a mandarina pale ale.

Automated so far:

• Heating up to 150-165 F
• Maintaining heat in that range for 20 minutes while grains steep
• Bringing to a boil
• Alerts for adding ingredients at certain time points during the boil

However, the alerts only pop up on the serial monitor on my laptop, so I am hoping to buy an LCD screen and piezo buzzer to make noise and display the next step. 

With the code finished, today was brew day!

The ingredients.

The setup.

Boiling wort.

Post-brew ice bath.

The wort is now fermenting, and this time the recipe calls for a two-stage fermentation process, so I will be moving it to a secondary fermenter after 4-6 days.

UPDATE 7/9/16: Here is the code I used, which has now been tested during this run as well as another time to fix a few bugs, and seems to run perfectly now (note: I also bought a piezo buzzer to alert us when the next ingredient should be added and put that in the code):

#include <Time.h> #include <TimeLib.h> #include <OneWire.h> // Adapted from "OneWire DS18S20, DS18B20, DS1822 Temperature Example" by Sonia Holar and Christian Volz - July 2016 // Procedure for Mandarina Pale Ale // // http://www.pjrc.com/teensy/td_libs_OneWire.hTimel // // The DallasTemperature library can do all this work for you! // http://milesburton.com/Dallas_Temperature_Control_Library OneWire ds(2); // probe on pin 2 #define RELAY_PIN 10 //relay pin 10 const int buzzerPin = 9; //piezo buzzer on pin 9 int x = 0; int y = 0; int SteepStart = 50000; int Stage1 = 1; int Stage2 = 0; int reachBoil = 0; int boilStart = 50000; //my added variables void setup(void) { pinMode(RELAY_PIN, OUTPUT); pinMode(buzzerPin, OUTPUT); Serial.begin(9600); tone(buzzerPin,1000,1000); //beep once on startup } void loop(void) { byte i; byte present = 0; byte type_s; byte data[12]; byte addr[8]; float celsius, fahrenheit; if ( !ds.search(addr)) { Serial.println("No more addresses."); Serial.println(); ds.reset_search(); delay(250); return; } Serial.print("ROM ="); for( i = 0; i < 8; i++) { Serial.write(' '); Serial.print(addr[i], HEX); } if (OneWire::crc8(addr, 7) != addr[7]) { Serial.println("CRC is not valid!"); return; } Serial.println(); // the first ROM byte indicates which chip switch (addr[0]) { case 0x10: Serial.println(" Chip = DS18S20"); // or old DS1820 type_s = 1; break; case 0x28: Serial.println(" Chip = DS18B20"); type_s = 0; break; case 0x22: Serial.println(" Chip = DS1822"); type_s = 0; break; default: Serial.println("Device is not a DS18x20 family device."); return; } ds.reset(); ds.select(addr); ds.write(0x44,1); // start conversion, with parasite power on at the end delay(1000); // maybe 750ms is enough, maybe not // we might do a ds.depower() here, but the reset will take care of it. present = ds.reset(); ds.select(addr); ds.write(0xBE); // Read Scratchpad Serial.print(" Data = "); Serial.print(present,HEX); Serial.print(" "); for ( i = 0; i < 9; i++) { // we need 9 bytes data[i] = ds.read(); Serial.print(data[i], HEX); Serial.print(" "); } Serial.print(" CRC="); Serial.print(OneWire::crc8(data, 8), HEX); Serial.println(); // convert the data to actual temperature unsigned int raw = (data[1] << 8) | data[0]; if (type_s) { raw = raw << 3; // 9 bit resolution default if (data[7] == 0x10) { // count remain gives full 12 bit resolution raw = (raw & 0xFFF0) + 12 - data[6]; } } else { byte cfg = (data[4] & 0x60); if (cfg == 0x00) raw = raw << 3; // 9 bit resolution, 93.75 ms else if (cfg == 0x20) raw = raw << 2; // 10 bit res, 187.5 ms else if (cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms // default is 12 bit resolution, 750 ms conversion Time } celsius = (float)raw / 16.0; fahrenheit = celsius * 1.8 + 32.0; Serial.print(" Temperature = "); Serial.print(celsius); Serial.print(" Celsius, "); Serial.print(fahrenheit); Serial.println(" Fahrenheit"); //MY CODE: if (Stage1 == 1) { //stage1 = heating up and then steeping grains Serial.println(x); Serial.println(y); Serial.println(Stage1); Serial.println(Stage2); Serial.println(now()); //just for our information/to make sure everything works properly if (fahrenheit >= 160){ digitalWrite(RELAY_PIN, LOW); //turn off heat Serial.println("Relay off"); if (x==0){ x=1; } } else if (fahrenheit <= 155){ digitalWrite(RELAY_PIN, HIGH); //turn on heat Serial.println("Relay on stage 1"); } } if (y!=x){ SteepStart = now(); tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.print("NEW SteepStart: "); Serial.println(SteepStart); y=x; Serial.println("Add grains");//alert us to add grains } if (now() >= (SteepStart+1200) && now() < (SteepStart+1210)){ //at 20 min mark Stage1 = 0; Stage2 = 1; tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("Remove grains");//alert us to remove grains } if (Stage2 == 1){ //stage2 = bring to boil and maintain 60 mins digitalWrite(RELAY_PIN, HIGH); //heat on Serial.println(x); Serial.println(y); Serial.println(Stage1); Serial.println(Stage2); Serial.println(now()); Serial.println("Relay on stage 2"); if (fahrenheit >= 205) if (reachBoil == 0){ tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) reachBoil = 1; boilStart = now(); Serial.print("boilStart set to "); Serial.println(boilStart); Serial.println("Add DME and first hops"); //alert us to add DME } } if (now() >= (boilStart+2700) && now() <= (boilStart+2710)){ tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("45 min have passed, add next hops");//alert us 45 min mark } if (now() >= (boilStart+3300) && now() <= (boilStart+3310)){ tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("10 min have passed, add next hops");//alert us 10 min mark } if (now() >= (boilStart+3600) && now() <= (boilStart+3610)){ digitalWrite(RELAY_PIN, LOW);//heat off tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) Serial.println("5 min passed, Relay off"); //alert us 5 min mark Stage2 = 0; //end stage 2 } //add alert for 70F in ice bath //Heat to 150-165F, maintain for 20 mins (steeping) //Bring to boil (212F) - add DME, then first hops //Maintain boil 45 min, add hops; 10 min, add hops; 5 min, turn off heat //Ice bath - want T to fall to 70F }

UPDATE 8/10/16: I forgot until now that I added a part to the code that turns the heater off during the boiling stage and back on below a certain temperature, instead of having the heater on the full 60 minutes of boiling - this allows for less loss of liquid, which means more wort to turn in to beer at the end! Instead of turning the heat on in stage 2, I inserted the following:

if (Stage2 == 1){ //stage2 = bring to boil and maintain 60 mins if (fahrenheit <= 203){ digitalWrite(RELAY_PIN, HIGH); //heat on Serial.println("Relay on stage 2"); } else if (fahrenheit >= 205){ digitalWrite(RELAY_PIN, LOW); //heat off - want to prevent losing too much water by just leaving heat on during all of boil if (reachBoil == 0){ tone(buzzerPin, 1000, 1000); //(pin,frequency,duration in ms) reachBoil = 1; boilStart = now(); Serial.print("boilStart set to "); Serial.println(boilStart); Serial.println("Add DME and first hops"); //alert us to add DME } }

I chose the temperature cutoffs of 203 and 205 from observing the brewing process with this heater. Generally, it would not go far above 205 F once it started boiling, and would completely stop bubbling around 203 F.

Heater-Relay-Arduino Setup (7/1/16)

My immersion water heater and relay (SSR-25DA) arrived in the mail, so today I will be talking about how I set that all up.

IMPORTANT: When using something like this immersion heater, make sure you are plugged into a GFCI outlet to prevent electric shock. I will be making a post about safety measures in the future so check that out if it exists for more information.

1. Test heater by boiling a pot of water
This was to make sure it worked before I cut the cord and wired it to the relay and arduino, and to take a few process planning notes for myself.

Note: I am going to fix the whole wood-plank-heater setup (make more secure, etc.), this was just something I threw together for testing. I don't want the heater coil to touch the pot because it is using electricity to heat and that could be dangerous since the pot is metal.

Using the temperature probe and arduino to measure while I boiled the water.

2. Cut the cord and separate the two wires - determine hot and neutral
When plugged in, one wire will be hot and one neutral. There are a couple ways to tell the difference between the two. Normally, one prong on the plug will be wide and one narrow, the narrow prong connecting to the hot wire (also, there is sometimes color coding on the wires). However, my plug has two narrow prongs, so either can be the hot wire depending on the orientation when I plug it in. That means I have to make sure to plug it in the same way every time, because I will only be running one wire, which needs to be the hot wire, through the relay (which acts as a switch to turn the heater on and off).

To solve this, I marked one wire with tape, and used a digital multimeter to check which prong that wire connected to. Another way to find the hot wire in general: one wire is ribbed (neutral) and the other is smooth (hot). So, I marked the smooth wire with tape and designated that to be my hot wire, and also marked the corresponding prong.

Using the DMM

3. Strip the ends of the wires and connect the heater to the relay

After stripping the ends, twist the filaments together.

I loosened the screws on the load side of the relay and inserted the relay between the two hot wires leading to the heater and plug. The neutral wires I twisted back together and secured with a wire nut and electrical tape.

P.S. Engineering majors - check out those heat-dissipating fins on the heat sink!

4. Connect the arduino to the relay
Here is a diagram of how I set it all up:

I connected the 3+ part of the relay to pin 10 (you can choose any, you will need to know which it is assigned to for the code), and the -4 part to ground via my breadboard (already connected to arduino ground for the temperature probe).

5. Write the code

We now need some arduino code that will tell the heater when to turn on and off. I am currently working on it and will make another post about it when I finish.

Temperature Probe Setup (6/28/16)

NOTE: I have basically no experience with any of this, other than a few starter projects using a breadboard. I have been using the internet to figure things out. I also do not know C/C++ (used with the arduino) - it is totally possible to figure out how to write code for it based on examples online!

I finally got together my supplies to make the temperature probe. I have also ordered a water heater and the other things I need to eventually automate the heating during brewing, but I will figure the rest of that out once it arrives. For now, here is how I hooked up the temperature probe:

The temperature probe is the DS18B20 model. I downloaded the OneWire library for my Arduino and used the example code called "DS18x20_Temperature." After uploading that to my Arduino, I opened Tools>Serial Monitor to view the outputs of my sensor: the temperature showed up in Fahrenheit and Celsius, measured accurately each second. I might eventually get a screen to display it but for now this works.

What the Serial Monitor reads each second:

ROM = 28 51 C1 4C 7 0 0 60
  Chip = DS18B20
  Data = 1 A 6 4B 46 7F FF 6 10 D  CRC=D
  Temperature = 96.62 Celsius, 205.92 Fahrenheit
No more addresses.

Bottling Day! (6/27/16)

After fermenting for 10 days, it was clear that the beer was not bubbling anymore (the entire foamy "head" had disappeared and no air was coming out of the airlock). I took a reading from the hydrometer, which I also did right before letting the wort ferment, and used the two readings to determine that my beer was 6.7% alcohol!

The hydrometer (should not be touching the sides for the actual reading):

After that, I prepared the priming sugar and added it to the wort, siphoned into this bucket without all the sediment from the fermentor:

All the leftover dead yeast and other sediment - yuck:

Then we siphoned the beer into bottles and capped them:

The (almost) finished product: 8 bottles of 6.7% American Red Ale.

Now all that's left is to let them carbonate for 2 weeks and then we will have delicious beer to drink. Christian and I tried the beer as-is and it was already pretty good!

Foggy Bottom Fermentation Workshop (6/18/16)

I attended the Turf and Terrain Foggy Bottom event about fermentation and microbes, where we got to start a "ginger bug" base for making carbonated soda with natural yeast as well as a sourdough bread base. In the ginger bug, the natural yeast will ferment and carbonate the base, and after a few days I can add more sugar, water, and fruits of my choosing to make carbonated soda. At the event we got to try one soda made this way and it turned out really well, so I am looking forward to that!

We also got to swab natural objects around the area to collect yeast and other microbes, which we added to sterile wort that the leader of the event would use to attempt to make his own beer with the naturally occurring yeast (the beer I am making uses store bought yeast, which is much more common; only a few Belgian breweries use natural fermentation for their commercial beer). Hopefully I will get an update on how my sample turns out.

For more information about these projects, check out microobservatory.com and @microobservatory on instagram.

The flower I swabbed:

The ginger bug (before fermenting):

Getting Started with Brewing (6/17/16)

I started my first batch of beer, American Red Ale, just a few days ago. I got a 1-gallon homebrewing kit from My LHBS and a couple kits for different types of beer. I chose the 1-gallon kit instead of the normal and probably more cost effective 5-gallon kit because I hope to start automating parts of the process and will need to run many batches, so I figured I didn't need to make tons of beer at once.

I won't get into the details of the brewing, but we cooked the wort (unfermented beer) on the stove following the kit's instructions, pumped it into a fermenting jug using an auto-siphon, added the yeast, and it is now fermenting for 10-14 days in my basement. Here is a picture from the pumping process:

And here is the beer-in-progress after 3 days:

The foam is caused by the yeast consuming the sugars in the wort and producing CO2 and alcohol. In person you can see the airlock at the top bubbling slowly as the CO2 is released.