brewby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 67034c466328c725de4cd15b591c95955e0eed93
+  data.tar.gz: 9ede21737fa8fcd2bfe51ad241822d99c0e31305
+SHA512:
+  metadata.gz: bc34919f55b18b24f5e2ab51b717ad0563b568cace52f123b3751766c729d29922147dacfe42c16cf3bb6b78a942af0f139ba65fa49453e0cf2651364bc03c39
+  data.tar.gz: e33629c1845ef23ba705db6a63c8de1201b00948bdc9c4db5859cb82e52a76e3201d29e0dba0c1bc0ca0a88271f9f06260eacb861d0cd4a7994476329c78e3ef

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andrew Nordman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,112 @@
+# Brewby
+
+Brewby Core functionality underpinning Brewby - IO interfacing Layer, Recipe DSL, Configuration Loading,
+and more.
+
+This library is the foundation for brewery automation applications themselves.  Unless you are
+writing a brewery automation application, you will not use this library directly.
+
+
+## Input Sensors
+
+brewby provides adapters for input sensors in a consistent interface.  The following adapters
+are currently supported, with several more on the way:
+
+* `Brewby::Input::DS18B20` - Dallas 18B20 temperature sensors runnning on the One-Wire Bus
+* `Brewby::Input::Test` - A fake sensor that grabs a random number. Used for testing purposes
+
+## Output Adapters
+
+brewby also provides an interface for controlling output for heat sources.  There are two
+layers to this system.  The first is the low-level interface adapters for output: GPIO, serial
+communication, etc.  These are what trigger the on/off states directly.  On top of that is the
+layer that handles knowing when to turn on/off a heating element.  We control this via the
+`Brewby::HeatingElement` class, passing it an output adapter.  By setting a few variables, we
+can simulate a percentage of total output power utilizing software-based pulse-width modulation.
+The principle of pulse width modulation is that you break on/off cycle into equal time lengths
+with an identical output waves.  For example, if you wish to simulate 50% power but only have an
+on/off switch, you break it up into equal, one-second time lengths, with 500 milliseconds on
+and 500 milliseconds off.  The duration of the wave length is called the pulse width, and the
+total size of the wave length is called the pulse range.  By modulating between on/off states,
+you simulate power levels.
+
+Here is an example of the `Brewby::HeatingElement` class in action, with a 5 second pulse range
+and a 2.5 second pulse width.  By continuously calling `pulse`, we check the time and toggle the
+element on and off via the passed in adapter:
+
+``` ruby
+adapter = Brewby::Outputs::Test.new
+element = Brewby::HeatingElement.new(adapter, pulse_range: 5000)
+element.pulse_width = 2500  # 50% power
+
+loop do
+  element.pulse
+  if element.on?
+    puts "Within pulse width"
+  else
+    puts "Outside pulse width"
+  end
+end
+```
+
+## Recipe Steps
+
+Creating a good brew requires several steps in the process, some automatable and some eot. Brewby
+treats these steps as logic gates, encapsulating the control for each step based on a step type.
+Currently, Brewby only has the `TempControl` step for handling temperature control via manual
+and automatic control and duration.  Here is an example of a temperature control step for a mash
+step, holding at 155F for 75 minutes:
+
+``` ruby
+  sensor = Brewby::Inputs::Test.new
+  relay = Brewby::Outputs::Test.new
+  element = Brewby::HeatingElement.new(relay, pulse_range: 5000)
+  step = Brewby::Steps::TempControl.new({
+    mode: :auto, 
+    input: sensor, 
+    output: element, 
+    target: 150.0,
+    duration: 75
+  })
+
+  loop do
+    step.step_iteration
+    break if step.time_remaining <= 0
+  end
+```
+
+## Brewby Applications
+
+As you can imagine, writing out several steps can be very repetitive, especially when handling 
+something like a multiple decoction step mash schedule.  Not only do the steps need to be handled,
+but the equipment configuration needs to be setup every time a new step is created. To handle this,
+steps are wrapped into an Application to act as the bridge between Steps and IO.
+
+``` ruby
+  class StepMash < Brewby::Application
+  def tick
+    super
+    render_status
+  end
+
+  def render_status
+    @last_output ||= Time.now
+    if @last_output < (Time.now - 1)
+      puts "Target: #{current_step.target}F\tActual: #{current_step.last_reading}F\tPower Level: #{current_step.power_level * 100}%"
+      @last_output = Time.now
+    end
+  end
+end
+
+application = StepMash.new
+application.add_input :test
+application.add_output :test
+application.add_step :temp_control, target: 125.0, duration: 15
+application.add_step :temp_control, target: 155.0, duration: 35
+application.add_step :temp_control, target: 168.0, duration: 10
+
+application.start
+```
+
+By default, Applications use the first input and output when adding new steps unless passed in
+as an option to the `add_step` method.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/brewby.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |gem|
+  gem.authors       = ["Andrew Nordman"]
+  gem.email         = ["cadwallion@gmail.com"]
+  gem.summary       = %q{The core components of the Brewby brewing system}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "brewby"
+  gem.require_paths = ["lib"]
+  gem.version       = "0.1.0"
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'pry'
+
+  gem.add_dependency 'temper-control'
+end

data/examples/basic_control.rb

@@ -0,0 +1,24 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'brewby'
+
+class StepMash < Brewby::Application
+  def tick
+    super
+    render_status
+  end
+
+  def render_status
+    @last_output ||= Time.now
+    if @last_output < (Time.now - 1)
+      puts "Target: #{current_step.target}F\tActual: #{current_step.last_reading}F\tPower Level: #{current_step.power_level * 100}%"
+      @last_output = Time.now
+    end
+  end
+end
+
+application = StepMash.new adapter: 'test', inputs: [{}], outputs: [{}]
+application.add_step :temp_control, target: 125.0, duration: 15
+application.add_step :temp_control, target: 155.0, duration: 35
+application.add_step :temp_control, target: 168.0, duration: 10
+
+application.start

data/examples/brewby_recipe.rb

@@ -0,0 +1,35 @@
+recipe 'Honey Ale' do
+  step 'Strike Water' do
+    type :temp_control
+    mode :auto
+    target 168.0
+    hold_duration 5
+    input :hlt
+    output :hlt
+  end
+
+  step 'Infusion Mash Step' do
+    type :temp_control
+    mode :auto
+    target 150.0
+    hold_duration 60
+    input :mlt
+    output :hlt
+  end
+
+  step 'Fly Sparge' do
+    type :temp_control
+    mode :auto
+    target 168.0
+    hold_duration 45
+    input :hlt
+    output :hlt
+  end
+
+  step 'Boil' do
+    type :temp_control
+    mode :manual
+    input :bk
+    output :bk
+  end
+end

data/examples/config.json

@@ -0,0 +1,21 @@
+{
+  "adapter":"raspberry_pi",
+  "inputs":[
+    {
+      "hardware_id":"28-something"
+    },
+    {
+      "hardware_id":"28-somethingelse"
+    }
+  ],
+  "outputs":[
+    {
+      "pulse_range":5000,
+      "pin":17
+    },
+    {
+      "pulse_range":5000,
+      "pin":19
+    }
+  ]
+}

data/examples/recipe_loader.rb

@@ -0,0 +1,28 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'brewby'
+
+class RecipeLoader < Brewby::Application
+  def tick
+    super
+    render_status
+  end
+
+  def render_status
+    @last_output ||= Time.now
+    if @last_output < (Time.now - 1)
+      puts "Target: #{current_step.target}F\tActual: #{current_step.last_reading}F\tPower Level: #{current_step.power_level * 100}%"
+      @last_output = Time.now
+    end
+  end
+end
+
+app = RecipeLoader.new({
+  adapter: 'test', 
+  inputs: [{ name: 'hlt' }, { name: 'bk' }], 
+  outputs: [{ name: 'hlt' }, { name: 'bk' }]
+})
+
+file = ARGV[0] || "examples/brewby_recipe.rb"
+puts "Loading Recipe #{file}"
+app.load_recipe File.expand_path(file)
+app.start

data/lib/brewby.rb

@@ -0,0 +1,6 @@
+require "brewby/version"
+require 'brewby/steps'
+require 'brewby/application'
+
+module Brewby
+end

data/lib/brewby/application.rb

@@ -0,0 +1,88 @@
+require 'brewby/inputs'
+require 'brewby/outputs'
+
+module Brewby
+  class Application
+    attr_reader :outputs, :inputs, :steps
+    attr_accessor :adapter, :name
+
+    include Brewby::Timed
+
+    def initialize options = {}
+      @options = options
+      @steps = []
+      @adapter = options[:adapter].to_sym
+      configure_inputs
+      configure_outputs
+      @ready = false
+    end
+
+    def configure_inputs
+      @inputs = []
+
+      @options[:inputs].each do |input_options|
+        add_input @adapter, input_options
+      end
+    end
+
+    def add_input adapter, options = {}
+      sensor = Brewby::Inputs.adapter_class(adapter).new options
+      @inputs.push sensor
+    end
+
+    def configure_outputs
+      @outputs = []
+      
+      @options[:outputs].each do |output_options|
+        add_output @adapter, output_options
+      end
+    end
+
+    def add_output adapter, options = {}
+      output_adapter = Brewby::Outputs.adapter_class(adapter).new options
+      element = Brewby::HeatingElement.new output_adapter, pulse_range: options[:pulse_range], name: options[:name]
+      @outputs.push element
+    end
+
+    def add_step step_type, options = {}
+      case step_type
+      when :temp_control
+        default_options = { input: @inputs.first, output: @outputs.first }
+        step = Brewby::Steps::TempControl.new default_options.merge(options)
+      end
+      @steps.push step
+    end
+
+    def load_recipe file
+      Brewby::StepLoader.new(self).load_file file
+    end
+
+    def start
+      start_timer
+      @steps.each do |step|
+        start_step step
+        until ready_for_next_step?
+          tick 
+        end
+        @ready = false
+      end
+    end
+
+    def ready_for_next_step?
+      @ready
+    end
+
+    def tick
+      current_step.step_iteration
+    end
+
+    def start_step step
+      @current_step = step
+      step.start_timer
+    end
+
+    def current_step
+      @current_step || @steps[0]
+    end
+  end
+end

data/lib/brewby/heating_element.rb

@@ -0,0 +1,61 @@
+module Brewby
+  class HeatingElement
+    attr_accessor :pulse_width, :pulse_range, :name, :adapter
+
+    def initialize adapter, options = {}
+      @pulse_range = options[:pulse_range] || 1000
+      @on = false
+      @pulse_range_end = (Time.now.to_i * 1000) + @pulse_range
+      @adapter = adapter
+      @pulse_width = 0
+      @name = options[:name]
+    end
+
+    def pulse
+      set_pulse_time
+      update_pulse_range if pulse_exceeds_range?
+      
+      if pulse_within_width?
+        on!
+      else
+        off!
+      end
+    end
+
+    def set_pulse_time
+      @pulse_time = (Time.now.to_i * 1000)
+    end
+
+    def pulse_within_width?
+      @pulse_time <= pulse_end
+    end
+
+    def pulse_exceeds_range?
+      @pulse_time > @pulse_range_end
+    end
+
+    def update_pulse_range
+      @pulse_range_end += @pulse_range
+    end
+
+    def pulse_end
+      @pulse_range_end - (@pulse_range - @pulse_width)
+    end
+
+    def on!
+      @adapter.on
+    end
+
+    def off!
+      @adapter.off
+    end
+
+    def on?
+      @adapter.on?
+    end
+
+    def off?
+      !on?
+    end
+  end
+end