Team Bastler
Contents
Einleitung
MEDTECH DIY Blockwoche
Herzlich Willkommen auf der offiziellen Homepage des Team Bastler - Projektteams. Das Team entstand während der Blockwoche Medizintechnik. Diese fand an der Hochschule Luzern Technik & Architektur im FabLab vom 12. bis 17. Februar 2024 statt. Ziel der Blockwoche ist es, den Studierenden durch das selbstständige Entwickeln und Testen von Prototypen medizinischer Geräte die Schnittstelle zwischen Technik und Medizin näher zu bringen. Um dies zu erreichen, wurde zu Beginn der Blockwoche ein Input von den Blockwochenleitern gehalten, wie sich die Teams ihren Zielen nähern können. In diesen Inputs ging es unter anderem um das Löten, den Umgang mit dem Arduino, sowie die Funktionsweise von 3D-Druckern und Laserscheidgeräten. Am Schluss der Blockwoche wurden die Prototypen den anderen Gruppen vorgestellt und präsentiert. Der Plan der gesamten Woche sieht dann wie folgt aus:
Wochenplan
Gruppenmitglieder
Hallo zusammen, wir sind das Team Bastler der Blockwoche Medizintechnik Do It Yourself. Der Kern des Projektteams besteht aus vier Studenten, drei vom Studiengang Maschinentechnik und einer vom Studiengang Medizintechnik. Durch die interdisziplinäre Zusammensetzung wird die praktische und theoretische Arbeit im Team gefördert, womit zusätzlich wesentliche Erfahrungen von weiteren Fachgebieten gewonnen werden können.
Mitglieder:
Nando Epp Maschinenbau
Polymechaniker EFZ
Andreas Furger Maschinenbau
Polymechaniker EFZ
Cyrill Furrer Maschinenbau
Polymechaniker EFZ
Tim Marguth
Medizintechnik
Gymnasium
Theorie & Reflektion
Als vorbereitung auf die Blockwoche haben wir die Hackteriaseite "Medizintechnik DIY" durchgearbeitet. Dadurch erhielten wir erste Informationen über was DIY überhaupt ist, wie es in verbindung zur Medizintechnik steht, sowie einige Basisinformationen über das Fablab und Hackteria und die Opensourcementalität.
Biotechnologisches DIY
Die Vorstellung, biotechnologische Experimente in der eigenen Garage zu realisieren, wirkt wie ein Traum, der die Begeisterung eines jeden Hobby-Bastlers weckt. Während unserer Blockwoche zum Thema "Eigenständige Medizintechnikprojekte" hatten wir die Gelegenheit, in diese faszinierende Welt einzutauchen und selbst kleine Experimente sowie technische Kniffe umzusetzen. Der DIY-Ansatz ermöglicht es, die stetig komplexer werdenden technologischen Entwicklungen und wissenschaftlichen Erkenntnisse auf eine vereinfachte Weise darzustellen, wodurch sie besser begreifbar werden. In Garagen oder FabLabs kooperieren häufig Fachleute mit Hobby-Enthusiasten, was einen fruchtbaren Austausch von Wissen ermöglicht. Diese gegenseitige Lern- und Erfahrungsbereicherung durften wir hautnah in der Skill Share Session erleben.
Eigeninitiative ist insbesondere im Bildungsbereich und in Entwicklungsländern eine vielversprechende Chance, da hier oft nur begrenzte finanzielle Ressourcen zur Verfügung stehen. Dabei geht es nicht nur um das theoretische Verständnis, sondern auch darum, durch eigenes aktives Handeln ein tieferes Begreifen zu erlangen.
FabLab
Das FabLab Luzern ist in ein weltweites Netzwerk von Werkstätten eingebunden, die sich auf die Erstellung von Prototypen und Produkten spezialisiert haben. In diesem Rahmen stehen digitale Fertigungsmaschinen wie Laser-Cutter und 3D-Drucker zur Nutzung bereit. Diese FabLabs sind offen für alle Interessierten und können auch für spezielle Veranstaltungen reserviert werden.
http://fablab-luzern.ch/info/fab-charta-2/#FabCharter
Open Source
Das Prinzip der Open Source gründet auf der Überzeugung, dass Informationen über etwas, sei es Baupläne oder Codes, für jeden frei verfügbar und einsehbar sein sollten. Es zielt darauf ab, Wissen miteinander zu teilen und auszutauschen, anstatt es zu verschleiern oder geheim zu halten. Auf diese Weise haben viele Projekte die Möglichkeit, auf den Grundlagen bereits entwickelter Arbeiten aufzubauen, sie zu erweitern und an die eigenen Bedürfnisse anzupassen.
Hackteria
Hackteria ist eine Online-Plattform, die Open-Source-Projekte sammelt und der Öffentlichkeit zugänglich macht. Die Ausrichtung von Hackteria liegt auf Projekten im Bereich der biologischen Kunst und wurde 2009 in Madrid von Andy Gracie, Marc Dusseiller und Yashas Shetty ins Leben gerufen. Das vorrangige Ziel von Hackteria besteht darin, Wissenschaftler, Künstler und Hacker dazu zu ermutigen, ihr Wissen zu teilen, um entweder neue Erfindungen zu schaffen oder bestehende weiterzuentwickeln.
Hack 0
Am Morgen erhielten wir eine kurze Einführung zum Thema ARDUINO UNO.
Somit können wir anschliessend einfache Codes auf dem ARDUINO UNO laufen lassen.
Nach der Einführung erhält jede Gruppe eine Aufgabenstellung, welche zu meistern ist.
Das Team Bastler hat die Übung 02 erhalten:
Aufgabenstellung
Download Leitfaden: File:Leitfaden-für-das-Arbeiten-mit-dem-Arduino.pdf
Erstelle ein Sketch für einen Arduino UNO, um drei Schalter und ein Potentiometer auszulesen und im Serial Monitor darzustellen. Für jeden Schalter soll ein eigener Wert oder Wort ausgegeben werden. Für das Poti soll der Widerstandswert ausgeben werden. Benutze dafür die folgenden Zuordnungen:
Schalter 1 auf Pin 2
Schalter 2 auf Pin 3
Schalter 3 auf Pin 4
Potentiometer auf Pin A0
Initialer Zustand von Schalter 1, 2 und 3 auf LOW
Schalter 1, 2 und 3 als Input-Pullup verwenden
Serielle Schnittstelle und Monitor mit Baudrate 9600
Für die Arduino Übung haben wir die folgenden Komponenten benötigt. Ein Arduino Uno, ein breadboard, diverse Taster, ein Poti und Jumper-Kabel.
Für die Vorbereitung werden folgende Fragen gestellt:
Code
// Definiere die Pins für die Schalter und das Potentiometer
const int schalterPin1 = 2;
const int schalterPin2 = 3;
const int schalterPin3 = 4;
const int potiPin = A0;
void setup() {
// Initialisiere die serielle Kommunikation mit einer Baudrate von 9600
Serial.begin(9600);
// Setze die Schalter-Pins als Input und aktiviere die Pull-up Widerstände
pinMode(schalterPin1, INPUT_PULLUP);
pinMode(schalterPin2, INPUT_PULLUP);
pinMode(schalterPin3, INPUT_PULLUP);
}
void loop() {
// Lese die Zustände der Schalter und den Widerstand des Potentiometers aus
int schalterZustand1 = digitalRead(schalterPin1);
int schalterZustand2 = digitalRead(schalterPin2);
int schalterZustand3 = digitalRead(schalterPin3);
int potiWert = analogRead(potiPin);
// Gib die Zustände der Schalter und den Potentiometerwert im Serial Monitor aus
Serial.print("Schalter 1: ");
Serial.println(schalterZustand1);
Serial.print("Schalter 2: ");
Serial.println(schalterZustand2);
Serial.print("Schalter 3: ");
Serial.println(schalterZustand3);
Serial.print("Potentiometerwert: ");
Serial.println(potiWert);
// Kurze Verzögerung, um das Auslesen zu verlangsamen
delay(1000);
}
Wenn der Code ein wenig angepasst wird, kann ein Servomotor mit zwei Schaltern und ein Servomotor mit einem Poti angesteuert werden.
Hier der Code:
#include <Servo.h>
// Definiere die Pins für die Taster, das Potentiometer und die Servomotoren
const int tasterPin1 = 3;
const int tasterPin2 = 2;
const int potiPin = A0;
const int servoPin1 = 9; // Beispielhaft: Hier musst du den tatsächlichen Pin angeben, an dem der erste Servo angeschlossen ist
const int servoPin2 = 10; // Beispielhaft: Hier musst du den tatsächlichen Pin angeben, an dem der zweite Servo angeschlossen ist
Servo servo1; // Erstelle ein Servo-Objekt für den ersten Servo
Servo servo2; // Erstelle ein Servo-Objekt für den zweiten Servo
void setup() {
// Initialisiere die serielle Kommunikation mit einer Baudrate von 9600
Serial.begin(9600);
// Setze die Taster-Pins als Input und aktiviere die Pull-up Widerstände
pinMode(tasterPin1, INPUT_PULLUP);
pinMode(tasterPin2, INPUT_PULLUP);
// Setze die Servo-Pins als Output
servo1.attach(servoPin1);
servo2.attach(servoPin2);
}
void loop() {
// Lese die Zustände der Taster und den Widerstand des Potentiometers aus
int tasterZustand1 = digitalRead(tasterPin1);
int tasterZustand2 = digitalRead(tasterPin2);
int potiWert = analogRead(potiPin);
// Gib die Zustände der Taster und den Potentiometerwert im Serial Monitor aus
Serial.print("Taster 1: ");
Serial.println(tasterZustand1);
Serial.print("Taster 2: ");
Serial.println(tasterZustand2);
Serial.print("Potentiometerwert: ");
Serial.println(potiWert);
// Steuere den Servo entsprechend den Schalterzuständen
if (tasterZustand1 == LOW) {
servo1.write(30); // Drehe den Servo auf 30 Grad im Uhrzeigersinn
} else if (tasterZustand2 == LOW) {
servo1.write(150); // Drehe den Servo auf 30 Grad gegen den Uhrzeigersinn
} else {
servo1.write(90);
}
// Steuere den zweiten Servo entsprechend dem Potentiometerwert
int winkel = map(potiWert, 0, 1023, 0, 180); // Mape den Potentiometerwert auf einen Winkel zwischen 0 und 180 Grad
servo2.write(winkel); // Setze den Winkel des zweiten Servos entsprechend dem Potentiometerwert
// Kurze Verzögerung, um das Auslesen zu verlangsamen
delay(100);
}
Download Datasheet: File:A000066-datasheet.pdf
Hack 1
Hintergrund
Für unseren ersten Hack wollten wir ein Labyrinthpuzzle via Servomotoren mit dem Arduino ansteuern. Ziel dabei ist es die Kugel ans andere Ende des Labyrinths zu bringen. Anstatt dies von Hand zu tun, haben wir einen Joystick am Arduino angeschlossen. Darüber kann der Neigungswinkel des Labyrinths in zwei Achsen kontrolliert werden.
Experiment
Eine Variante könnte auch mit einer EMG Steuerung erfolgen. So kann das Labyrinth durch das Faustmachen bewegt werden.
Code
#include <Servo.h>
// Definiere die Pins für die Taster, das Potentiometer und die Servomotoren
const int potiPinX = A2;
const int potiPinY = A3;
const int servoPinX = 9; // Beispielhaft: Hier musst du den tatsächlichen Pin angeben, an dem der erste Servo angeschlossen ist
const int servoPinY = 10; // Beispielhaft: Hier musst du den tatsächlichen Pin angeben, an dem der zweite Servo angeschlossen ist
Servo servoX; // Erstelle ein Servo-Objekt für den ersten Servo
Servo servoY; // Erstelle ein Servo-Objekt für den zweiten Servo
void setup() {
// Initialisiere die serielle Kommunikation mit einer Baudrate von 9600
Serial.begin(9600);
// Setze die Servo-Pins als Output
servoX.attach(servoPinX);
servoY.attach(servoPinY);
}
void loop() {
// Lese die Zustände der Taster und den Widerstand des Potentiometers aus
int potiXWert = analogRead(potiPinX);
int potiYWert = analogRead(potiPinY);
// Gib die Zustände der Taster und den Potentiometerwert im Serial Monitor aus
Serial.println(potiXWert);
Serial.println(potiYWert);
// Steuere den zweiten Servo entsprechend dem Potentiometerwert
int winkelX = map(potiXWert, 0, 1023, 30, 150); // Mape den Potentiometerwert auf einen Winkel zwischen 0 und 180 Grad
int winkelY = map(potiYWert, 0, 1023, 150, 30); // Mape den Potentiometerwert auf einen Winkel zwischen 0 und 180 Grad
servoX.write(winkelX); // Setze den Winkel des zweiten Servos entsprechend dem Potentiometerwert
servoY.write(winkelY); // Setze den Winkel des zweiten Servos entsprechend dem Potentiometerwert
// Kurze Verzögerung, um das Auslesen zu verlangsamen
delay(100);
}
3D Daten
https://drive.google.com/drive/folders/1N88YckJ09iUkrr9SIjJMzAR5Nl-z0hQD?usp=sharing
Hack 2
Hintergrund
Experiment
Code
Jede Gruppe hat die Verantwortung, eine Skill-Share-Session für die Mitstudierenden vorzubereiten und durchzuführen, um innerhalb einer Stunde umfassendes Wissen zum gewählten Thema zu vermitteln. Unsere Gruppe wählte das Thema Jassen. Die Skill-Share-Einführung fand am Mittwochvormittag statt und wurde von allen Teams besucht. Jede Teilnehmerin und jeder Teilnehmer erhielt drei gelbe und drei rote Post-Its. Auf den gelben Zetteln sollten vorhandene Fähigkeiten notiert werden, während auf den roten festgehalten wurde, welche Fähigkeiten während der Blockwoche erworben werden sollen.
Neurobiologie
Sie beschäftigt sich mit der Struktur, Funktion, Entwicklung und den biochemischen Prozessen im Gehirn und anderen Teilen des Nervensystems. Die Neurobiologie untersucht, wie Neuronen interagieren und Signale übertragen und wie diese Prozesse das Verhalten, die Wahrnehmung und die kognitiven Funktionen beeinflussen. Neurobiologie ist die wissenschaftliche Untersuchung des Nervensystems. Insgesamt erforscht die Neurobiologie die grundlegenden Mechanismen, die der Funktionsweise des Nervensystems zugrunde liegen.
Laminar Flow Hood
Laminar Flow Hoods, oder Laminarströmungshauben sind wichtige Werkzeuge in der Pilzzucht, insbesondere für sterile Techniken. Die Luft strömt mit konstanter Geschwindigkeit in eine Richtung wodurch das Eindringen von Luftpartikeln und Mikroorganismen verhindert wird. Diese Hauben verwenden in der Regel HEPA-Filter, um Partikel und Mikroorganismen aus der Luft zu entfernen um so einen sauberen Arbeitsbereich zu gewährleisten. Pilzzüchter verwenden Laminarströmungshauben während Aufgaben wie der Inokulation (Übertragung von Pilzsporen auf ein Substrat / Nährboden) und Agar-Arbeit (Hinzufügen von Roggenkernen / Holzschnitzel / Stroh als weiteres Nährmittel), um das Risiko von Kontaminationen zu minimieren und damit die Erfolgsquote und Qualität zu verbessern.
Jassen
Der Schieberjass ist ein Kartenspiel, bei dem die 36 Karten gemischt und gleichmässig auf die Spieler verteilt werden. In jeder Spielrunde darf ein Spieler die Trumpffarbe bestimmen. Wenn ein Spieler den Trumpf nicht selbst festlegen möchte, kann er zu seinem Partner gegenüber schieben, und dieser muss dann den Trumpf bestimmen. Das Ziel ist es, insgesamt 157 Punkte zu erreichen, die dann mit dem jeweiligen Trumpffaktor multipliziert werden. Die Trumpffaktoren sind wie folgt festgelegt:
- Eichle und Rose bzw. Eggen und Herz zählen einfach
- Schälle und Schilte bzw. Schaufel und Kreuz zählen doppelt
- Obenabe und Undenufe zählen dreifach
Wenn ein Spieler mit Trumpf an der Reihe ist, gibt er die erste Karte ab, auch wenn er durch schieben seinen Partner den Trumpf wählen liess. Die anderen Spieler geben der Reihe nach entweder eine Karte der gleichen Farbe oder eine Trumpfkarte ab. Wer die höchste Karte oder stärkste Trumpfkarte gespielt hat, gewinnt den Stich und erhält die vier gespielten Karten. Der Wert des Stichs entspricht dem Punktewert aller vier Karten. Beim Schieber handelt es sich um ein Partnerspiel, bei dem die beiden gegenüberliegenden Spieler jeweils ein Team bilden. Die erzielten Punkte werden zusammengezählt und gemeinsam notiert. Beim Spiel mit Trumpf wird der Under/Bube zum Puur und die 9 zum Nell. Puur und Nell sind die beiden stärksten Karten im Spiel. Beim Undenufe wird die Sechs, beim Obenabe das Ass zur stärksten Karte. Gewonnen hat die Partei, die zuerst die für den Gewinn erforderliche Punktzahl erreicht hat.
Online Jass-Plattform zum Üben: https://www.schieber.ch/
