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, 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.
Inputs
Arduino Einführung
Arduino ist eine benutzerfreundliche Elektronikplattform mit offenen Quellcode, die sich an Künstler, Designer und Hobbyisten richtet. Durch die Kombination von physischem programmierbarem Schaltkreis-Board und einer einfachen C/C++-basierten Programmiersprache ermöglicht Arduino den unkomplizierten Einstieg in die Entwicklung interaktiver Projekte, ohne umfangreiche Elektronikkenntnisse vorauszusetzen.
Auf der Webseite von Arduino findet man viele Informationen. Zudem gibt es im Internet zahlreiche Open-Source-Programme und Anleitungen für verschiedene Anwendungen.
LaserCutter
Im Verlauf der Woche erhielten wir eine umfassende Einführung in die verschiedenen Möglichkeiten des Fablabs, darunter auch das Lasern. Beim Lasern werden Platten aus unterschiedlichen Materialien mithilfe eines Hochleistungslasers durchtrennt, wodurch die Möglichkeit besteht, beliebige Formen und Geometrien zu erstellen. Der kreative Gestaltungsfreiheit sind dabei kaum Grenzen gesetzt. Es ist jedoch wichtig, das zu verarbeitende Material sorgfältig auszuwählen und sicherzustellen, dass die gewünschte Form nicht zu klein ist. Der Laser zeichnet sich durch seine Schnelligkeit und Präzision aus, wodurch er sich hervorragend für die Prototypenherstellung eignet. Mithilfe von verschiedenen Zeichenprogrammen kann ein Plan erstellt und anschliessend mit wenigen Mausklicks und einem USB-Stick auf die Lasermaschine übertragen werden. Zudem präsentiert sich das gelaserte Teil bei sachgemässer Konstruktion optisch ansprechend und ist somit auch für das Design von Prototypen geeignet.
Die einführende Schulung zu den Lasermaschinen erwies sich als äusserst hilfreich und sollte idealerweise zu Beginn jeder Woche gemeinsam mit den Gruppen durchgeführt werden.
Benutzeranleitung vom LaserCutter: https://fablab-luzern.ch/wp-content/uploads/2020/02/LASER-Anleitung-A4-2_0.pdf
3D Drucker
Wie das Lasern wurde uns während der Blockwoche Medizintechnik-DIY auch das 3D-Drucken nähergebracht, wodurch wir eigene Teile für die Prototypen herstellen konnten. Beim 3D-Drucken wird Kunststoff erhitzt und durch eine Düse mit einem Dreiachsensystem in eine gewünschte Form gebracht. Die Auswahl verschieden grosser Düsen beeinflusst dabei die Feinheiten der Struktur des Drucks. Der Kunststoff wird schichtweise aufgebaut, was schliesslich zu einem fertigen Teil führt. Bei der Konstruktion von 3D-Druckteilen ist darauf zu achten, dass keine Überhänge entstehen, die einen Winkel von 45° überschreiten. Alternativ kann auch mit einer Stützstruktur gearbeitet werden, die teilweise vom 3D-Druckprogramm automatisch generiert wird und nach dem Druck manuell entfernt werden muss, was zeitaufwendig sein kann. Wenn die Konstruktionsregeln befolgt wurden und eine Zeichnung des Teils im entsprechenden Format vorhanden ist, kann man diese mithilfe des Programms CURA und einer SD-Karte auf die 3D-Drucker im Fablab laden und den Druck starten.
Das Fablab stellt verschiedene 3D-Drucker der Marke Ultimaker und Bambu Lab zur Verfügung und die Einführung in das 3D-Drucken war sehr aufschlussreich. Diese sollte ebenfalls zu Beginn der Blockwoche mit den Gruppen durchgeführt werden, da das 3D-Drucken eine kostengünstige Möglichkeit bietet, Einzelteile herzustellen.
Benutzeranleitung von den 3D-Druckern: https://fablab-luzern.ch/wp-content/uploads/2020/03/CURA-Anleitung-A4-2_0.pdf
Hack 0
Am Dienstagmorgen 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 Arduino Datasheet: File:A000066-datasheet.pdf
Download Leitfaden: File:Leitfaden-für-das-Arbeiten-mit-dem-Arduino.pdf
Download Lösungsvorschläge: File:Lösungsvorschläge_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.
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);
}
Lessons Learned
Durch die Einführungsstunde von Noah Gautschi in die Arduinoprogrammierung haben wir alle nötigen Grundkenntnisse erhalten um mit unseren Projekten beginnen zu können. Wir haben die Grundlagen der Arduinoprogrammierung und dessen elektronischen Verbindungsmöglichkeiten im praktischen Umfeld kennengelernt. Durch das Experimentieren mit verschiedenen Schaltkreisen und dem Schreiben von verschiedenen Codes dazu, haben wir gelernt, dass Fehler, Schwierigkeiten und weitere Herausforderungen Teil des Lern-, Entwicklungs- und Herstellprozesses sind und oft zu den besten Lösungen führen. Durch Teamarbeit haben wir uns gegenseitig bei unseren Problemen geholfen um sie effektiver zu lösen.
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 weiterentwickelte Variante ist mit einer EMG Steuerung erfolgen. So kann das Labyrinth durch das anspannen der Unterarme bewegt werden.
Das funktionierende Programm zeigt das oben aufgeführte GIF.
Im ersten Bild werden über den EMG-Sensor keine Bewegung detektiert. Im zweiten Bild wird eine Bewegung einer Hand detektiert und im dritten Bild werden die Bewegung zweier Hände detektiert.
Um abzugrenzen, welche Hand bewegt wird, wird die Grundlinie angehoben. Wenn dieser Schritt weggelassen wird, kann durch leichte Ausschläge des anderen Signals, welches nicht angesteuert wird, beide Servomotoren angesteuert werden, was nicht gewünscht wird.
3D & Lasercutter Daten
https://drive.google.com/drive/folders/1N88YckJ09iUkrr9SIjJMzAR5Nl-z0hQD?usp=sharing
Code
(Version mit Joystick)
#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);
}
(Version mit EMG)
#include <Servo.h>
#define SAMPLE_RATE 500
#define BAUD_RATE 115200
#define EMG_SENSOR_LEFT A1
#define EMG_SENSOR_RIGHT A4
#define BUFFER_SIZE 10
Servo servoLeft;
Servo servoRight;
int circular_buffer_left[BUFFER_SIZE];
int data_index_left, sum_left;
int circular_buffer_right[BUFFER_SIZE];
int data_index_right, sum_right;
int envelop_left, envelop_right;
void setup() {
Serial.begin(BAUD_RATE);
servoLeft.attach(9);
servoRight.attach(10); // Adjust pin number for right servo
}
float EMGFilter_left(float input) {
float output = input;
{
static float z1, z2; // filter section state
float x = output - 0.05159732*z1 - 0.36347401*z2;
output = 0.01856301*x + 0.03712602*z1 + 0.01856301*z2;
z2 = z1;
z1 = x;
}
{
static float z1, z2; // filter section state
float x = output - -0.53945795*z1 - 0.39764934*z2;
output = 1.00000000*x + -2.00000000*z1 + 1.00000000*z2;
z2 = z1;
z1 = x;
}
{
static float z1, z2; // filter section state
float x = output - 0.47319594*z1 - 0.70744137*z2;
output = 1.00000000*x + 2.00000000*z1 + 1.00000000*z2;
z2 = z1;
z1 = x;
}
{
static float z1, z2; // filter section state
float x = output - -1.00211112*z1 - 0.74520226*z2;
output = 1.00000000*x + -2.00000000*z1 + 1.00000000*z2;
z2 = z1;
z1 = x;
}
return output;
}
float EMGFilter_right(float input) {
float output = input;
{
static float z1, z2; // filter section state
float x = output - 0.05159732*z1 - 0.36347401*z2;
output = 0.01856301*x + 0.03712602*z1 + 0.01856301*z2;
z2 = z1;
z1 = x;
}
{
static float z1, z2; // filter section state
float x = output - -0.53945795*z1 - 0.39764934*z2;
output = 1.00000000*x + -2.00000000*z1 + 1.00000000*z2;
z2 = z1;
z1 = x;
}
{
static float z1, z2; // filter section state
float x = output - 0.47319594*z1 - 0.70744137*z2;
output = 1.00000000*x + 2.00000000*z1 + 1.00000000*z2;
z2 = z1;
z1 = x;
}
{
static float z1, z2; // filter section state
float x = output - -1.00211112*z1 - 0.74520226*z2;
output = 1.00000000*x + -2.00000000*z1 + 1.00000000*z2;
z2 = z1;
z1 = x;
}
return output;
}
int getEnvelop_left(int abs_emg_left) {
sum_left -= circular_buffer_left[data_index_left];
sum_left += abs_emg_left;
circular_buffer_left[data_index_left] = abs_emg_left;
data_index_left = (data_index_left + 1) % BUFFER_SIZE;
return (sum_left/BUFFER_SIZE) * 2+100;
}
int getEnvelop_right(int abs_emg_right) {
sum_right -= circular_buffer_right[data_index_right];
sum_right += abs_emg_right;
circular_buffer_right[data_index_right] = abs_emg_right;
data_index_right = (data_index_right + 1) % BUFFER_SIZE;
return (sum_right/BUFFER_SIZE) * 2;
}
void loop() {
unsigned long past = 0;
unsigned long interval = 0;
long timer = 0;
while (true) {
unsigned long present = micros();
interval = present - past;
past = present;
timer -= interval;
if (timer < 0) {
timer += 1000000 / SAMPLE_RATE;
int EMG_sensor_left_value = analogRead(EMG_SENSOR_LEFT);
int EMG_signal_left = EMGFilter_left(EMG_sensor_left_value);
envelop_left = getEnvelop_left(abs(EMG_signal_left));
Serial.print("Left: ");
Serial.print(envelop_left);
Serial.print("\t");
int EMG_sensor_right_value = analogRead(EMG_SENSOR_RIGHT);
int EMG_signal_right = EMGFilter_right(EMG_sensor_right_value);
envelop_right = getEnvelop_right(abs(EMG_signal_right));
Serial.print("Right: ");
Serial.println(envelop_right);
}
// Adjust servo positions based on envelop values
if (envelop_left > 150) {
servoLeft.write(150);
} else {
servoLeft.write(90);
}
if (envelop_right > 60) {
servoRight.write(90);
} else {
servoRight.write(150);
}
}
}
Lessons Learned
Mit einem Joystic zwei Servomotoren anzusteuern ist uns relativ schnell gelungen. Die Schwierigkeit bestand darin, die Servomotoren über das EMG-Signal zu steuern. Zu Beginn haben wir versucht ein bereits bestehendes Programm zu nutzen, was nicht gerade gut gelang. Mit einem anderen Programm, welches benutzt wird um aus einem EMG-Signal Töne auszugeben, können die Peaks gut ausgewertet werden und anschliessend genutzt werden um die Servomotoren zu steuern. Damit zwei Servomotoren angesteuert werden können, werden zwei EMG-Sensoren benötigt, was das ganze wieder erschwert. Damit alles funktioniert, haben wir für jeden Servomotor einen eigenen Filter und eigene Funktionen in den Code verbaut.
Schlussendlich kann das Spiel mit dem EMG gesteuert werden, jedoch kann die Box nur entweder geneigt oder nicht geneigt werden.
Hack 2
Hintergrund
Die Idee unseres Hack 2 basiert auf dem Spiel Flappy Bird. Dabei muss der Spieler einen Vogel durch Tippen auf den Bildschirm steigen lassen und durch Lücken zwischen grünen Röhren navigieren. Für jede überflogene Röhre gibt es einen Punkt. Das Ziel ist es, so weit wie möglich zu kommen, während Kollisionen mit Röhren oder dem Boden das Spiel beenden. Für die Höheneinstellung des Schlägers wird bei unserer Umsetzung ein Schrittmotor mit einer Spindel verwendet. Das Spielfeld rotiert um die Rakete herum und der Spieler muss die Rakete durch die Hindernisse navigieren, indem er den Push-Button betätigt. Wenn der Push-Button nicht betätigt wird, fällt der Schläger mit konstanter Geschwindigkeit nach unten. Wenn der Push-Button betätigt wird, steigt der Schläger nach oben. Das Ziel ist es, die Rakete so lange wie möglich durch die Hindernisse zu steuern.
Experiment
Das Verstellen der Höhe der Rakete erfolgt mittels eines Schrittmotors, der in Verbindung mit einer Trapezspindel arbeitet. Diese Konfiguration ermöglicht es, die Rakete präzise auf verschiedene Höhen zu bewegen. Während die Rakete sich im Dauersinkflug befindet, kann sie durch Betätigung eines Schalters wieder nach oben fliegen.
Um sicherzustellen, dass die Rakete beim Kontakt mit Hindernissen nicht beschädigt wird, haben wir einen Schaumstoffarm angebracht, an dem die Rakete befestigt ist. Dieser Arm ist so konstruiert, dass er nachgeben kann, indem er wegfaltet, falls die Rakete auf ein Hindernis trifft. Auf diese Weise wird die Rakete vor Beschädigungen geschützt und kann weiterhin sicher fliegen.
Zur Bewegung der Hindernisse, die in Form von Wänden mit Lücken ausgeführt sind, verwenden wir einen Gleichstrommotor. Dieser Motor sorgt dafür, dass die Hindernisse kontinuierlich um die Rakete herum rotieren. Die Rotationsgeschwindigkeit der Hindernisse kann mittels eines Potentiometers eingestellt werden, um den Schwierigkeitsgrad anzupassen oder das Spiel zu variieren.
Insgesamt ermöglichen diese Komponenten eine dynamische und interaktive Erfahrung, bei der die Rakete Hindernissen ausweichen und gleichzeitig die Flughöhe anpassen muss, um das Ziel zu erreichen.
3D-Druck & Lasercutter Daten
Für die Herstellung der Rakete, die geschickt durch die Lücken fliegen muss, haben wir aus Zeitgründen den 3D-Druck gewählt. Diese Methode ermöglicht es, präzise und maßgeschneiderte Designs zu erstellen, die den Anforderungen unseres Projekts entsprechen. Durch den 3D-Druck können wir die Form und Größe der Rakete leicht anpassen und gleichzeitig sicherstellen, dass sie leicht genug ist, um durch die Hindernisse zu navigieren, aber dennoch stabil genug, um kontrolliert zu fliegen.
Den gesamten Aufbau haben wir aus MDF-Platten realisiert, die wir mit einem Lasercutter präzise zugeschnitten haben. Diese Methode ermöglicht es uns, komplexe Formen und Strukturen mit hoher Genauigkeit zu erstellen. Die MDF-Platten bieten eine solide Basis für den Aufbau und gewährleisten gleichzeitig eine stabile und haltbare Struktur. Durch den Einsatz des Lasercutters konnten wir auch feine Details und präzise Ausschnitte realisieren, um die Funktionalität und Ästhetik unseres Projekts zu optimieren.
Durch die Kombination von 3D-Druck für die Rakete und Laserschnitt für den Aufbau haben wir eine effiziente und effektive Herangehensweise gewählt, um unser Projekt umzusetzen. Diese Fertigungstechnologien ermöglichen es uns, schnell und präzise hochwertige Komponenten herzustellen und gleichzeitig die Flexibilität zu bieten, um Änderungen oder Anpassungen bei Bedarf vorzunehmen.
Code
int stepCounter;
int steps = 10;
int x_delay = 700;
int buttonPin = 2; // Pin für den Taster
void setup() {
pinMode(6, OUTPUT); // Enable
pinMode(5, OUTPUT); // Step
pinMode(4, OUTPUT); // Richtung
pinMode(buttonPin, INPUT_PULLUP); // Taster mit Pull-up-Widerstand
digitalWrite(6, LOW);
}
void loop() {
if (digitalRead(buttonPin) == HIGH) {
// Taster wurde nicht gedrückt (Pull-up, daher HIGH)
digitalWrite(4, HIGH); // im Uhrzeigersinn
} else {
// Taster wurde gedrückt (LOW, da Pull-up invertiert)
digitalWrite(4, LOW); // gegen den Uhrzeigersinn
}
for (stepCounter = 0; stepCounter < steps; stepCounter++) {
digitalWrite(5, HIGH);
delayMicroseconds(x_delay);
digitalWrite(5, LOW);
delayMicroseconds(x_delay);
}
}
Hier ist der Schaltplan abgebildet.
Lessons Learned
Bei diesem Hack wurden wertvolle Erfahrungen bei der Entwicklung einer interaktiven Steuerung für ein Hindernisflugspiel gesammelt. Die Konfiguration mit einem Schrittmotor, einem schützenden Schaumstoffarm und einem regelbaren Gleichstrommotor ermöglicht ein anspruchsvolles Spielerlebnis. Der Schrittmotor ermöglicht dem Spieler eine präzise Steuerung der Flughöhe. Der Schaumstoffarm wurde integriert, um Kollisionsschäden zu vermeiden. Dadurch wird die Spielsicherheit erhöht. Der Gleichstrommotor ermöglicht, die Hindernisdrehzahl anzupassen, um variable Spielsituationen zu schaffen. Das Ergebnis dieser Kombination ist ein dynamisches Spielerlebnis zur Förderung der Geschicklichkeit.
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/
Zusammenfassung und Reflektion
An der Blockwoche DIY - Medizintechnik an der Hochschule Luzern Technik & Architektur nahm das Bastler-Team bestehend aus Andreas Furger, Cyrill Furrer, Nando Epp und Tim Marguth teil. Ziel dieser Intensivwoche war es, den Studierenden die Schnittstelle zwischen Technik und Medizin durch das eigenständige Entwickeln und Testen von Prototypen medizinischer Geräte näher zu bringen. Eine ausgewogene Mischung von gemeinsamen Interessen und unterschiedlichen Erfahrungshintergründen führte zu einer angenehmen Lernatmosphäre in der Gruppe. Durch informative Inputs zu Themen wie Arduino-Anwendungen, Löten, Laserschneiden und 3D-Drucken wurde das Wissen der Teilnehmenden erweitert. Das Team Bastler präsentierte stolz seine selbst entwickelten Prototypen am Ende der Woche.
Im Rahmen von Hack 1 wurde ein Labyrinthpuzzle mithilfe von Servomotoren und einem Arduino realisiert. Die Herausforderung besteht darin, die Kugel durch das Labyrinth zu bewegen. Dies erfolgt durch einen am Arduino angeschlossenen Joystick. Hack 2 basiert auf dem Spiel Flappy Bird. Hierbei wird ein Schrittmotor mit einer Spindel zur Höheneinstellung des Spielcharakters verwendet. Das Spielfeld dreht sich um die Rakete und der Spieler navigiert diese durch Hindernisse, indem er einen Push-Button drückt. Das Ziel besteht darin, die Rakete möglichst lange durch die Hindernisse zu steuern.
Abschlusspräsentation
Am Ende der Woche stellten die Gruppen die Ergebnisse ihrer Projekte vor. So konnten wir uns einen Überblick über die erreichten Ziele machen. Es waren spannende Präsentationen und interessante Projekte der Gruppen. Unsere Gruppenpräsentation ist in der folgenden PDF-Datei enthalten.
