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.

 

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display

#include <OneWire.h>
#include <DallasTemperature.h>
 
#include <SPI.h>
#include <SD.h>
File myFile;

const int chipSelect = 4;
unsigned short int counter = 0; // value range between 0 to 65,536 // we have no need to store negative value ranges 
 
// Data wire is plugged into pin 2 on the Arduino
#define ONE_WIRE_BUS 2
 
// Setup a oneWire instance to communicate with any OneWire devices 
// (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
 
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
 

void setup(void)
{
  lcd.init();                      // initialize the lcd 
  lcd.init();
  
 // start serial port
 Serial.begin(9600);
 
 // Start up the library
 sensors.begin();
 
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
 
 Serial.print("Initializing SD card...");
 
 // see if the card is present and can be initialized:
 if (!SD.begin(chipSelect)) {
 Serial.println("Card failed, or not present");
 // don't do anything more:
 return;
 }

 Serial.println("card initialized.");

 // use this code if you want the file removed upon device reboot or reset ???
 //Serial.println("Removing file.txt...");
 //SD.remove("file1.txt");
 
 if (SD.exists("brewday2.txt")) {
 Serial.println("file1 exists.");
 } else {
 Serial.println("file1 doesn't exist.");
 }
 
}
 
void loop(void)
{
 delay(5000);

  lcd.backlight();
  lcd.setCursor(0,0);
//  lcd.print("kodiakbrewing.com ");
  lcd.print("Log Counter: ");
  
  lcd.setCursor(13,0);
  lcd.print(counter);

  lcd.setCursor(0,1);
  lcd.print("log to: brewday2.txt");
  lcd.setCursor(12,1);
  
  
  lcd.setCursor(0,2);
  lcd.print("Int. Temp: ");
  lcd.setCursor(11,2);
  lcd.print(sensors.getTempCByIndex(1) * 1.8 + 32.0); // Convert to F

  lcd.setCursor(0,3);
  lcd.print("Ext. Temp: ");
  lcd.setCursor(11,3);
  lcd.print(sensors.getTempCByIndex(0) * 1.8 + 32.0); // Convert to F
  
 
 sensors.requestTemperatures(); 
 Serial.print("External Temperature is: ");
 Serial.print(sensors.getTempCByIndex(0) * 1.8 + 32.0); // Convert to F
 Serial.print('\n');
 Serial.print("Internal Temperature is: ");
 Serial.print(sensors.getTempCByIndex(1) * 1.8 + 32.0);
 Serial.print('\n'); 
 Serial.println(counter);
 
 // make a string for assembling the data to log:
 String external_temp = "";
 String internal_temp = "";
 
 // read the two sensors and append to the string:
 external_temp = String(sensors.getTempCByIndex(0) * 1.8 + 32.0);
 internal_temp = String(sensors.getTempCByIndex(1) * 1.8 + 32.0);

 
File dataFile = SD.open("brewday2.txt", FILE_WRITE);
 
// counter = counter + 1;  
counter++;
 
 // if the file is available, write to it:
 if (dataFile) {
 dataFile.println(String(counter) + "," + external_temp + "," + internal_temp);
 dataFile.close();
 }
 // if the file isn't open, pop up an error:
 else {
 Serial.println("error opening file.txt");
 }
 
 
}

 

Posted in Arduino-RaspberryPi-Make-Beer | Leave a comment

American Brown Ale 10 gallon batch


20160319_120209

attempt #1 pic below – Brew date: 3/26/1016

american_brown_ale-attempt1

attempt #2 pic below – Brew date: 7/10/2016

20160812_180653

10 gallons.

This beer was modeled after the Diamond Knot Brown Ale per the grains/hops posted on their web site, and simulated for ABV/SRM and IBU using app “Wort Pro”.

http://www.diamondknot.com/the-beer/always-on/brown-ale/

Videos of the brew are below:

adding flaked oats to mash: – add sweetness and body – read…

start of boil (using hop balls for whole hops so they don’t plug up the pipes):

transfer to fermentor:

adding yeast:

next day fermenting:

Attempt #1 – OG 1.068 // FG 1.010 – final ABV 7.6% – yes a little higher then the 6.0% Diamond Knot..

  • IBU 25.8
  • SRM 13

Attempt #2 – OG 1.066 // FG 1.014 – final ABV 6.83%

  • IBU 28.3
  • SRM 13

Total water used 15.5 gallons for final 10 gallons of beer…

attempt #1 grains:

  • 18 lb Pale Malt 2-row
  • 4.5 lb Munich Malt 10 love
  • 3.0 lb Crystal Malt 10 love – see below for attempt #2 changes
  • 0.20 lb Chocolate Malt
  • 0.20 lb Black Barley
  • 1.0 lb flaked Barley
  • 1/2 lb of brown sugar

attempt #2 grains:

  • 18 lb Pale Malt 2-row
  • 4.5 lb Munich Malt 10 love
  • 1.5 lb Crystal Malt 15 love
  • 1.5 lb Crystal Malt 60 love – we did this to give the beer more caramel flavor and beer body
  • 0.40 lb Chocolate Malt – we double the dark grains to darken the color a bit
  • 0.40 lb Black Barley
  • 1.0 lb flaked Barley
  • 1/2 lb of brown sugar – we didn’t use it this time, the sugar…

hops attempt #1:

  • 2.0 oz Galena with some whole hops from last year’s harvest (Yakima & Cascade) at start of boil, added to the hop boil ball, see video.
  • 2.0 oz Willamette last 15 minute of boil.

hops attempt #2:

  • 2.0 oz of home grown Cascade Hops, 2015 harvest (beginning of boil)
  • 1.0 oz of Cascade pallet + 1.0 oz Willamette pallet (last 15 minutes)

attempt #1 – Wyeast #1056 yeast was used, took 2 weeks to ferment out, this yeast consistently bubbled over the 2 week period…

attempt #2 – British Ale Wyeast #1098 // 2 liter starter // 1.040 gravity – majority of the active fermentation will be over in about 4 days, but let it go out full 2 weeks – because it’s still happening, just slower, also we like to allow extra time for all the floaters in the fermentor to settle.  On that note, per one of our brew nerds – once fermentation is over, trapped dissolved co2 gas slowly escapes the beer, so it will give you a false sense of a fermenation – only way is to measure.

attempt #3 – 11/11/18 – all same as attempt #2, expect for yeast – we used WLP002 English Ale… OG 1.052 / started the mash schedule at 138F and slowly ramped to 152F in 1 hour, then held at 152F for an additional 30 minutes for 90 minute total mash / this mash schedule produced much a better efficiency compared to OG of 1.040 in attempt #2

Beer tastes awesome – Fermentation was 2 weeks, which included 1 week rest time – this helps the yeast to reabsorb any unwanted off-flavors, in keg for only a few days!  Boom, a winner!

Posted in BEER Home Brewing | Tagged | Leave a comment

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.

logFile.write('{:10.0f}\t{:3.2f}\n'.format(time.time(),temperature))

a quick python plot example below:

plot

sample code to generate a plot from the sample data.

from matplotlib import pyplot as plt
from matplotlib import style
import numpy as np

# select the style
style.use('ggplot')

# unpack values into array when using numpy // python uses lists
x,y = np.loadtxt('test3.dat', unpack=True, delimiter='\t')

plt.plot(x,y)

# configure the labels
plt.title('temperature plot')
plt.ylabel('Y Axis')
plt.xlabel('X Axis')

plt.show()

 

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
import serial, datetime
from datetime import datetime
import time

LOGFILE_FORMAT = '%Y-%m-%d.dat' # could also contain a path: '/home/brewery/temperatures/%Y-%m-%d.dat'
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S' # better make them human readable

LOGFILE_FORMAT_FILE_NAME = '/home/pi/python/datalog_onefile_test2_dynamic.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('{:s}\t{:3.2f}\n'.format(loggedTimestamp,temperature))
# if you want the decimal part of the time to be dropped use below line instead
# un-comment it and replace the .write line above
    # logFile.write('{:10.0f}\t{:3.2f}\n'.format(time.time(),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()

last_temp_reading = -273

while True:
    temp = ser.readline().strip() # get something clean from the start
    if temp:   # a non-empty string is "True", an empty string (or None...) is "False"
        temperature = float(temp)
        print "printing variable", temperature
        print "printing temperature variable", last_temp_reading

# dynamic sampling, ignoring repeating temperature samples
        if last_temp_reading != temperature: # assumes you can't get a reading of -273, so first execution will always see this as true.
            print "temp is different, recording it!", temperature
            logTemperature(temperature)
            last_temp_reading = temperature
        else:
            print "temp is the same, ignoring it!!!", last_temp_reading

 

 

Posted in Arduino-RaspberryPi-Make-Beer | 1 Comment

Apricot Belgian Blonde 10 Gallon Recipe // All Grain

20160305_150844

brew-day: 12/26/2015 // OG – 1.072 // Update on temp. chart of fermentation later along with FG, we are hoping for 8%.  This recipe originally called for 3lb of sugar, we used 1.5lb.  If you want 9%, add that extra sugar.

For yeast using a 2000ml starter, French Saison #3711 prepared 28 hours ahead of time.  The best thing to do with starters if you really want to be exact about it, is to test the wort until it reaches an OG of approx. 1.040.  This will prepare and propagate the yeast for the main fermentation without tiring its self out before the main fight.  The best way to do that is with a refractometer (make sure to buy one with the SG wort scale for brix %).

sugar + yeast = alcohol, Co2 and heat.

Fermentation is an exothermic process. The internal temperature of the fermentor can be as much as 10F above ambient conditions on the outside, just due to yeast activity.

450x450x7462b.jpg.pagespeed.ic.zJ98iUC8K6

70 minute boil.

Malt:

  • 24 lbs of American 2-row (use local grain from your state/region if you can, support your local farmers)
  • 1.2 lb aromatic malt
  • 1.5lb cane sugar – [ in Belgian beers sugar is added to lighten the body of the beer without affecting the taste, it will also increase the ABV as it should fully convert.  Warning: Belgian beers are not Budweiser. drink them responsibly and slow… ]

Hops:

  • 10 minute into the boil (70 mins total), add 2 ounce of Magnum Hops – for Bitter
  • at end of boil, add 2 ounce of Styrian Hops – for Aroma

We always add Irish Moss at 15 minute to end of boil

Yeast:

We used a French Saison #3711 // but there are other choices not limited to: Abbey Ale or Wyeast 3787 (Trappist High Gravity) yeast (we recommend you make a starter atleast 24 hours bore brew day).

Fermentation:

Add 2 days into the fermentation the Apricot Puree, 5-6 lbs.  Fruit doesn’t transfer well in boil, otherwise skip if you don’t want the Apricots.

Posted in Belgian Beer Recipes | Leave a comment

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).

#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 – 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

Posted in Arduino-RaspberryPi-Make-Beer | Tagged , , , , , , , , , | Leave a comment

Imperial Brown Stout 10/11% All Grain Recipe

Mashout, brew date: 9/20/2015 ( next to an IPA on the right, our previous brew )..

OG 1.086 // FG after 2 week fermentation 1.025 – 8% ( we didn’t hit our goal of 10% because of the yeast that we used for this test, but the beer came out super delicious regardless, so it was a success! ) // Next time we will use the WLP007 yeast and should be closer to our target!

IMAG0331

This is going to be something new for us, we had plenty of good Porters and Black Stouts, but a Brown Stout ?  🙂 exactly!

Notice the nice Brown foam..

IMAG0333

Video of the fermentation the morning after :- )

 

For our 10 gallon batch we used these grains and also used 1LB of Light DME, to add to the ABV% without affecting the color of the beer or taste too much.

  • 18 lbs of Marris Otter Malt
  • 9 lbs British Brown Malt
  • 4 lbs Amber Malt
  • 1.4 lbs Black Malt (Roasted)
  • 1LB Light DME

6 ounces of Columbus hops (used for bittering) added at the beginning of boil with a 90 minute boil.

Yeasts:

Our first choice was WLP007, but it was sold out // so we picked a British Ale #1098 and did a 3 liter starter.  There are many other yeasts you could probably try, depending on what you like.

 

Posted in BEER Recipes | Tagged , , | Leave a comment

Semper fIPA – All Grain Recipe

IMG_3067

 

Above picture credit: Danny Ferguson

next we are going to try a recipe by a fellow brewer from the Brew Nerds community on Google+  credit goes to Danny Ferguson

The Semper fIPA was targeted 7% ABV & 70 IBU / our version might vary based on what type of hops we can get, we will post our version later when we brew in about a month.

5.5 gal fermenter volume:

81% 2-row pale
6% German Munich
6% American carapils (dextrin)
4% American crystal 40
3% orange blossom honey (or enough to hit target gravity)

hops:

2.0 oz Amarillo leaf FWH – ( First Wort Hops )
0.5 oz Chinook leaf 30 min
1.0 oz Columbus pellet 30 min
1.0 oz Sorachi Ace leaf 15 min
2.0 oz Citra leaf dry hop 5 days

WLP001 yeast

Posted in BEER Recipes | Leave a comment

Dog Biscuits/Treats from Spent Grain (Beer Brewing)

Dog Biscuits/Treats from Spent Grain

You can now buy these from us – this is our way or raising cash to fund our operation/blog, since we can’t sell you beer.

 

HOPS ARE POISONOUS TO DOGS – if you add hops to the Mash, you can’t use the grain to make dog biscuits.

Tip – Most brewers will be too busy brewing the beer so collect a bunch of spent grain after the mash is over, (drain it of the wort) if you don’t want it to be too wet and stick it into the fridge for later, it should be good for a solid week or more.  This way you can make the biscuits a few days later after your brew day when you are not so busy or too tired.

After a few tries using recipes from a Google I decided to make my recipe and combine my experience of bread baking, I list two recipes..

One of the things that I noticed from the Google recipes is that most of them used only 2 cups of spent-grain, that’s little grain.  We all know we have “a lot!” more than 2 cups left after a brew.

Recipe #1 (the more messy recipe that takes more time, see Recipe #2 below if you want a quicker less messy solution)

  • 4 cups of spent grain (no hops were used) – hops are poisonous to dogs
  • 1 cup of – flour (you can combine either of flour types or just use one type)
  • 1 cup of whole flour
  • 2 cups of (beef or chicken) broth for flavor – heat it up in the microwave so that it is luke warm and add the yeast to it
  • 1 egg (use the whole egg, calcium from shell is good if possible)
  • 1/2 packet bread yeast (add to the broth, see above)

In a mixer: grain + flour + broth + egg.. mix it well, you can easily control how sticky it will be by adding chicken broth slowly or less of it, Add 1/2 packet of bread yeast with the broth (pre-heated), roll into a ball and let it sit under a towel for at least an 1 hour to raise..

Roll it out and use cookie cutters to take shape of your biscuits..

Preheat to 350F // bake for 30 ~ 45 minutes…  Since you added yeast, these cookies will be nice and poofy.

After baking, lower temp to 200 ~ 220F and bake them for a few hours (2) to dry them out so that mold don’t take hold later (this largely depends on how thick your cookies are), thicker need longer drying time… We also use grocery paper bags for a week+ to remove any residual moisture, works well.

If your mix is sticky, just keep on adding flour until it’s not, use lots of flour on your work area so that the cookies won’t stick…  If things seem too sticky, don’t give up, add more flour – no matter how crazy it looks!  Also you have an option of using less broth, since that is what made them sticky.

I ended up with 3 sheets of cookies, use foil if you run out of cookie sheets :- ) pre-spray with cooking oil..  If you make your cookies thin, they don’t require as much extra drying time or next to none, don’t assume anything // check and look to make sure you are not overheating and burning them!

Recipe #2

This recipe does not use bread yeast, is simpler and faster to prepare/make and it should not be sticky at all, also you do everything in the mixing bowl, so there is little to clean up later.  If you are short on time go with this one and dogs love peanut butter cookies as well!

Once you have your mix spread out on the cookie sheet, I usually cut it into strips.  If you want to spend the extra time using fancy cookie shapes, go for it.  Dogs don’t care :- )

  • 4 cups of spent grain (ours was pretty dry and stored in the fridge for 2 days after brew day)
  • 1.5 cups of flour (pick type, whole or all purpose), if you grain is more wet, you might need 2 cups, add more if so
  • 2 eggs
  • 1 cup of peanut butter

mix this all up, pre-heat your oven to 350 F and stick it in there for 30 minutes, then reduce heat to 220F and leave it in there for 2 hours.  Again, spray your pan so they won’t stick.

 

 

 

Posted in BEER Recipes | Tagged | Leave a comment

Copper Ale – All Grain Recipe

Here are pictures of our brew 3/22/2015 – after a one month rest ( keg in a fridge at 36F )…  first 2 pics are from artificial light and last 2 from natural window light.

If you want the color darker – increase your Chocolate malt…

copperale_04 copperale_03 copperale_02

after about 5 weeks the beer will clear up completely and show its true Copper color along with achieving its overall profile:

copper_ale

 

 

 

 

V_21_20_Main

This is a Copper Ale, 5 gallon all grain recipe.  Double everything for a 10 gallon batch.

This one should end up at around 7% ABV, 15 IBU, 14 SRM..

We did a Copper Ale using a different recipe a few years back – use the Search window to find all variations, trying a new one this time…

weight (in lbs) type of grain:

  • 11 lb // domestic 2-row
  • 1 lb // Munich malt
  • 0.45 lb // Victory malt
  • 0.09 lb // Chocolate malt 350L

Hop Schedule:

Northern Brewer hops ( 6.0% Alpha Acid ) // 25 grams – add all of the hops as soon as boil starts, boil for 60 minutes.  Add irish moss in the last 15 ~ 20 minutes of boil.

Wyeast American 1056 yeast should do nicely or use your house strain.

details of our 10 gallon brew on 2/28/2015.. 

  • total water used (mash and sparge) 15.5 gallons
  • we rounded the hops and added 2 ounces total ( or 1 ounce per the original 5gal recipie )
  • we added irish-moss 20 minutes prior to end of boil
  • we made a starter 24 hours before…
  • we start re-circulation 15 minutes before mash-out, to clear up the beer from particles
  • OG was 1.062
  • brew house efficiency ( coming up… )

video of circulation ( 20 min prior to mash-out ):

Final mash-out:

End-of-Boil, in this video I cool my wort and employ the re-circulation pump to remove cooling time as this help to remove the heat faster!  Wort needs to be cooled to the recommended temp. range on the yeast packet – read the specs!

and the final stage, transfer beer to Fermentor – beer that is 10 gallons is to heavy to lift, you need to get a pump at this stage – unless you want to break your back.  You can get away without a pump with 5 gallon batches, but not really with 10+

pitch yeast and wait…

clean up equipment, relax and drink beer, jump into a hot tub!

 

Posted in BEER Recipes | Tagged | Leave a comment

Brasserie Dieu du Ciel Rosee d’hibiscus ( clone ) all-grain Ale

Rosee

773-Rosee-dHibiscus

This recipe comes from a Brew Your Own magazine, January-February 2015 issue, page 40.  We are planning to tweak it a little bit and change it around especially for the yeast and grains that we have access locally from our brew supply store.  This is the all-grain version, they also had a extract only recipe.

Stay tuned!

  • Mash at 152F for 60 minutes – for a dry crisp Ale
  • follow with a 90 minute boil

We will update once we brew it and finalize our recipe and results :- )

5 gallon recipe.

  • 5.2 lb Belgian Pilsner malt – substitute for what you can get
  • 4 lb Wheat malt
  • 1 lb light candi sugar – add in last 5 minutes of boil

Hops schedule:

  • 1/4 oz or 7 grams of Nelson Sauvin hops at 40 minutes after boil starts
  • 0.4 oz or 11 grams of Nelson Sauvin hops at 10 minutes from end of boil

Other ingredients:

  • 2 to 4 ounces of dried hibiscus – last 5 minutes of boil / the more the more pinkish it will be
  • 1/2 ounce coriander seed – end of boil (crush these before using with a roller of some kind or a beer bottle), let it soak for 5 minutes before starting to cool and chill the wort

Yeast:

We plan to use a 1214 Belgian Abbey yeast here, but original recipe calls for a WLP400 (Belgian Wit Ale) or a Fermentis Safbrew T-58 yeast…

Carbonate to 2-2.5 volume of co2.

 

 

 

 

 

 

Posted in BEER Recipes | Leave a comment