MedTechDIY20 Die Profis

From Hackteria Wiki
Revision as of 20:55, 7 February 2020 by Taglur (talk | contribs) (Die Woche in Bilder)
Jump to: navigation, search

Hier gehts zurück auf: Medizintechnik DIY

Wochenplan

Team

Die Profis besteht aus den drei Studierenden Daniel Glur, Lukas Roth und Daniel Zellweger der Hochschule Luzern. Im Rahmen der Blockwoche "DIY Medizintechnik" formierte sich das Team aus verschiedenen Studiengängen um auch interdisziplinär voneinander zu lernen und Wissen auszutauschen.

Mitglieder:

Maschinentechnik: Medizintechnik:

Einleitung

Die Blockwoche "DIY Medizintechnik" verbindet Anwendungen der Medizintechnik mit Do It Yourself (DIY) Ansätzen. Dadurch wird das tiefere Verständnis von Medizintechnischen Geräten durch einen direkten, interdisziplinären und möglichst selbstgesteuerten Zugang gefördert. Basierend auf verschiedenen elektrophysiologischen Messmodulen (EMG, EKG, EOG, EEG) entwickeln die Studierenden im Team Ideen für innovative Projekte. Erste Prototypen werden mit den Mitteln der Digitalen Fabrikation hergestellt und getestet. Tag für Tag stehen produktive "Hacks" auf dem Programm. Hacks sind sehr praxisbezogene Arbeitssequenzen wo die Studierenden Experimente durchführen sowie Prototypen entwickeln und bauen können. Dabei ist aber nicht nur die Medizintechnik zentral sondern auch der Interdisziplinäre Austausch sowie eine Skill-Share-Session wo die Studierenden ganz nach dem do it yourself Gedanken einen eigenen Workshop leiten können. Alle Erkenntnisse und Erfahrungen werden laufend in einem eigenen Wiki-Eintrag festgehalten und dokumentiert.

Die Blockwoche wird von den beiden Dozenten Dr. Marc R. Dusseiller und Urs Gaudenz duchgeführt. Unterstützt wurden die Beiden von Dr. Christian Gehringer, MSc. (ETH) und Chris Obrist

Maschinentechnik:

Planung

Die Blockwoche wird wie in folgendem Wochenplan unterteilt:

Wochenplan

Wochenrückblick

Die Woche in Bilder

ProfisInAction.PNG Komponente.PNG Aufbau.PNG Motor mit Adapter.jpg Pumpe.PNG Pulsmessung.jpg Zusammenbau2.jpg Foto 07.02.20, 11 14 53.jpg DanielZellweger.jpg

Tag 1

Einführung

Wir traffen uns zu beginn im FABLAB, wo sich die Dozenten vorstellten und uns über Ihren bisherigen Werdegang informierten. Das interessante an der beruflichen Laufbahn der beiden ist, dass beide ein Studium abgeschlossen haben und heute einer Tätigkeit nachgehen, welche eigentlich nicht mehr viel mit dem damaligen Studium zu tun hat. Das vermittelt unserer Meinung nach, den Studenten eine etwas andere Sichtweise als die technische Hochschule. Es zeigt z.B. dass man nach einem Studium nicht gezwungen ist auf diesem Fachgebiet zu arbeiten sondern dass der Arbeitsmarkt noch sehr viele andere Möglichkeiten zu bieten hat.

Nachdem sie sich Vorgestellt haben, stellten sie uns auch noch den Assistent vor. Dieser ist ein ausgebildeter Arzt welcher sich momentan für seinen zweiten Doktortitel engagiert. Von Ihm und seinem grossen medizinischen Fachwissen können wir als Studenten die ganze Woche profitieren.

Danach überliessen die Dozenten uns Studenten das Wort. Es war eine etwas andere Vorstellungsrunde wie man sie noch nicht kannte. Dazu stand uns ein ganzer Tisch mit kuriosen Gegenständen, welche etwas mit dem DIY Gedanke zu tun haben, zur verfügung. Sie vorderten uns alle auf einen Gegenstand auszuwählen. Danach mussten wir uns Vorstellen und noch ein paar Worte dazu verlieren welche Gemeinsamkeiten wir mit dem ausgesuchten Gegenstand teilen.

DIY (Do It Yourself)

Das DIY Prinzip basiert auf eigenem experimentieren und learning by doing


How to use Wiki

Tag 2

Am zweiten Tag begannen wir die Vorbereitung Skill-Share-Session. Diesbezüglich sollte jeder Teilnehmer einen Skill, welcher er erlernen möchte und einen Skill, den man beibringen könnte notieren. Diese wurden dann auf einer Tafel in Cluster aufgeteilt. Zwölf davon wurden als Skill-Share Workshops ausgewählt und die Teilnehmer konnten sich nach Belieben einschreiben.

Skill-share-session

Während des zweiten Teils arbeiteten wir an unserem Experiment weiter, welches wir am Vortag begonnen haben. Dazu mussten wir die elektronischen Bauteile mit unserem Laptop verbinden und einen vorgefertigten Sketch laufen lassen.

Nachdem wir den ersten Versuch erfolgreich durchführen konnten, versuchten wir mit dem Arduino einen Stepmotor anzusteuern. Dabei stiessen wir jedoch auf einige Schwierigkeiten. Da wir diese bis zur Einführung des Lasercutters und des 3D-Druckers fertig haben sollten. Siehe #Hack 0

Unteranderem wurde unsere Skill-Share-Session über Arduino vorbereitet.

Am Abend kam Chris Obrist zu Besuch und unterhielt uns mit einer wundervollen musikalischen Darbietung.

Tag 3

Von 9:00 Uhr bis nach dem Mittag um 14:00 Uhr waren wir alle mit der #Skill-Share-Session beschäftigt.

Danach hatten wir Zeit um den nächsten Hack vorzubereiten und zu planen.

Tag 4

Den Vormittag verbrachten wir weiter mit dem Hack 1, welchen wir dann vor der Mittagspause den Dozenten und allen Mitstudierenden präsentieren durften. Leider litten wir während des ganzen Hack 1 sehr unter Zeitdruck, was auf eine turbulente Projektphase zurückzuführen ist. Mehr dazu erfährst du im #Hack 1.

Nach einer kurzen Inspirationphase entschieden wir uns dafür eine kleine Spritzenpumpe zu basteln. #Hack 2: Spritzenpumpe

Tag 5

Am Tag 5 ging es darum die Einzelteile physikalisch sowie über ein Funktionierendes Arduinoprogamm zum laufen zu bringen. #Hack 2: Spritzenpumpe

Tag 6

Experimente

Bei den Experimenten sollte es darum gehen aus unterschiedlichsten Einzelteilen ein Produkt zu erschaffen. Dieser Prozess brachte uns dazu über die Grenzen unseres altäglichem Denken zu springen und in der Verbindung der einzelnen Bereiche solcher Produkte besser zu verstehen.

Hack 0

Versuchsaufbau 1

  • Mucle Spike Shield
  • Arduino
  • 3 Elektroden
  • Elektrodenkabel
  • USB Kabel
  • Sketch (led_strip2014_highergain.ino)

Durchführung 1

Nach den Inputs der Dozenten verbrachten wir hauptsächlich die Zeit damit den Muscle Spiker Shield nach der Anleitung mit den dazugehörigen Teilen zusammenzulöten.[1]V2.11 Nebenbei machten wir unsere ersten Schritte in Arduino. Als wir unsere mechatronischen Komponenten zusammengestellt und ein Grundverständnis von Arduino angeeignet haben, verbanden wir dies in einem Experiment. Das Experiment welches wir durchführten nennt man Control Machines with your Brain und ist auf der Seite von Backyard Brains nachzusehen.

Für den Versuch wurden Elektroden an den Testpersonen angeschlossen und über den Arduino ausgelesen. Der Versuch wurde mit zwei Testpersonen durchgeführt. Dabei fiel uns nebst der Kontrolle der LED's auch auf, dass der Puls gemessen wurde. Dies unabhängig von der Position der Elektroden. Vermutlich reagieren die Elektroden zu sensitiv für diese Anwendung.


Versuchsaufbau
Elektrodenbefestigung
Messung von Daniels Puls

Versuchsaufbau 2

  • Mucle Spike Shield
  • Arduino
  • 3 Elektroden
  • Elektrodenkabel
  • USB Kabel
  • Sketch (led_strip2014_highergain.ino)

Durchführung 2

Als zweites Experiment versuchten wir durch das anspannen der Muskeln einen Servomotor anzusteuern. Wie es auch auf der Homepage von Backyard Brains anzutreffen ist. Dieser Versuch konnte aber leider aus Zeitgründen nicht zu Ende geführt werden. Wir konnten lediglich das Arduinoprogramm laden und etwas anpassen.

Reflexion

Der Hack 0 war in der Hinsicht sehr interessant, da wir alle unsere ersten Erfahrungen mit einem Arduino machen konnten. Einige von unserem Team hatten bisher auch noch nie auf einer Printplatte irgendwelche Widerstände oder Schalter etc. gelötet. Ebenso war es erstaunlich, dass man mit so wenig so viel verschiedene Sachen machen kann. Keiner von uns hat gedacht dass wir bereits am ersten Tag irgend etwas mit unseren Muskeln kontrollieren könnten. Insgesamt kam der Hack 0 gut bei uns an und wir alle konnten einiges davon profitieren und hoffentlich auch den weiteren Hacks weiterverwenden.

Hack 1: Baseball-Cap mit Ventilator

Der Hack 1 beschreibt die Konzept- und Testphase des ersten Prototyps.

Zu Beginn waren wir uns sehr unschlüssig was wir wirklich bauen wollen. Also entschieden wir uns für ein weiteres Experiment mit einem Bausatz von Backyard Brains. Wir versuchten durch die Funktion des Heart and Brain Spiker Shield einen Ventilator anzusteuern. Der Gedanke, welcher uns auf diese Idee führte, kennt wohl jeder Student. Während einer Prüfung kommt so mancher ins Grübeln und in harten Fällen kommt es auch vor dass einem eine Schweissperle von der Stirn läuft. Um in solchen Fällen für die nötige Kühlung zu sorgen, sollen Sensoren die Hirnströme gemessen und als Signal wiedergeben werden um damit einen Ventilator anzuschalten.

Zu unserem eigenen Erstaunen erhielten wir sogar ein Signal aus unserer Messung. Es stellte sich aber sehr bald heraus, dass das wohl nicht die Hirnströme waren sondern eher Bewegungen des Kopfs und der Kabel. Denn die Sensoren sind recht empfindlich gegen solche Einflüsse. Zudem kam noch, dass die Sensoren über den Haaren angebracht wurden, was das Signal der Hirnströme noch zusätzlich verschlechterte. Nach einigen Versuchen sahen wir ein, dass das wohl eine zu grosse Herausforderung war und wir uns besser an einen einfacheren Versuch versuchen sollten.

Signal aus Messung der "Hirnströme"
Daniel beim messen der "Hirnströme"

Also beschlossen wir uns anstelle der Hirnströme den Puls zu messen. Denn während einer Prüfung kann es durchaus auch vorkommen, dass der Puls etwas ansteigt. Die Messungen sollten dann ausgelesen werden und wenn der Puls eine gewisse Frequenz übersteigt, schaltet ein Ventilator ein um den Studenten wieder etwas zu beruhigen.

Für diesen Versuch platzierten wir Sensoren am Unterarm und an der Handoberfläche. Idealerweise sollten laut Assistent Christian die Sensoren aber so weit wie möglich voneinander entfernt, an einer anderen Körperstelle angebracht werden um eine gewisse Referenz zu haben und um sicherzustellen, dass man wirklich den Puls misst. Unsere Kabel waren aber leider etwas zu kurz. Wir erhielten trotzdem ein relativ gutes Signal von welchem man davon ausgehen konnte, dass es sich um den Puls handelte. Jetzt nur noch das Signal auswerten, einen Frequenzbegrenzer programmieren und mithilfe von einem Arduino UNO den Ventilator ansteuern... Dachten wir... Dies war allerdings etwas Schwieriger als erwartet und überstieg unsere Kompetenzen. Das führte uns dazu auch diesen Versuch an dieser Stelle abzubrechen und nochmal zu überdenken.


Pulssignal
Pulssmessung


Nun rannte uns schon langsam die Zeit davon. Doch dann kam uns die Idee, welche wir schon zu Beginn benötigt hätten. Und zwar wollten wir einen Ventilator auf einem Baseball-Cap anbringen und diesen ansteuern wenn ein gewisses Temperaturniveau unter dem Cap überschritten wird wird. Dazu wird ein 12V Ventilator via Relais von dem Arduino angesteuert. Weil der Arduino nur eine Spannung von 5V liefert, musste ein 12V Netzgerät den Ventilator mit Strom versorgen. Damit man den Ventilator so schalten konnte, damit er den Strom über das 12V Netzgerät bezieht, mussten wir noch ein Relais einbauen. Den Code für den Arduino bezogen wir aus verschiedenen ähnlichen Projekten aus dem Internet und passten ihn spezifisch für unsere Anwendung an. Für das auslesen der Temperatur mussten wir zuerst zwei Libreries herunterladen (DallasTemperature und OneWire).

Verbaute Komponenten

Nun mussten wir noch den Ventilator am Baseball-Cap anbringen. Dafür wurde eine Halterung im CAD konstruiert und mit einem 3D-Drucker ausgedruckt. Die Teile wurden danach zusammengesteckt und mit dem Baseball-Cap verschraubt. Natürlich wurde zuvor ein Loch in das Cap geschnitten, damit der Ventilator auch seinen Zweck erfüllen kann und dem Studenten einen kühlen Kopf verschafft.

3D-Modell im CAD

Zusammenbau1.jpg Zusammenbau2.jpg

Nun wurde unser Prototyp getestet. Der Sensor erfüllte seinen Dienst und wir konnten erfolgreich die Temperaturen messen. Jedoch war das Relais während dem Testen ständig eingeschalten und der Ventilator lief die ganze Zeit auch wenn die Temperatur den Minimalwert unterschritten hatte. Es hat sich also irgendwo in unserem Programm einen Fehler eingeschlichen. Den galt es nun zu finden und zu beheben. Dazu bauten wir einen Druckknopf ein um zu überprüfen ob das Relais defekt war und um die Fehlerquellen etwas einzugrenzen.

Temperatur.jpg

Der Druckknopf funktionierte, das Relais schaltete perfekt ein und aus und der Ventilator wurde an- und abgestellt. Somit wissen wir nun wo der Fehler zu suchen ist und können versuchen das Programm an diesen Stellen zu bereinigen. Nur ist jetzt schon Donnerstag Nachmittag und der Hack 2 hat schon begonnen. Wir alle wurden aufgefordert unseren bisherigen Prototypen aufzugeben und etwas neues, anderes zu versuchen und zu testen. Also legen wir schweren Herzens unser erster Prototyp beiseite und widmen unsere Kreativität dem nächsten Hack.

Reflexion

Der Hack 1 hat uns gezeigt, dass es gar nicht so einfach ist beim ersten Versuch ein brauchbares Resultat zu erzielen. Jedoch konnten wir so aus zwei vorhergehenden, fehlgeschlagenen Ansätzen eine Idee weiterentwickeln. Somit konnten wir mit unseren Kompetenzen und den Erfahrungen aus dem Hack 0 ein zufriedenstellendes Resultat erzielen. Durch die zwei Versuche zuvor ging leider recht viel Zeit "verloren", welche wir sehr benötigt hätten um unser erster Prototyp fehlerfrei hinzukriegen. Es war uns auch eine Lehre, dass man nicht zu lange an einer Sache verharren sollte wenn einem nur wenig Zeit zur Verfügung steht. Manchmal ist es besser man wirft alles nochmal über den Haufen und beginnt von vorne. Trotz allen Strapazen während des Hack 1 sind wir mit unserem ersten Prototyp sehr zufrieden und konnten auch bei diesem Versuch wieder viel profitieren und mitnehmen. Nun blicken wir gespannt nach vorne auf den nächsten Hack.


Code

Wir konnten zwar die Temperatur herauslesen und das Relais über einen Butten steuern, jedoch die Steuerung anhand der Temperatur geling uns nicht.

/********************************************************************/
// First we include the libraries
#include <OneWire.h> 
#include <DallasTemperature.h>
/********************************************************************/
// Data wire is plugged into pin 2 on the Arduino 
#define ONE_WIRE_BUS 2 

float tempReading;
/********************************************************************/
// Setup a oneWire instance to communicate with any OneWire devices  
// (not just Maxim/Dallas temperature ICs) 
OneWire oneWire(ONE_WIRE_BUS); 
/********************************************************************/
// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);
/********************************************************************/ 
int relayPin = 4;       // Relay Singnal lead to Digital Pin [D2-D12]

float maxTemperature = 30.00; // The Max Temperature allowed
float minTemperature = 25.00; // The Min Temperature allowed

// constants won't change. They're used here to set pin numbers:
const int buttonPin = 8;     // the number of the pushbutton pin
const int ledPin =  4;      // the number of the LED pin

// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status

void setup(void) {
// initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);

 Serial.begin(9600); 
 Serial.println("Dallas Temperature IC Control Library Demo"); 
 // Start up the library 
 sensors.begin(); 
}
 
void loop(void) 
{ 
 // call sensors.requestTemperatures() to issue a global temperature 
 // request to all devices on the bus 
/********************************************************************/
 Serial.print(" Requesting temperatures..."); 
 sensors.requestTemperatures(); // Send the command to get temperature readings 
 Serial.println("DONE"); 
/********************************************************************/
 Serial.print("Temperature is: "); 
 Serial.print(sensors.getTempCByIndex(0)); // Why "byIndex"?  
   // You can have more than one DS18B20 on the same bus.  
   // 0 refers to the first IC on the wire 
   delay(1000); // Check Temperature every second

 float temperature = getTemperature();
 if(temperature >= maxTemperature){
    powerOnRelay();
  } else if (temperature <= minTemperature) {
    powerOffRelay();
  }
  delay(1000); // Check tempertature every second

} 
void powerOnRelay() {
    digitalWrite(relayPin, HIGH);
    Serial.println("Relay On");
}

void powerOffRelay() {
    digitalWrite(relayPin, LOW);
    Serial.println("Relay Off");
}
float getTemperature(){
  tempReading = digitalRead(ONE_WIRE_BUS);

 // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == HIGH) {
    // turn LED on:
    digitalWrite(ledPin, HIGH);
  } else {
    // turn LED off:
    digitalWrite(ledPin, LOW);
  }
}

Hack 2: Spritzenpumpe

Nachdem der Hack 1 abgeschlossen war, machten wir uns aufs Neue darüber Gedanken was wir für einen Prototyp für den Hack 2 bauen wollen. Urs hat nach dem Abschluss von Hack 1 gesagt, wir sollten uns ein komplett neues Produkt überlegen, welches möglicherweise auch etwas mit der Medizintechnik zu tun hat. Nach einem Brainstorming kamen wir noch nicht so richtig auf einen grünen Zweig. So kamen wir auf die Idee uns einen Kaffee zu holen und einfach mal durch das FABLAB zu laufen um alles Mögliche anzuschauen, in die Hand zu nehmen und uns von all diesen Gegenständen inspirieren zu lassen. So kamen uns diverse Gegenstände in die Finger. darunter waren Servomotoren sowie einige DC-Motoren, eine Spritze, eine Pumpe, ein Micro-Switch Schalter, ein Potentiometer und vieles mehr. Diese Gegenstände haben wir dann auf unserem Gruppentisch ausgebreitet und uns Gedanken darüber gemacht was wir damit wohl anstellen konnten zum Thema Medizintechnik. So entstanden relativ schnell einige Ideen. Wir haben uns schlussendlich dafür entschieden ein Dosiergerät für eine medizinische Spritze zu machen. Dieses sollte so funktionieren, dass wir eine Spritze in eine Vorrichtung legen und über einen DC-Motor zum Einfahren bzw. Ausfahren bringen. Dazu muss die Drehbewegung des Motors in eine Lineare Bewegung umgeleitet werden. Zudem muss ggf. auch die Drehzahl des Motors durch ein Potentiometer reguliert werden können um einen zu schnellen Aus- oder Einfahrvorgang zu verhindern. Soviel zu zu den technischen Überlegungen.

Sofort nach dem Entscheid suchten wir nach einem geeigneten Motor. Dieser sollte dabei eine eher tiefe Drehzahl haben damit die Spritze nur langsam ein- und ausfährt. Zudem suchten wir im Internet nach einem geeigneten Mechanismus der die Drehbewegung in eine lineare Bewegung umwandelt. Denn wir hatten leider zu wenig zeit um alles selber zu entwerfen und zu konstruieren. So wurden wir auf auf der Hompage von Thingiverse schliesslich fündig. Also konnte wir die Folgenden Komponenten herunterladen und mit dem 3D-Drucker ausdrucken.

Komponenten:

Da wir einen anderen Motor verwendeten als für diesen Mechanismus vorgesehen wäre, mussten wir noch eine passende Adapterplatte konstruieren, damit der Motor auch auf die Vorrichtung passt.

Der Motor benötigt, wie auch der Ventilator von Hack 1, eine Spannung von 12V für den Betrieb. Also mussten wir erneut das 12V Netzgerät verwenden. Damit unser zweiter Prototyp auch die gewünschte Fördermenge fördern kann, muss die Zeitdauer, in welcher gefördert werden soll, definiert werden. Das dazugehörige Programm wird mit einem Arduino UNO implementiert. Der Zugehörige Code haben wir durch Recherche im Internet und durch persönliches erweitern und anpassen erstellt. Die Drehzahl des Motors darf nicht zu hoch sein damit man die Fördermenge auch sinnvoll einstellen kann. Für diese Anwendung wird ein Potentiometer zwischen Relais und Motor gehängt. So kann die Motorspannung reguliert und die Drehzahl anforderungsgemäss eingestellt werden. Nachfolgend wird der Prozessablauf kurz beschrieben.

Mit einem Knopfdruck wird wird ein Relais geschalten und der Motor wird angesteuert. Die Drehzahl des Motors wird über ein Getriebe reduziert. Die Zahnräder greifen auf eine Zahnstange und wandeln die Drehbewegung in eine lineare Bewegung um. An der Zahnstange wird der Stössel der Spritze befestigt. Der Rest der Spritze wird mit einem Kabelbinder fest mit der Bodenplatte verbunden damit sich dieser Teil nicht bewegen kann. Die programmierte Zeitdauer bestimmt welche Menge an Flüssigkeit gefördert werden soll.

Aufbau der Spritzenpumpe

Reflexion

Anders als beim Hack 1 kamen waren wir uns bei diesem Hack sehr schnell einig was genau wir bauen möchten. Die ganze Ideenfindung erledigte sich sehr schnell und wir konnten nach bereits wenigen Stunden mit dem programmieren des Arduinos beginnen. Wie wir bereits im Hack 1 erfahren durften, ist das bei dem gedrängten Zeitplan dieser Woche ein grosser Vorteil. Rückblickend können wir urteilen, dass der Hack 2 aus unserer Sicht ein erfreuendes Erfolgserlebnis war. Unser zweiter Prototyp funktioniert genau so wie wir uns das von Beginn an vorgestellt haben. Per Knopfdruck fördert unser Prototyp eine gewisse Menge an Flüssigkeit.

Code

 
bool geschaltet = false;
int RelaisPin = 10;       
int tasterPin = 2;
int empfindlichkeit = 200;
 
void setup() {
  
  pinMode( tasterPin, INPUT_PULLUP);
  pinMode( RelaisPin, OUTPUT);
 
}
 
void loop() {
 
  if (digitalRead(tasterPin) == LOW)  
  {
    if (geschaltet == false) {
      geschaltet = true;
    }
    else {
      geschaltet = false;
    }
  }
 
  if (geschaltet == true) {
    digitalWrite(RelaisPin, HIGH);
    delay(1000);
    geschaltet = false;     
  }
 
  if (geschaltet == false) {
    digitalWrite(RelaisPin, LOW);
  }
 
  delay(empfindlichkeit);
}

Hack 3

Skill-Share-Session

Grundlagen der Arduinoprogrammierung

Dieser Kurs wurde von unserer Gruppe angeboten und soll den Teilnehmern die Grundlage der Programierung eines Arduino UNO beibringen. Folgend werden die grundlegenden Befehle und deren Syntax vorgestellt. Der Aufbau folgt dem YouTube Tutorial von Max. Hier gelangst du zu dem Link: [2]

Skript

Der Code wird in einem Skript geschrieben. Dieses ist in zwei Bereiche aufgeteilt

  • Void setup() Dieses Skript wird einmalig ausgeführt und enthält zB. Input und output
  • Void loop() Dieser Teil des Skripts wird als Dauerschleife wiederholt

Befehlseingabe

Die Befehle werden nach folgender Syntax eingegeben:

  • Funktion(Parameter1, Parameter2);

Dabei muss das «;» gesetzte werden, ausserdem spielen Gross- und Kleinbuchstaben eine Rolle.

Variablen

Übersichtshalber sollen sprechende Namen für die Bezeichnung von z.B. Outputs verwendet werden. Dabei können verschiedene Datentypen ausgewählt werden.

Datentyp

  • int Ganze Zahlen von -32768 … 32767 z.B. 1, 48, -654
  • boolean Entweder true oder false
  • byte 8 Bit an Informationen z.B. 00010101 (=21)
  • char enthält 1 Byte Informationen, das ein Zeichen darstellt z.B. 65 = A
  • long grosse Zahlen von ca. -2.1 Milliarden bis 2.1 Milliarden z.B. 15636451
  • float Komazahlen z.B. 5.498
  • string Zeichenketten z.B. «Do it yourself»

Deklaration Syntax

  • Datentyp Name = Wert;

oder

  • Datentyp Name;
  • Name = Wert;

Ort der Deklaration

Die Variable muss immer im Teil des Skriptes deklariert sein, wo sie auch gebraucht wird. Wird die Variable im setup wie auch im loop benötigt, so kann man die Variable als sogenannte globale Variable oberhalb des Setups deklarieren.

If-Schleife

Bei der If-Schleife wird der Wert einer Variablen mit einem Vergleichswert verglichen. Falls der Vergleich positiv ist, wird der Code ausgeführt, ansonsten übersprungen. Dazu sind Vergleichsoperatoren notwendig.

Syntax

if(Bedingung) {

          CODE;

}

Vergleichsoperatoren

  • == gleich
  •  != ungleich
  • < kleiner
  • < grösser
  • <= kleiner gleich
  • >= grösser gleich

While-Schleife

Mit der While-Schleife wird die Bedingung fortlaufend geprüft. Stimmt diese, wird der Code ausgeführt, ansonsten wird der Code übersprungen. Es können die selben Vergleichsoperatoren wie bei der If-Schleife verwendet werden.

Syntax

while (Bedingung) {

            CODE;

}

Bildgebende Verfahren

Der Tag begann mit einer Einführung in die Bildgebenden Verfahren durch David Stadelmann. Hierbei erklärte er uns, verschiedene Methoden, um Bilder aus dem Körperinneren zu machen und welche Methode für die verschiedenen Gewebetypen gebraucht werden. Zudem Zeigte und erklärte er uns anhand von Beispielen was die Einzelnen Schattierungen aussagen könnten.

DIY-MedTech Bildgebende Verfahren-Unterschiedliche Bildeindrücke - Team Frosch

Synths & Sound

Danach ging es weiter mit dem Kurs Synths & Sounds. Diese Session wurde von Dr. Marc R. Dusseiller durchgeführt. Hierbei zeigte er uns, wie man mit verschieden erzeugten Schwingungen eine grosse Variation von Tönen generiert kann. Zudem auch wie man elektronisch gewisse Instrumente Simulieren könnte und durch die Aneinanderreihung verschiedenster Tonvariationen eine Melodie enstehen kann. Dies mit unterschiedlich Variationen von selbstgebauten Synthesizers.

Schweissen

Bei dem Skill-Share Workshop von Team G2020 konnten wir verschiedene Schweissverfahren kennenlernen und auch gleich anwenden.

Es wurde uns das Elektrodenschweissen, das MIG-Schweissen und das TIG-Schweissen nähergebracht.

Dieser Workshop war für uns alle sehr interessant, da sich bisher noch keiner von uns so wirklich mit dem Schweissen und den verschiedenen Verfahren auskannte. An diesem Tag konnten wir nach einer kurzen Theorie gleich sofort selber handanlegen und die verschiedenen Schweissverfahren ausprobieren.

Dabei mussten wir feststellen, dass es gar nicht so einfach ist wie es immer aussieht. Besonders das TIG-Schweissen braucht sehr viel Übung und Geschick um wirklich schöne Schweissergebnisse zu erzielen.

Autonomes Nervensystem und das Hören in der Medizin

Der Assistent Dr. Christian Gehringer, MSc. (ETH) hielt uns einen sehr interessanten Vortrag. Dabei ging es darum, dass wir die Anatomie kennenlernen und erkunden am Beispiel des Hörens z.B mit einem Stethoskop.

Autonomes Nervensystem und das Hören in der Medizin