Hobbybrauer.de

Hallo zusammen,

ich braue seit einiger Zeit mit CBPi, einer modifizierten Hendi-Induktionsplatte (s. andere Threads hier) und Brew-in-a-Bag. Ich habe schon mein eigenes CBPi Plugin zur Regelung der Hendi gebastelt (Gradientenregelung), welche die Platte über die interne Elektronik steuert (an/aus, Leistung einstellen).

Nun braue ich allerdings sehr kleine Sude (zwischen 6l und 12l Ausschlag) und habe das Problem, dass die Leistung der Hendi eigentlich viel zu groß ist und die Überschwinger beim Maischen sehr groß sind (bis zu 5°), trotz auf die Hälfte oder weniger reduzierte Leistung. Nicht nur beim ersten Hochheizen, sondern durch die Trägheit auch wenn ich die Temperatur halten will.

Meine Idee wäre jetzt, die Ansteuerung wie folgt anzupassen:

1. Modus: Aufheizen auf nächste Rasttemperatur
- definierte Leistung fahren bis Schwellwert A unter Rasttemperatur erreicht
- Leistung halbieren bis Schwellwert B unter Rasttemperatur erreicht
- Leistung halbieren bis Schwellwert C unter Rasttemperatur erreicht
- usw. bis Rasttemperatur erreicht

2. Modus: Temperatur halten
- minimale Leistung fahren und über Hysterese +/- 0,5°C regeln

3. Modus: Kochen
- maximale Leistung fahren bis Kochtemperatur-Schwelle (97°) erreicht, dann auf definierte kleinere Leistung zurückfallen

Hat jemand sowas schon gemacht in CBPi und Ideen, wie sich die Schwellwerte überschlagweise ermitteln lassen? Oder vielleicht sogar eine "kontinuierliche" Leistungsregelung umgesetzt?
Oder eine ganz andere Idee, wie ich die starken Überschwinger vermeiden kann mit dem Setup?

Wenn du mit den Gradienten regelst, gehe ich mal von folgendem Algorithmus aus:

Code: Alles auswählen

HendiEin wenn Tist < (Tsoll - (gradient)
         sonst HendiAUS

Wenn du nun den Gradienten mit einem Gradientenfaktor (GF) versiehst, dann kannst du das Regelverhalten beeinflussen, es gilt:

Je größer die thermische Masse, umso kleiner GF!

Code: Alles auswählen

HendiEin wenn Tist < (Tsoll - (gradient*GF)
         sonst HendiAUS

Durch GF schaltet die Platte vor dem Erreichen der Solltemperatur früher ab.

Meine Maischepfanne hat ein Bruttovolumen von 32L, da hat sich ein GF von 1,2 bewährt.

Bei den von dir angegebenen Mengen würde ich, je nach Leistungseinstellung an der Hendi, GF bei ca. 2-3 sehen.Letztendlich musst du das testen.

Gruß Lothar

Ja, so sieht der Algorithmus aus. GF von 2 oder 3 hab ich noch nicht probiert, hatte bisher auch so 1,2 das war wohl zu wenig.
Parallel dazu versuche ich mal was zu schreiben, was dann auch die Leistung anpasst.

Danke schonmal!

Ich habe das jetzt mal so ähnlich umgesetzt als Plugin für CBPi3:

1. Gradientenregler mit einstellbarem Gradientenfaktor (für 10-12l Maische fahre ich mit 2,5 wohl ganz gut)
2. Leistungsregelung: Je näher an der Zieltemperatur, desto weniger Leistung (mehr oder weniger kontinuierlich, nicht halbiert, wie oben angedacht)
3. Umschalten auf "Kochleistung" ab konfigurierbarer Schwelle (z.B. 90°C)

Im Prinzip funktioniert das super, ich hab mir da ein eigenes Plugin gebaut (Kettle_Controller und Actor). Aber ich habe ein Problem, wo ich mir noch nicht ganz sicher bin, woran das liegt:

Wenn die Platte sich für eine längere Heizpause abschaltet und dann wieder heizen will, startet sie immer mit 500W (Minimum). CBPi zeigt aber die "korrekte" Leistung an. Wenn ich dann die Automatik aus und wieder einschalte, reagiert die Platte wieder korrekt... Jemand eine Idee?
Kurze Pausen von wenigen Sekunden scheinen ihr nichts auszumachen...

Code: Alles auswählen

while self.is_running():
            gradient = float(temps[-1] - temps[0]) #subtract first and last temp in array (lookback time)
            temps.append(float(self.get_temp())) #update array
            
            diff = abs(self.get_target_temp() - self.get_temp())
            mashPower = pmax - (pmax/((0.5 * diff) + 1)) #leistungsregelung
            
            if start == True: #initially switch heater on with mashPower
                self.actor_power(mashPower)
                self.heater_on(power=mashPower)
                start = False
            
            #boil mode
            if self.get_temp() >= boilTemp:
                self.actor_power(boilPower)
                self.heater_on(power=boilPower)
            
            #mash mode
            elif self.get_temp() >= self.get_target_temp() - float(gradient * gradientFactor):
                self.heater_off()
                
            elif self.get_temp() < self.get_target_temp():
                self.actor_power(mashPower)
                self.heater_on(power=mashPower)
                
            else:
                self.heater_off()

Hallo,

das Problem besteht nach wie vor. Mag da mal jemand drüberschauen, ob er im Actor oder beim Kettle einen Bug findet?

Code: Alles auswählen

import logging
import time
from collections import deque

from modules import cbpi
from modules.core.controller import KettleController
from modules.core.props import Property
from modules.core.hardware import ActorBase

from modules.core.props import Property, StepProperty
from modules.core.step import StepBase

try:
    import RPi.GPIO as GPIO
    GPIO.setmode(GPIO.BCM)

except Exception as e:
    print
    e
    pass

@cbpi.controller
class HendiGradientPower(KettleController):

    GradientFactor = Property.Number("Gradient Factor", configurable=True, default_value=1, unit="")
    Pmax = Property.Number("Mash Power", configurable=True, default_value=50, unit="%")
    BoilTemp = Property.Number("Boil Threshold", configurable=True ,default_value=97)
    BoilPower = Property.Number("Boil Power", configurable=True, default_value=40)
    LookbackTime = Property.Number("Lookback Time", configurable=True, default_value=20)
    
    def stop(self):
        super(KettleController, self).stop()
        self.heater_off()
    
    def run(self):
        gradientFactor = float(self.GradientFactor)
        pmax = float(self.Pmax)
        lookbackTime = int(self.LookbackTime)
        tempArray = deque(maxlen=lookbackTime)
        boilTemp = float(self.BoilTemp)
        boilPower = float(self.BoilPower)
        
        mashPower = pmax
        start = True
        
    #queue with last temp values initialized with zeroes
        for i in range(0, lookbackTime):
            tempArray.append(self.get_temp())
        
        while self.is_running():
            gradient = tempArray[-1] - tempArray[0] #subtract first and last temp in array (lookback time)
            tempArray.append(self.get_temp()) #update array
            
            diff = abs(self.get_target_temp() - self.get_temp())
            mashPower = pmax - (pmax/((0.5 * diff) + 1))
            mashPower = round(mashPower, 1)
            
            #boil mode
            if self.get_temp() >= boilTemp:
                self.actor_power(boilPower)
                self.heater_on(power=boilPower)
            #mash mode
            elif self.get_temp() >= self.get_target_temp() - (gradient * gradientFactor):
                self.heater_off()
            elif self.get_temp() < self.get_target_temp():
                self.actor_power(mashPower)
                self.heater_on(power=mashPower)
            self.sleep(1)
        self.heater_off()

@cbpi.actor
class HendiHeater(ActorBase):
    onoff_pin = Property.Select("On/Off Control 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, 27])
    power_pin = Property.Select("Power Control 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, 27])
    freq = Property.Number("PWM Frequency (Hz)", configurable=True)
    Pmax = Property.Number("Max Power (%)", configurable=True, default_value=60, unit="%")

    power = 0
    pwm = None
    #stopped = True

    def init(self):
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(int(self.power_pin), GPIO.OUT)
        GPIO.setup(int(self.onoff_pin), GPIO.OUT)
        GPIO.output(int(self.onoff_pin), 0)
        self.power =  int(self.Pmax)

    def on(self, power=None):
        #self.stopped = False
        if self.pwm is None:
            if self.freq is None:
                self.freq = 100
            self.pwm = GPIO.PWM(int(self.power_pin), int(self.freq))
            self.pwm.start(int(self.power))
        #if(0 == self.power):
            #GPIO.output(int(self.onoff_pin), 0)
        #else:
            #GPIO.output(int(self.onoff_pin), 1)
        self.pwm.start(int(self.power))
        self.pwm.ChangeDutyCycle(int(self.power))
        GPIO.output(int(self.onoff_pin), 1)

    def set_power(self, power):
        self.power = min(int(power), int(self.Pmax))
        self.pwm.ChangeDutyCycle(int(self.power))

    def off(self):
        #self.stopped = True
        self.pwm.ChangeDutyCycle(0)
        self.pwm.stop()
        GPIO.output(int(self.onoff_pin), 0)

juju1337 hat geschrieben: Mittwoch 3. März 2021, 10:53 ich braue seit einiger Zeit mit CBPi, einer modifizierten Hendi-Induktionsplatte (s. andere Threads hier)

Hi,
kannst du den anderen Thread hier mal verlinken nach dem du umgebaut hast? Ich kann jetzt leider nix konkret zu dem Bug im Plugin beitragen, aber mich würde der Umbau der HW interessieren die du verwendest.
Danke.

https://hobbybrauer.de/forum/viewtopic.php?f=58&t=24385 Das ist der Thread an dem ich mich orientiert habe, musst aber ein bisschen durchlesen, was ich anders gemacht habe.

Hobbybrauer.de

Regelung Maischetemperatur/Heizleistung CBPi mit Hendi

Regelung Maischetemperatur/Heizleistung CBPi mit Hendi

Re: Regelung Maischetemperatur/Heizleistung CBPi mit Hendi

Re: Regelung Maischetemperatur/Heizleistung CBPi mit Hendi

Re: Regelung Maischetemperatur/Heizleistung CBPi mit Hendi

Re: Regelung Maischetemperatur/Heizleistung CBPi mit Hendi

Re: Regelung Maischetemperatur/Heizleistung CBPi mit Hendi

Re: Regelung Maischetemperatur/Heizleistung CBPi mit Hendi

Re: Regelung Maischetemperatur/Heizleistung CBPi mit Hendi