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:
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
Vorbereitung vor der Blockwoche
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
Experiment
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, 0, 180); // Mape den Potentiometerwert auf einen Winkel zwischen 0 und 180 Grad
int winkelY = map(potiYWert, 0, 1023, 0, 180); // 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);
}
