First Version

modules/base_plugins/brew_steps/__init__.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+import time
+
+
+from modules.core.props import Property, StepProperty
+from modules.core.step import StepBase
+from modules import cbpi
+
+
+@cbpi.step
+class MashStep(StepBase):
+    '''
+    Just put the decorator @cbpi.step on top of a method
+    '''
+    # Properties
+    temp = Property.Number("Temperature", configurable=True)
+    kettle = StepProperty.Kettle("Kettle")
+    timer = Property.Number("Timer in Minutes", configurable=True)
+
+    def init(self):
+        '''
+        Initialize Step. This method is called once at the beginning of the step
+        :return: 
+        '''
+        # set target tep
+        self.set_target_temp(self.temp, self.kettle)
+
+    @cbpi.action("Start Timer Now")
+    def start(self):
+        '''
+        Custom Action which can be execute form the brewing dashboard.
+        All method with decorator @cbpi.action("YOUR CUSTOM NAME") will be available in the user interface
+        :return: 
+        '''
+        if self.is_timer_finished() is None:
+            self.start_timer(int(self.timer) * 60)
+
+    def reset(self):
+        self.stop_timer()
+        self.set_target_temp(self.temp, self.kettle)
+
+    def finish(self):
+        self.set_target_temp(0, self.kettle)
+
+    def execute(self):
+        '''
+        This method is execute in an interval
+        :return: 
+        '''
+
+        # Check if Target Temp is reached
+        if self.get_kettle_temp(self.kettle) >= int(self.temp):
+            # Check if Timer is Running
+            if self.is_timer_finished() is None:
+                self.start_timer(int(self.timer) * 60)
+
+        # Check if timer finished and go to next step
+        if self.is_timer_finished() == True:
+            self.next()
+
+
+@cbpi.step
+class MashInStep(StepBase):
+    '''
+    Just put the decorator @cbpi.step on top of a method
+    '''
+    # Properties
+    temp = Property.Number("Temperature", configurable=True)
+    kettle = StepProperty.Kettle("Kettle")
+    s = False
+
+    def init(self):
+        '''
+        Initialize Step. This method is called once at the beginning of the step
+        :return: 
+        '''
+        # set target tep
+        self.s = False
+        self.set_target_temp(self.temp, self.kettle)
+
+
+
+    def execute(self):
+        '''
+        This method is execute in an interval
+        :return: 
+        '''
+
+        # Check if Target Temp is reached
+        if self.get_kettle_temp(self.kettle) >= int(self.temp) and self.s is False:
+            self.s = True
+            self.notify("Step Temp Reached!", "Please press the next button to continue", timeout=None)
+
+
+

modules/base_plugins/dummy_temp/__init__.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+import subprocess
+import time
+
+from modules import cbpi, socketio
+from modules.core.hardware import  SensorActive
+from modules import cbpi
+from modules.core.props import Property
+
+
+@cbpi.sensor
+class DummyTempSensor(SensorActive):
+    temp = Property.Number("Temperature", configurable=True, default_value=5)
+
+    def get_unit(self):
+        return "°C" if self.get_config_parameter("unit", "C") == "C" else "°F"
+
+    def stop(self):
+        pass
+
+    def execute(self):
+        while self.is_running():
+
+            self.data_received(self.temp)
+            socketio.sleep(5)
+
+
+
+
+
+
+
+
+
+
+

modules/base_plugins/fermenter_hysteresis/__init__.py

@@ -0,0 +1,27 @@
+from modules import cbpi
+from modules.core.controller import KettleController, FermenterController
+from modules.core.props import Property
+
+
+@cbpi.fermentation_controller
+class Hysteresis(FermenterController):
+
+    on = Property.Number("Offset On", True, 0)
+    off = Property.Number("Offset Off", True, 0)
+
+    def stop(self):
+
+        super(FermenterController, self).stop()
+        self.heater_off()
+
+    def run(self):
+        while self.is_running():
+            print "Temp %s" % self.get_temp()
+            if self.get_temp() < self.get_target_temp() - int(self.on):
+                self.heater_on(100)
+            elif self.get_temp() >= self.get_target_temp() - int(self.off):
+                self.heater_off()
+            else:
+                self.heater_off()
+            self.sleep(1)
+

modules/base_plugins/gpio_actor/__init__.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+import time
+
+from modules import cbpi
+from modules.core.hardware import ActorBase, SensorPassive, SensorActive
+from modules.core.props import Property
+
+try:
+    import RPi.GPIO as GPIO
+
+    GPIO.setmode(GPIO.BCM)
+except Exception as e:
+    print e
+    pass
+
+
+
+@cbpi.actor
+class GPIOSimple(ActorBase):
+
+    gpio = Property.Select("GPIO", options=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26])
+
+    def init(self):
+        GPIO.setup(int(self.gpio), GPIO.OUT)
+        GPIO.output(int(self.gpio), 0)
+
+    def on(self, power=0):
+        print "GPIO ON %s" % str(self.gpio)
+        GPIO.output(int(self.gpio), 1)
+
+    def off(self):
+        print "GPIO OFF"
+        GPIO.output(int(self.gpio), 0)
+
+@cbpi.actor
+class GPIOPWM(ActorBase):
+
+    gpio = Property.Select("GPIO", options=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26])
+    duty_cylce = Property.Number("Duty Cycle", configurable=True)
+
+    p = None
+    power = 100
+
+    def init(self):
+        GPIO.setup(int(self.gpio), GPIO.OUT)
+        GPIO.output(int(self.gpio), 0)
+
+
+    def on(self, power=None):
+        if power is not None:
+            self.power = int(power)
+
+        if self.duty_cylce is None:
+            duty_cylce = 50
+
+        self.p = GPIO.PWM(int(self.gpio), int(self.duty_cylce))
+        self.p.start(int(self.power))
+
+    def set_power(self, power):
+        if power is not None:
+            self.power = int(power)
+        self.p.ChangeDutyCycle(self.power)
+
+    def off(self):
+        print "GPIO OFF"
+        self.p.stop()
+
+
+@cbpi.actor
+class RelayBoard(ActorBase):
+
+    gpio = Property.Select("GPIO", options=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26])
+
+    def init(self):
+        GPIO.setup(int(self.gpio), GPIO.OUT)
+        GPIO.output(int(self.gpio), 1)
+
+    def on(self, power=0):
+
+        GPIO.output(int(self.gpio), 0)
+
+    def off(self):
+
+        GPIO.output(int(self.gpio), 1)
+
+@cbpi.actor
+class Dummy(ActorBase):
+
+    def on(self, power=100):
+        print "ON"
+
+    def off(self):
+        print "OFF"

modules/base_plugins/hysteresis/__init__.py

@@ -0,0 +1,39 @@
+from modules import cbpi
+from modules.core.controller import KettleController
+from modules.core.props import Property
+
+
+@cbpi.controller
+class Hysteresis(KettleController):
+
+    # Custom Properties
+
+    on = Property.Number("Offset On", True, 0)
+    off = Property.Number("Offset Off", True, 0)
+
+    def stop(self):
+        '''
+        Invoked when the automatic is stopped.
+        Normally you switch off the actors and clean up everything
+        :return: None
+        '''
+        super(KettleController, self).stop()
+        self.heater_off()
+
+
+
+
+    def run(self):
+        '''
+        Each controller is exectuted in its own thread. The run method is the entry point
+        :return: 
+        '''
+        while self.is_running():
+            if self.get_temp() < self.get_target_temp() - int(self.on):
+                self.heater_on(100)
+            elif self.get_temp() >= self.get_target_temp() - int(self.off):
+                self.heater_off()
+            else:
+                self.heater_off()
+            self.sleep(1)
+

modules/base_plugins/one_wire/__init__.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+import os
+from subprocess import Popen, PIPE, call
+
+from modules import cbpi, app
+from modules.core.hardware import SensorPassive
+import json
+import os, re, threading, time
+from flask import Blueprint, render_template, request
+from modules.core.props import Property
+
+blueprint = Blueprint('one_wire', __name__)
+
+temp = 22
+
+def getSensors():
+    try:
+        arr = []
+        for dirname in os.listdir('/sys/bus/w1/devices'):
+            if (dirname.startswith("28") or dirname.startswith("10")):
+                arr.append(dirname)
+        return arr
+    except:
+        return []
+
+
+
+
+class myThread (threading.Thread):
+
+    value = 0
+
+
+    def __init__(self, sensor_name):
+        threading.Thread.__init__(self)
+        self.value = 0
+        self.sensor_name = sensor_name
+        self.runnig = True
+
+    def shutdown(self):
+        pass
+
+    def stop(self):
+        self.runnig = False
+
+    def run(self):
+
+        while self.runnig:
+            try:
+                app.logger.info("READ TEMP")
+                ## Test Mode
+                if self.sensor_name is None:
+                    return
+                with open('/sys/bus/w1/devices/w1_bus_master1/%s/w1_slave' % self.sensor_name, 'r') as content_file:
+                    content = content_file.read()
+                    if (content.split('\n')[0].split(' ')[11] == "YES"):
+                        temp = float(content.split("=")[-1]) / 1000  # temp in Celcius
+                        self.value = temp
+            except:
+                pass
+
+            time.sleep(4)
+
+
+
+@cbpi.sensor
+class ONE_WIRE_SENSOR(SensorPassive):
+
+    sensor_name = Property.Select("Sensor", getSensors())
+
+    def init(self):
+
+        self.t = myThread(self.sensor_name)
+
+        def shudown():
+            shudown.cb.shutdown()
+        shudown.cb = self.t
+
+        self.t.start()
+
+    def stop(self):
+        try:
+            self.t.stop()
+        except:
+            pass
+
+    def read(self):
+        if self.get_config_parameter("unit", "C") == "C":
+            self.data_received(self.t.value)
+        else:
+            self.data_received(format(9.0 / 5.0 * self.t.value + 32, '.2f'))
+
+    @classmethod
+    def init_global(self):
+        try:
+            call(["modprobe", "w1-gpio"])
+            call(["modprobe", "w1-therm"])
+        except Exception as e:
+            pass
+
+
+@blueprint.route('/<int:t>', methods=['GET'])
+def set_temp(t):
+    global temp
+    temp = t
+    return ('', 204)
+
+
+@cbpi.initalizer()
+def init(cbpi):
+    cbpi.app.logger.info("INITIALIZE ONE WIRE MODULE")
+    cbpi.app.register_blueprint(blueprint, url_prefix='/api/one_wire')