Projekte

Auf für nicht-Mitglieder interessant: Unsere spannenden Projekte, zum nachmachen und inspirieren!

Upgrade einer Kaffee-Mühle

(Bericht eines Nicht-Mitglieds, der die Werkstatt zum einmaligen Nutzung besucht hat)

Ich hatte eine Kaffeemühle und den Wunsch, meinen Morgenkaffee etwas einfacher zuzubereiten. Heute mahlt sie eine gewünschte Menge Kaffee auf das Zehntelgramm genau – dank Technik, Teamwork und ein bisschen Tüftelgeist. In diesem kurzen Bericht geht es um mein Projekt und wie mir das Swablab geholfen hat.

Warum denn eigentlich eine Kaffeemühle?

Bevor es in die technischen Details geht, ein kurzer Ausflug in die Welt der Siebträger-Kaffeemaschinen – und warum es überhaupt sinnvoll (oder notwendig?) ist, sich so intensiv mit dem Mahlen von Kaffeebohnen zu beschäftigen.

Für alle, die mit Kaffee eher wenig am Hut haben: kein Problem, einfach zur nächsten Überschrift springen!

Es gibt viele Wege, Kaffee zuzubereiten: vom klassischen Filterkaffee über den Vollautomaten bis hin zur Bialetti auf dem Herd. Wer sich allerdings für eine Siebträgermaschine entscheidet, landet schnell in einem kleinen Universum voller Optimierungsmöglichkeiten. Der Grund: Die Qualität des Espressos hängt von einer Vielzahl an Variablen ab, die alle fein aufeinander abgestimmt sein müssen. Und hier liegt der Unterschied nicht zwischen feinen Noten im Kaffegeschmack, sondern tastächlich ob der Kaffee lecker ist oder lieber mit etwas mehr Milch und Zucker getrunken werden sollte. Mit ein bisschen Erfahrung (und viel Ausprobieren) kann man das Ergebnis gezielt beeinflussen. Dabei ist es wichtig so viele Variablen wie möglich konstant zu halten um andere Variablen wiederum kontrolliert einstellen zu können.

Eine zentrale Rolle spielt dabei die Kaffeemühle, denn frisch gemahlener Kaffee schmeckt tatsächlich besser! Genauer gesagt: zwei Dinge, die man an der Mühle einstellen kann – den Mahlgrad und die Menge des Kaffeepulvers. Während sich der Mahlgrad bei den meisten Mühlen ziemlich präzise einstellen lässt, sieht es bei der Dosierung etwas komplizierter aus. Wie viel Kaffeepulver benötigt wird hängt vom Siebträger ab, aber die Menge sollte jedes Mal bis auf ein Zehntelgramm genau gleich sein. Um das zu erreichen gibt es verschiedene Ansätze, je nach Preisklasse und Komfortwunsch: Ganz einfach beginnt es mit dem sogenannten Single Dosing – man wiegt die Bohnen vorher manuell ab und füllt jedes Mal den Tricher der Mühle mit einer einigen Dosis. Das funktioniert zwar sehr gut, ist aber ein zusätzlicher Aufwand bei jedem Kaffee. Andere Mühlen mahlen nach Zeit, also z.B. fünf Sekunden lang. Und in der Luxusklasse gibt es Modelle, die nach Gewicht dosieren. Letzteres ist zwar sehr komfortabel, aber auch teuer – und selbst da ist Präzision nicht garantiert.

Denn Kaffeebohnen verändern sich mit der Zeit – je nach Röstung, Luftfeuchtigkeit oder Lagerung. Was gestern noch perfekt dosiert war, kann heute zu viel oder zu wenig sein. Wer also mit einer zeitgesteuerten Mühle arbeitet, misst oft nach dem Mahlen nochmal mit der Waage nach, schüttet Pulver wieder zurück oder raus – ein ziemlicher Aufwand. Single Dosing war mir zu aufwändig und die Luxusklasse zu teuer. Daher das Ziel: eine günstigere Mühle zu einer nach Gewicht mahlenden Mühle aufrüsten!

Die Idee

Die Grundlage für mein Projekt war eine gebrauchte Eureka Mignon Silenzio die ich auf Ebay Kleinanzeigen gefunden hatte. Diese hat zwar einen einen integrierten Timer, aber zusätzlich auch einen manuellen Modus. Solange ein Taster unterhalb des Auswurfes gedrückt hält mahlt sie, lässt man ihn los, stoppt sie. Meine Idee war es, die Kabel des Tasters im Inneren der Mühle mit einem ESP32, einem günstigen Mikrocontroller mit WLAN, zu verbinden um mit diesem den Mahlvorgang zu steuern. In Kombination mit einer digitalen Waage sollte er genau das übernehmen, was sonst teure Mühlen mit integrierter Gewichtsdosierung tun. Mit dieser Idee im Kopf ging es auf ins Swablab.

Das Innere der Kaffeemühle

Das Innenleben der Eureka Mignon zu erkunden, war überraschend unkompliziert. Mit ein paar Schrauben war das Gehäuse schnell geöffnet – und was zum Vorschein kam, war erfreulich simpel aufgebaut. Das Innenleben sah so aus:

bild1.jpg

Die Elektronik im Inneren der Maschine ist relativ einfach, der Mahlknopf ist über ein Kabel mit dem Rest verbunden (gelber Kreis). Zusätzlich scheint es mehrer Pins zu geben (roter Kreis), an die bei teureren Versionen wahrscheinlich eine weitere Steuerungseinheit angeschlossen wird. Mit einem Swablab-Multimeter und einem extra Paar Swablab-Augen habe ich dann geprüft, ob es zwischen den Pins und dem Taster eine Verbindung gibt - und tatsächlich: zwei der Pins sind direkt mit dem Taster verbunden. Weiterhin gibt es einen Pin der auf Masse liegt und ein anderer führ eine Spannung von 3 Volt - genau das, was ein ESP32 als Stromversorgung benötigt.

Ich konnte also problemlos ein kleines Kabel an die entsprechenden Punkte anschließen und die Mühle danach wieder vollständig zusammenschrauben. Die Modifikation lässt sich jederzeit rückgängig machen – falls ich das Ganze später doch wieder im Originalzustand nutzen oder verkaufen möchte.

Elektro-Zeugs

Im Herzen des Projekts steckt ein ESP32 – ein kleiner Mikrocontroller, den man sich wie einen Mini-PC mit WLAN vorstellen kann. Er lässt sich frei programmieren und ist in der Lage, andere elektronische Bauteile zu steuern und auszulesen. Dazu gibt es den ESP bereits ab 5 Euro zu kaufen, was ihn ideal für DIY-Projekte wie dieses macht. So wurde im Swablab neben mir z.B. eine WLAN-Türklingel mit einem ESP32 gebaut. (Vielleicht funktioniert diese ja wenn ich das nächste Mal da bin ;) )

Neben dem ESP kamen noch ein paar weitere Komponenten zum Einsatz: Eine sogenannte Load-Cell, zur Messung des Gewichtes des Kaffeepulvers, ein kleines OLED-Display, das aktuelle Werte und Einstellungen anzeigen kann, sowie ein Drehknopf um die Mühle zu bedienen.

Den Aufbau der Schaltung, die Verbindung der einzelnen Bauteile und das Programmieren des Codes habe ich selbst übernommen. Aber selbst wenn man da mal hängen bleibt: Im Swablab sind eigentlich immer ein paar Leute da, die sich mit sowas auskennen und gern helfen. Was ich aber definitiv gebraucht habe: Werkzeug und Material. Schrauben, Kabel, ein Lötkolben, Lötzinn – all das habe ich direkt vor Ort im Swablab genutzt. Es ist super praktisch, dort auf eine voll ausgestattete Werkbank zurückgreifen zu können, ohne alles selbst besitzen oder mitbringen zu müssen. Schrauben und Kabel selber kaufen ist natürlich auch möglich, die gibt es aber oft nicht in kleinen Mengen und der Rest liegt danach aus Erfahrung lange in einer dunklen Schublade im Keller. Auch das Ausprobieren und Finden von passenden Schrauben ist vor Ort deutlich angenehmer.

Untergebracht wurde die gesamte Elektronik in einem 3D-gedruckten Gehäuse, welches unter die Kaffeemühle passt. Gedruckt hat sie ein Freund von mir, aber auch das Swablab-Team bietet einen eigenen 3D-Druckservice an – ideal für alle, die keinen Drucker zu Hause haben oder besondere Anforderungen an ihr Gehäuse stellen. Nachdem ich alle Bauteile verlötet hatte, konnte ich die Elektronik in das Gehäuse einsetzen und mit Heißkleber fixieren. Das Ergebnis - noch nicht ganz verklebt - ist hier zu sehen:

bild2.jpg

Das Ergebnis

Kurz gesagt: Voller Erfolg, auch wenn ich den Code des ESPs einige Male noch anpassen musste.Das Zielgewicht kann über Drehknopf und Display angepasst werden und der Mahlvorgang gestartet werden. War ein toller Moment, als dann alles zusammen gepasst hat und das erste Mal richtig funktioniert hat!

Rückblickend war das ein richtig produktiver Samstag im Swablab: gute Stimmung, kreatives Tüfteln, konzentriertes Arbeiten und ein tolles Endergebnis. Hier noch ein letztes Bild vom Endprodukt:

bild3.jpg

CO2 Melder

Wir bauen einen einfachen CO2 Melder der den CO2 Gehalt der Luft misst und ein Signal ausgibt, sobald bestimmte Werte überschritten werden.
Nachfolgend findet ihr eine Anleitung, sowie alle benötigten Teile. Viel Spaß beim Nachbauen!

Bauteile

co2_melder_arduino_mega.jpg
Wir verwenden zum Testen einen Arduino Mega

co2_melder_mq135.jpg
Der Luftqualität-Sensor MQ135 - die Version spielt keine Rolle

Aufbau

co2_melder_aufbau1.jpg
Der MQ135 wird an 5V, Masse und einen analog Eingang angeschlossen

aufbau_zeichnung1.jpg

co2_melder_aufbau2.jpg

Am CO2 Melder werden drei LEDs installiert, eine grüne, eine gelbe und eine rote. Diese zeigen drei Luftqualitätslevel an. Die grüne leuchtet wenn alles in Ordnung ist, die gelbe soll leuchten, sobald gelüftet werden sollte und die rote soll angehen, wenn der CO2 Gehalt zu hoch wird und gelüftet werden muss. Zusätzlich zu den LEDs wird ein Summer verbaut, der anfängt zu piepsen, sobald die rote LED leuchtet.

Software

Um die Software für unseren CO2 Melder zu schreiben nutzen wir die Arduino IDE

Nachdem wir die IDE installiert haben, müssen wir das Board umstellen, das wir nutzen. In unserem Fall ist das ein Arduino MEGA Board.

arduinoide_board.png

Einstieg

Wir beginnen mit einem einfachen Programm, das die rohen Daten von unserem Sensor liest und über die serielle Schnittstelle ausgibt:


void setup() {
  // setzt die Datenrate für die serialle Datenübertragung
  Serial.begin(9600);
}

void loop() {
  // liest den analolgen Wert an A0
  float value = analogRead(A0);
  // schreibt den Wert über die serialle Schnittstelle
  Serial.println(value);
  // wartet 1000ms = 1s
  delay(1000);
}

Wir stellen sicher, dass das Arduino Board an unserem PC über USB angeschlossen ist und unter Werkzeuge > Port, der korrekte USB Eingang ausgewählt ist.
Dann können wir unser Programm auf den Arduino übertragen.

arduinoide_upload.png
Über den seriellen Monitor unter Werkzeuge > Serieller Monitor können wir die Nachrichten von dem Arduino lesen.
arduinoide_serialler_monitor.png

Werte in ppm auslesen

So sind wir also bereits in der Lage, einfache Daten des Sensor auszulesen. Aber wie kommen wir jetzt von diesen Daten auf den CO2-Gehalt der Luft?
Dazu verwenden wir eine Bibliothek für den MQ135, die uns die Werte umrechnet: MQ135 Bibliothek

Wir binden die Bibliothek in unser Programm ein und können die bereitgestellten Funktionen nutzen.
Die Bibliothek kann als zip heruntergeladen und dann in der IDE importiert werden.

download_library_github.png
Die Bibliothek als zip herunterladen.

load_zip_library.png
Die Bibliothek kann als zip eingebunden werden.

Damit auf die Funktionen der Bibliothek zugegriffen werden kann, muss sie in das Programm eingebunden werden:


#include <MQ135.h>

Das ganze Projekt sieht dann so aus:


#include <MQ135.h>

#define PIN_MQ135 A0

// Die Bibliothek stellt uns ein MQ135 Objekt zur Verfügung
// Das Objekt wird der Pin übergeben, an dem der Sensor angeschlossen ist.
MQ135 co2_sensor(PIN_MQ135);

void setup() {
  Serial.begin(9600);
}

void loop() {
    // über unser MQ135 Objekt können wir direkt den CO2 Gehalt lesen
  float value = co2_sensor.getCO2();
  Serial.print("co2: ");
  Serial.println(value);
  delay(1000);
}

Kalibrierung

Bevor der Sensor richtig zum Einsatz kommt und korrekte Werte liefert, muss er kalibriert werden. Zur Kalibrierung sind folgende Schritte notwendig:

  1. Der Sensor muss "einbrennen". Dafür sollte der Sensor zwischen 24 und 48 Stunden einfach angeschlossen sein.
  2. Jetzt kann der Sensor kalibriert werden. Wenn kein Vergleichswert von einem anderen CO2-Messer herangezogen werden kann, kann der Sensor an der frischen Luft kalibriert werden. Wir gehen davon aus, dass draußen im Freien der durchschnittliche CO2 Gehalt (von ca. 400ppm) herrscht. Die Library bietet eine Funktion, die den R0 Wert für den gemessenen Widerstand bei ca. 400ppm ausgibt. Wir lassen den Sensor nach dem Einbrennen einige Minuten an der frischen Luft und Starten dann die Kalibrierung. Dazu berechnen wir einige R0 Werte und mitteln dann über alle gemessenen Werte. Hierdurch wird unser R0 Wert ermittelt, der exakt für diesen einen, von uns verbauten Sensor gilt. Der Vorgang wird einmalig durchgeführt, danach kann der Sensor verwendet werden.

Das Kalibrierungs-Programm:


#include <MQ135.h>

#define PIN_MQ135 A0

MQ135 co2_sensor(PIN_MQ135);

void setup() {
  Serial.begin(9600);

  double summe = 0;

  // startet eine Schleife die 500 mal läuft
  for (int i = 1; i <= 500; i++) {
    // liest den R0 Wert, der für ~400ppm bei der gemessenen Spannung gilt
    float r0 = co2_sensor.getR0();
    // wir summieren alle gemessenen Werte
    summe += r0;
    if (i % 10 == 0) {
      Serial.print("Messung Nr. ");
      Serial.println(i);
    }
    delay(200);
  }

  // unser tatsächliches R0 ist der Mittelwert aus allen gemessenen Werten
  float R0 = summe / 500;

  Serial.print("R0: ");
  Serial.println(R0);
}

void loop() {

}

Es werden 500 Werte verwendet, deren Durschnitt anschließend Anwendung findet. Hieraus resultiert unser Kalibrierungswert R0. Jetzt können wir unser eigentliches Programm schreiben.


#include <MQ135.h>

#define PIN_MQ135 A0
#define PIN_LED_GREEN DD2
#define PIN_LED_YELLOW DD3
#define PIN_LED_RED DD4

MQ135 co2_sensor(PIN_MQ135);
float ppm;

void setup() {
  pinMode(PIN_LED_GREEN, OUTPUT);
  pinMode(PIN_LED_YELLOW, OUTPUT);
  pinMode(PIN_LED_RED, OUTPUT);
  pinMode(PIN_NOISE, OUTPUT);
  // Kalibrierung mit dem zuvor berechneten Wert
  co2_sensor.setR0(xxx);
}

void loop() {
  ppm = co2_sensor.getCO2();

  if (ppm < 1000) {
    digitalWrite(PIN_LED_GREEN, 1);
    digitalWrite(PIN_LED_YELLOW, 0);
    digitalWrite(PIN_LED_RED, 0);
  }
  else if (ppm <= 2000) {
    digitalWrite(PIN_LED_GREEN, 0);
    digitalWrite(PIN_LED_YELLOW, 1);
    digitalWrite(PIN_LED_RED, 0);
  }
  else {
    digitalWrite(PIN_LED_GREEN, 0);
    digitalWrite(PIN_LED_YELLOW, 0);
    digitalWrite(PIN_LED_RED, 1);
  }

  delay(1000);
}

Jetzt fehlt noch der Summer. Dafür müssen wir unser Programm etwas umstellen, da wir neue CO2 Werte nur jede Sekunde einlesen wollen, der Summer jedoch, wenn er aktiv ist, in einem schnelleren Takt als eine Sekunde summen soll.
Wir führen einen Zähler ein, der immer von 0 bis 10 zählt und anschließend misst. Wenn der Wert bei über 2000 ppm liegt aktivieren wir den Summer und schalten ihn in jedem Durchgang abwechselnd ein und aus.


#include <MQ135.h>

#define PIN_MQ135 A0
#define PIN_LED_GREEN DD2
#define PIN_LED_YELLOW DD3
#define PIN_LED_RED DD4
#define PIN_NOISE DD5

void printValues();

const int maxCount = 10;
int count = 0;
bool noise = false;
bool noiseActive = false;

float ppm;

MQ135 co2_sensor(PIN_MQ135);

void setup() {
  pinMode(PIN_LED_GREEN, OUTPUT);
  pinMode(PIN_LED_YELLOW, OUTPUT);
  pinMode(PIN_LED_RED, OUTPUT);
  pinMode(PIN_NOISE, OUTPUT);
  Serial.begin(9600);
  co2_sensor.setR0(xxx);
}

void loop() {
  if (count >= maxCount || count < 0) {
    ppm = co2_sensor.getCO2();

    count = 0;
    if (ppm < 1000) {
      noiseActive = false;
      digitalWrite(PIN_LED_GREEN, 1);
      digitalWrite(PIN_LED_YELLOW, 0);
      digitalWrite(PIN_LED_RED, 0);
    }
    else if (ppm <= 2000) {
      noiseActive = false;
      digitalWrite(PIN_LED_GREEN, 0);
      digitalWrite(PIN_LED_YELLOW, 1);
      digitalWrite(PIN_LED_RED, 0);
    }
    else {
      noiseActive = true;
      digitalWrite(PIN_LED_GREEN, 0);
      digitalWrite(PIN_LED_YELLOW, 0);
      digitalWrite(PIN_LED_RED, 1);
    }

    printValues();
  }

  if (noiseActive) {
    noise = !noise;
    digitalWrite(PIN_NOISE, noise);
  }
  else {
    digitalWrite(PIN_NOISE, 0);
  }

  delay(100);
  count++;
}

void printValues() {
  Serial.print("ppm: ");
  Serial.println(ppm);
}

Wir starten mit dem Zähler bei -1 int count = -1;, sodass wir beim ersten Durchgang direkt eine Messung machen. Dafür schreiben wir in die Bedingung der Messung, dass wir entweder messen, wenn der Zähler die Schwelle von 10 überschritten hat, oder wenn der Zähler kleiner als 0 ist:


if (count >= maxCount || count < 0)

Wenn der CO2 Gehalt größer als 2000 ppm ist, aktivieren wir den Summer (noiseActive = true;) und schalten diesen bei jedem Durchgang ein oder aus:


noise = !noise;
digitalWrite(PIN_NOISE, noise);

Zum Schluss dürfen wir nicht vergessen zu warten und den Zähler zu erhöhen:


delay(100);
count++;

Nach einer Messung müssen wir den Zähler wieder auf 0 zurück setzen count = 0;

Der Quellcode ist auch in unserem Github Repository zu finden: Quellcode.
Die Bibliothek für den MQ135 befindet sich ebenfalls auf Github: Bibliothek

Optisches Tuning

Unser CO2 Melder hat inzwischen alle Funktionalitäten, um den CO2-Gehalt der Luft zu Messen und beim Überschreiten eines kritischen Schwellwertes dies über optische und/oder akustische Signale zu melden. Einen Schönheitspreis würde er aber noch nicht gewinnen.

Platine

Der ganze Prototypen-Aufbau mit einem Arduino Mega, einem Breadboard und Steckkabelverbindung ist platzintensiv und fehleranfällig. Es reicht bereits ein einfacher Wackelkontakt eines Kabels, dass LEDs nicht mehr leuchten oder die Werte eines Sensor nicht mehr korrekt ermittelt werden können.
Diese beiden Nachteile können durch verwenden eines Arduino Nano (sehr kleiner Mikrocontroller) und einer festen Verlötung der Bauteile auf einer Platine beseitigt werden.

Um Platinen herzustellen gibt es unterschiedliche Vorgehensweisen. Als Grundlage dient oft eine Kunststoffplatte, die auf einer Seite mit einer sehr dünnen Kupferschicht überzogen ist. Um die elektronischen Bauteile auf der Platine zu befestigen, werden an den entsprechenden Stellen Löcher in die Platine gebohrt. Um Leiterbahnen zur Verbindung der Löcher zu erstellen, wird die Kupferschicht an den Rändern der Leiterbahnen entfernt.
Zwei gängige Verfahren zum Auftrennen der Kupferschicht in einzelne Leiterbahnen sind beispielsweise fräsen und ätzen.

Wir haben uns dazu entschieden die Leiterbahnen auf unserer Platine durch fräsen zu trennen. Dazu entwirft man zunächst eine Vektorgrafik, welche die Bohrungen für die Bauteile beinhaltet. Anschließend fügt man Linien als Abtrennung der Leiterbahnen ein.
Wir haben Affinity Designer zur Entwicklung dieser Vektorgrafik genutzt, es gibt aber auch freie Alternativen, mit denen ebenfalls Vektorgrafiken erstellt werden können, beispielsweise Inkscape. Nachfolgende Grafik zeigt unser entworfenes Schema für die Platine:

platine_co2_4_fuer-cad-import.png

Die folgenden SVG-Dateien enthalten nur die Inhalte aus diesem Platinenschema, die für die jeweilige Bearbeitung relevant ist:

Fräsbearbeitung

Download-Link

Fräswerkezeug

Leiterbahnen

platine_co2_4_leiterbahnen.svg

Gravurstichel

Bohrungen für Lötstellen

platine_co2_4_loetstellen.svg

Bohrer 1 mm

Bohrungen für die Befestigung des Gehäuses

platine_co2_4_bohrung_gehaeuse.svg

Bohrer 2,5 mm

Aus diesen Vektorgrafiken kann nun ein NC-Code generiert werden. Mit dem erzeugten NC-Code weiß die CNC-Fräsmaschine, wo welche Bearbeitungen vorgenommen werden sollen. Da wir einen Snapmaker 2.0 zum fräsen verwenden, nutzen wir zum erzeugen der Fräsbahnen und Bohrungen die Software Snapmaker Luban.

platine_fraesung.jpg

Nach beendetem Fräsvorgang sieht die Platine so aus.

platine_unbestueckt.jpg

Als nächstes muss die Platine mit den Bauteilen bestückt und die Anschlüsse an die Platine gelötet werden. Hierzu kann man obiges Platinenschema als Hilfe verwenden.
Nach erfolgreicher Verlötung sieht die endgültige Platine dann so aus:

platine.jpg

Gehäuse

Um die selbst gebaute Platine vor Staub und sonstigen Umwelteinflüssen zu schützen, wird ein Gehäuse entworfen. Dieses soll möglichst klein sein, um den CO2 Melder jederzeit an anderen Standorten einsetzen zu können. Da wir die Möglichkeit haben, auf 3D Drucker zurückzugreifen, liegt es nahe, auch dieses Gehäuse mit dem 3D-Druckverfahren zu fertigen. Hierfür werden sämtliche Bauteile im CAD erstellt. Anschließend wird das Gehäuse gedruckt. Das Ergebnis sieht wie folgt aus:
screenshot_2021-04-17_230742.jpg

Falls kein 3D Drucker verwendet werden kann, kann selbstverständlich jedes andere passende Gehäuse verwendet werden.

Die Dateien für das Gehäuse können hier heruntergeladen werden: https://www.prusaprinters.org/de/prints/64081-co2-detector (Step vorhanden, um nötige Änderungen für euren Anwendungsfall möglich zu machen).

Zusammenbau

Der Zusammenbau gestaltet sich sehr einfach. Bei Bedarf sollten zuerst die 3D Druck Teile gesäubert werden. Anschließend kann die Platine in das Gehäuse eingelegt werden. Hierbei muss darauf geachtet werden, dass zuerst der USB-Aschluss des Arduinos in dessen vorgesehene Position geschoben wird und anschließend die gesamte Platine im Gehäuse versenkt wird. Anschließend kann der MQ135 Sensor in das Gehäuse eingelegt werden. Nun kann der Gehäusedeckel auf das Unterteil des Gehäuses gelegt werden und mit vier Zylinderschrauben fixiert werden.
screenshot_2021-04-20_205843.jpg

Jetzt ist der CO2 Melder für seinen vorgesehen Einsatzzweck bereit.

Bei den mit "*" markierten Links handelt es sich um Affiliate-Links.
Wenn ihr etwas über diese Links kauft, erhalten wir eine kleine Provision. Für euch ändert sich dabei nichts.
Dadurch könnt ihr uns ohne Aufwand unterstützen!
Wo ihr eure Sachen kauft, bleibt aber natürlich euch überlassen!

Moode Audio Player

Die Musiksteuerung wird über Moode Audio auf einem Raspberry Pi realisiert.

Spotify Settings

Um zu verhindern, dass die Lautstärke nach jedem Verbindungsabbruch wieder auf 0 gesetzt wird, folgende Einstellung setzen.

Renderers > Spotify Connect > EDIT Spotify Connect Settings > Volume Control > Initial Volume

image.png

CamillaDSP Settings

Um Stereo auf einen Mono Ausgang zu mixen wird der CamillaDSP von Moode Audio mit folgender Konfiguration genutzt:

description: null
devices:
  adjust_period: null
  capture:
    channels: 2
    extra_samples: null
    filename: /dev/stdin
    format: S32LE
    read_bytes: null
    skip_bytes: null
    type: File
  capture_samplerate: null
  chunksize: 1024
  enable_rate_adjust: null
  playback:
    channels: 2
    device: plughw:2,0
    format: S32LE
    type: Alsa
  queuelimit: 1
  rate_measure_interval: null
  samplerate: 44100
  silence_threshold: null
  silence_timeout: null
  stop_on_rate_change: null
  target_level: null
  volume_ramp_time: 150
filters:
  HighBoost:
    description: null
    parameters:
      freq: 10000
      gain: 10
      type: HighshelfFO
    type: Biquad
  LowBoost:
    description: null
    parameters:
      freq: 50
      gain: 20
      type: LowshelfFO
    type: Biquad
  mastergain:
    description: null
    parameters:
      gain: 0
      inverted: null
      mute: null
      scale: null
    type: Gain
mixers:
  MonoOutput:
    channels:
      in: 2
      out: 2
    description: null
    mapping:
    - dest: 0
      mute: false
      sources:
      - channel: 0
        gain: -6
        inverted: false
        mute: false
        scale: dB
      - channel: 1
        gain: -6
        inverted: false
        mute: false
        scale: dB
    - dest: 1
      mute: false
      sources:
      - channel: 0
        gain: -6
        inverted: false
        mute: false
        scale: dB
      - channel: 1
        gain: -6
        inverted: false
        mute: false
        scale: dB
pipeline:
- bypassed: false
  description: null
  name: MonoOutput
  type: Mixer
- bypassed: false
  channel: 1
  description: null
  names:
  - HighBoost
  - LowBoost
  type: Filter
processors: null
title: null

Klappstuhl (unvollständig)

Materialliste

Sitzfläche

Rückenlehne

5,5 m Holzlatten/Stuhl
ca 110m Holzlatten für 20 Stühle
28 Spax/Stuhl
560 spax für 20 Stühle


Zusammenbau

Schritt 1: Holzlatten zusammenstellen

Alle in der Materialliste aufgeführten Holzlatten an bereitgestellter Materialausgabe abholen und nach den Größen sortiert an den gewünschten Arbeitsplatz legen.

Schritt 2: Holzlatten abschleifen

Alle Kanten und Flächen des Baumaterials abschleifen, bis keine scharfen Kanten oder größere Spreißen mehr zu sehen sind. Das hierfür benötigte Schleifpapier ist ebenfalls bei der Materialausgabe zu finden.

Disco-Kugel (unvollständig)

Wir bauen eine Disco-Kugel, welche auf Geräusche und Musik reagieren kann und dadurch ihre Farbe ändert. Wir haben diese Disco-Kugel als ein Sommerferienprogramm entworfen, um den Kindern das Löten näher zu bringen.

Nachfolgend findet ihr eine Anleitung, sowie alle benötigten Teile. Viel Spaß beim Nachbauen!

Bauteile

Software

Hardware

3D Druck

Holzgehäuse

Um die Elektronik aufzubewahren verwenden wir ein selbstgebautes Holzgehäuse.

Zusammenbau

Bei den mit "*" markierten Links handelt es sich um Affiliate-Links.
Wenn ihr etwas über diese Links kauft, erhalten wir eine kleine Provision. Für euch ändert sich dabei nichts.
Dadurch könnt ihr uns ohne Aufwand unterstützen!
Wo ihr eure Sachen kauft, bleibt aber natürlich euch überlassen!

Mobiler Picknick-Tisch

Erstellt von: Daniel Moser
Erstellt am: 18.05.2025

Projektidee

Ziel dieses Projekts war es, einen transportablen, funktionalen und gleichzeitig ästhetischen Picknick-Tisch aus hochwertigem Buchenholz zu gestalten – ideal für den Einsatz im Freien, beispielsweise für ein Picknick mit Wein und Snacks. Besonderes Augenmerk lag auf klappbaren Tischbeinen, praktischen Aussparungen für Gläser und Flaschen sowie einer maßgefertigten Tragetasche.

Verwendete Materialien

Tisch

Tasche

Benötigtes Werkzeug

Holzbearbeitung

Textilverarbeitung

Arbeitsschritte

1. Zuschneiden der Tischplatte

Die Buchenholzplatte wurde zunächst grob zugeschnitten und mithilfe einer selbstgebauten Kreis-Jig auf der Tischkreissäge rund (400 mm Durchmesser) ausgearbeitet.

1000053089.jpg

1000053090.jpg

2. Fräsarbeiten an der Tischoberfläche

Zur Bearbeitung wurde die runde Tischplatte mittels Vakuumsauger sicher auf der Arbeitsplatte fixiert. Eine passgenaue 3D-gedruckte Schablone wurde angebracht.
Mit dem Rundfräser und Anlaufring wurden drei runde Vertiefungen eingefräst – zuerst das Innere grob entfernt, dann der Rand abgefahren, um Brandspuren zu vermeiden.

1000053309.png

1000053086.jpg

1000053087.jpg

Anschließend wurden Aussparungen für eine Weinflasche und zwei Weinglashalterungen mit dem Bündigfräser eingefräst. Die Kanten der gesamten Platte wurden abschließend mit einem Abrundfräser bearbeitet.

1000053088.jpg

3. Anfertigung der Tischbeine

Für die Beine wurden recycelte Tischbeine aus Birkenholz verwendet. Alternativ lässt sich auch ein Teil der Leimholzplatte dafür nutzen. Ein detaillierter Plan zur Bestimmung der Maße und der Gewichtsverteilung wurde im Vorfeld erstellt.

Plan: picnic_table_plan_v5.pdf

1000053094.jpg

Zuerst Zuschnitt auf Länge mittels Kappsäge. Danach wurden Längsschnitte zur Herstellung der Beine vorgenommen. Die Enden der Beine wurden beidseitig im Winkel von 70° geschnitten (Sägeeinstellung: 20°). Es wurden insgesamt vier Beine, eine kurze und eine lange Querstrebe benötigt.

1000053083.jpg

4. Vorbereitung und Montage der Scharniere

Die Scharniere wurden mit einem Nutfräser in die Beine eingelassen, um eine bündige Auflagefläche zu schaffen. Aufgrund der geringen Materialstärke wurde auf eine Einlassung in die Tischplatte verzichtet. Befestigung erfolgte mit 2,5 × 8 mm Senkkopfschrauben.


1000053084.jpg

Wichtig: Die Ausrichtung der Scharniere muss dem 70°-Winkel der Beine exakt folgen.

1000053085.jpg

5. Montage der Tischbeine

Die Beine wurden mit den Querstreben verleimt und zusätzlich mit 2,5 × 25 mm Senkkopfschrauben fixiert. Vorbohrungen verhindern das Spalten des Holzes. Im Anschluss wurden die fertigen Tischbein-Halter an der Unterseite der Tischplatte montiert.

1000053091.jpg

6. Feinschliff und Oberflächenbehandlung

Nach dem finalen Schleifen mit bis zu 240er Körnung wurde die gesamte Holzoberfläche mit lebensmittelechtem Leinöl behandelt, um sie zu schützen und gleichzeitig die Holzmaserung hervorzuheben.

1000053092.jpg

1000053081.jpg

7. Transporttasche

Für den Transport des Tisches wurde aus einem robusten, recycelten Baumwollstoff eine passende Tragetasche genäht. Die Tasche stammt ursprünglich aus der Verpackung eines Kochgeschirrsets.


1000053192.jpg

Die oberen Säume wurden zusätzlich verstärkt und reißfester Faden verwendet, um die hohe Belastung durch das Tischgewicht abzufangen. Zwei Nylon-Tragegurte ermöglichen komfortablen Transport.

1000053193.jpg

Ich wünsche viel Freude beim Nachbauen und kreative Stunden in der Werkstatt!

Klapphocker (unvollständig)