Projekte
Auf für nicht-Mitglieder interessant: Unsere spannenden Projekte, zum nachmachen und inspirieren!
- Upgrade einer Kaffee-Mühle
- CO2 Melder
- Moode Audio Player
- Klappstuhl (unvollständig)
- Disco-Kugel (unvollständig)
- Mobiler Picknick-Tisch
- Klapphocker (unvollständig)
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:
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:
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:
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
- Arduino (egal ob Nano, Uno oder Mega) (https://amzn.to/32nR6D1*)
- MQ135 Luftqualität-Sensor (https://amzn.to/32lIFbz*)
- Leuchtdioden (im Idealfall 5mm LEDs) (https://amzn.to/3twDSje*)
- rot
- gelb
- grün
- Summer (https://amzn.to/3ed9bcu*)
- Platine (Rohling: https://amzn.to/3sAwGSc* oder https://amzn.to/2QF6PeA*)
- Gehäuse (https://www.prusaprinters.org/de/prints/64081-co2-detector)
- DIN912 M2x12 (https://amzn.to/3ttuHAk*)
Wir verwenden zum Testen einen Arduino Mega
Der Luftqualität-Sensor MQ135 - die Version spielt keine Rolle
Aufbau
Der MQ135 wird an 5V, Masse und einen analog Eingang angeschlossen
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.
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.
Über den seriellen Monitor unter Werkzeuge > Serieller Monitor können wir die Nachrichten von dem Arduino lesen.
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.
Die Bibliothek als zip herunterladen.
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:
- Der Sensor muss "einbrennen". Dafür sollte der Sensor zwischen 24 und 48 Stunden einfach angeschlossen sein.
- 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:
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 | Gravurstichel | |
Bohrungen für Lötstellen | Bohrer 1 mm | |
Bohrungen für die Befestigung des Gehäuses | 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.
Nach beendetem Fräsvorgang sieht die Platine so aus.
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:
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:
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.
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
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
- 2x 62.5 x 4.5 x 2 cm
- 4x 37.5 x 4.5 x 2 cm
- 16x 4x45 Spax
Rückenlehne
- 2x 80 x4.5 x 2 cm
- 3x 37.5 x4.5 x 2 cm
- 12x 4x45 Spax
- 1x Stofftasche 50 x 50 cm
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
- Arduino (https://amzn.to/3AigJXC*)
- Mikrofon (*)
- Lochrasterplatine (*)
- LED-Band (*)
- (Welcher Durchmesser) Kabel (*)
- Holzgehäuse
- Diffusor + Zwischenrahmen ()
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
- 1x Leimholzplatte aus Buche 400x400x18mm (Link Bauhaus)
- 4x Scharniere (Link Aliexpress)
- 16x Senkkopfschrauben (2,5 × 8 mm)
- 2x Senkkopfschrauben (2,5 × 25 mm)
- Leinöl (lebensmittelecht)
Tasche
- Robuster Baumwollstoff (recycelt)
- 2x Nylon-Gurte
- Reißfester Faden
Benötigtes Werkzeug
Holzbearbeitung
- 3D-gedruckte Frässchablone (Link Printables)
- Oberfräse
- Rundfräser mit Anlaufring (5/8" Höhe, 3/4" Ø) (Link Aliexpress)
- Bündigfräser (15 mm Ø)
- Abrundfräser
- Tischkreissäge mit Kreis-Jig
- Kappsäge (für präzise Winkelschnitte)
- Akku-Schrauber
- Schleifpapier (Körnungen bis 240)
Textilverarbeitung
- Nähmaschine
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.
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.
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.
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
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.
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.
Wichtig: Die Ausrichtung der Scharniere muss dem 70°-Winkel der Beine exakt folgen.
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.
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.
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.
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.