Team E-gewinnt

From Hackteria Wiki
Revision as of 01:06, 27 February 2022 by Takljaji (talk | contribs) (Mittwoch)
Jump to: navigation, search
Team E-gewinnt

Abstract

Wer effizient seine Arbeit erledigt, hat mehr Zeit zum Gamen. Doch eine solche Effizienz ist immer mit einer erhöhten Temperatur des Kopfes verbunden. Damit effizient gearbeitet und zugleich ein kühler Kopf beibehalten werden kann, hat das Team E-gewinnt den Calanda-Kopfkühler entwickelt. Sind die Pflichtstunden im Büro überstanden, so kann man sich auf das ultimative Krafttraining mit dem "Flappy Dino World" Game freuen. Diese beiden Projekte und das Muscle SpikerShield werden weiter unten im Detail erklärt.

Einleitung

Die Blockwoche "Medizintechnik DIY" wird an der Hochschule Technik & Architektur angeboten. Es verbindet Anwendungen der Medizintechnik mit Do It Yourself (DIY) Ansätzen. Dadurch wird das tiefere Verständnis von Medizintechnischen Geräten durch einen interdisziplinären und selbstgesteuerten Zugang gefördert.

Ziel der Blockwoche ist es kreative Produktideen an der Schnittstelle von Technik und Medizin zu generieren und zu Konzepten zu entwickeln. Dabei sollen die Möglichkeiten der Digitalen Fabrikation kennengelernt werden und bei der Entwicklung von Prototypen zum Einsatz kommen. Methoden des Human Centered Designs sollen kennengelernt werden und das Wissen im Bereich der elektrophysiologischen Messmethoden soll vertieft werden. Die dazu notwendigen Informationen sollen selbständig recherchiert, dokumentiert und ausgewertet werden.

Team

Das Team besteht aus vier Studenten. Einem Wirtschaftsingenieur, einem Maschinentechniker und zwei Medizintechnikern. Durch die interdisziplinäre Zusammensetzung und den unterschiedlichen und vielseitigen Erfahrungen der einzelnen Teammitglieder hat sich das Team super ergänzt. Dadurch konnten spannende und neuartige Lösungen gefunden werden.

Mitglieder:

Journal

Montag

Am Montag um 09:00 Uhr war der Start in die Blockwoche Medizintechnik DIY im FabLab der Hochschule Luzern. Nach einer kurzen Einführung in das FabLab Luzern und einer Übersicht über den Wochenablauf gab es eine Vorstellungsrunde. Bei dieser wurden auf einem Tisch verschieden Gegenstände platziert. Anschliessend mussten die Studenten einen Gegenstand auswählen und bei der Vorstellung kurz erklären, warum der jeweilige Gegenstand gewählt wurde. Nach der Vorstellungsrunde wurden die Gruppen gebildet und die Teams konnten dann auch schon mit Hack 0 beginnen.

Am Nachmittag gab Herr Urs Gaudenz einen Input über die Themen Open Source und Do It Yourself. Anschliessend wurde kurz gezeigt, wie eine Wiki-Seite erstellt und bearbeitet werden kann und schliesslich konnten die Gruppen noch bis zum Schluss des Tages an Hack 0 weiter arbeiten.

Dienstag

Am Dienstag wurde das Muscle SpikerShield fertig gestellt. Anschliessend ging die ganze Klasse bei jeder Gruppe vorbei. Die Gruppen berichteten über ihre Fortschritte und Probleme. Danach schrieben alle jeweils zwei ihrer Skills auf als Vorbereitung für den Skill Share am Mittwoch. Am Nachmittag erhielten wir eine Einführung ins Lasercutting und den 3D-Druck. Wir spielten mit dem Muscle SpikerShield herum und kontrollierten mit unseren Bewegungen einen Motor. Am Abend hörten wir eine Präsentation über die Kombination von Kunst und Medizintechnik. So wurden zum Beispiel ein Kunstwerk, bei welchem ein Ultraschallgerät ein Teil davon ist, oder Würmer, welche eine Symbiose mit Algen eingehen, vorgestellt.

Mittwoch

Der Morgen bestand aus drei Skillshare-Sessions. Von jeder Gruppe, sowie einigen Dozenten, wurden 45-minütige Kurse vorbereitet. So konnte aus diversen Themen ausgewählt werden, wie z. B. Arduino-Grundlagen, Meditation oder Hartlöten. Von Unserer Gruppe wurde von Elias ein Skill Share zum Modellieren mit Ton angeboten. Zu fünft modellierten wir kleine Gesichter, ein Pinguin, eine Schildkröte und ein Frosch, als Basisform diente ein nasses Zeitungsknäuel. Mithilfe diverser Inputs konnten alle Teilnehmer:innen ein Modell formen. Da mit lufttrocknendem Ton gearbeitet wurde konnten die Modelle eingepackt und mit nach Hause genommen werden.

Der Nachmittag konnte vollkommen für den Hack 1 genutzt werden.

Donnerstag

Am Donnerstag hatten wir den ganzen Tag Zeit, um an unseren eigenen Projekten zu arbeiten. Noch vor dem Mittag präsentierte jede Gruppe den anderen Kursteilnehmern kurz, was sie in den letzten paar Tagen für Hack 1 gebaut hatten. Dabei wurden auch die gesammelten Erfahrungen und die aufgetretenen Probleme miteinander ausgetauscht.

Am Nachmittag wurde weiter an Hack 1 gearbeitet, so dass der Prototyp am Ende vom Tag fast fertig war. Zudem wurden in der Gruppe Ideen für Hack 2 gesammelt und auch wurde schon mit dessen Umsetzung begonnen.

Freitag

Der Freitag war die finale Phase für die Ausarbeitung der Projekte. Am Morgen wurden noch die letzten Feinschliffe am Hack 1 vorgenommen. Der Rest des Tages stand mehrheitlich für den Hack 2 zur Verfügung. Gegen Ende des Tages wurde das PowerPoint für die Abschlusspräsentation erstellt und die zu präsentierenden Teile im Team aufgeteilt.

Samstag

Der letzte Tag der Blockwoche bestand aus Präsentationen, in welcher die Gruppen ihre erarbeiteten Projekte vorstellten. Mit Hilfe von PowerPoint-Präsentation wurde der Ablauf der Woche aus Gruppensicht vorgestellt. Gesammelte Erfahrungen, aufgetretene Probleme und erarbeitete Lösungen wurden miteinander geteilt. Auch wurden, falls funktionstüchtig, die Prototypen demonstriert. Nach den Präsentationen wurde eine Feedback-Runde über die Blockwoche durchgeführt. Anschliessend wurden die Arbeitsplätze noch aufgeräumt und somit ging die Blockwoche zu Ende.

Theorie

OpenSource

Der Begriff Open Source geht ursprünglich in die 1980er Jahre zurück und bezog sich am Anfang ausschliesslich auf Open Source-Software. Dabei ging es darum, dass man Code der Öffentlichkeit zugänglich macht, sodass ihn jeder benutzen und nach seinen Wünschen verändern kann. Der Open Source-Gedanke hat sich mittlerweile zu einer Bewegung weiterentwickelt, welche sich mit allen möglichen Themen befasst. Wobei der Grundgedanke immer derselbe geblieben ist: Die Quelle der Arbeit wird der Öffentlichkeit zugänglich gemacht, so dass jeder die Arbeit selbst benutzen oder nach seinem Belieben verändern kann. Dieser Grundgedanke und das Internet, welches uns global verbindet, führt zu einer erhöhten Kooperation zwischen allen möglichen Kreatoren und hilft Konsumenten unabhängiger von Unternehmen zu sein.

Arduino

Bei einem Arduino handelt es sich um ein Circuit-Board, welches einen Mikrocontroller auf sich hat. Dieses Circuit-Board bietet diverse Schnittstellen, um unterschiedlichste Bauteile mit dem Arduino zu verbinden und diese eventuell anzusteuern. Arduino ist eine italienische Firma, welche Circuit-Boards herstellt, welche den Gebrauch von Mikrocontroller vereinfachen. Der bekannteste "Arduino" ist der Arduino-Uno. Der Arduino Uno ist billig und ausreichend gut für die meisten Projekte. Werden mehr Rechenleistung und weitere Schnittstellen wie WiFi benötigt, kann ein entsprechendes Board von Arduino bezogen werden. Die Boards können aber auch von anderen Herstellern gekauft werden, weil Arduino alle ihre Hardwaredesigns Open-Source hat.

DIY Biologie

Die DIY-Biologie Bewegung versucht ein Wissensgebiet, welches bisher nur für Universitäten und Grossunternehmen zugänglich war, für jeden zugänglich zu machen. Das Ziel ist es biotechnische Forschung aus den grossen Laboren in die Garagen und Küchen von Interessierten zu bringen. Dafür werden in der Community unzählige Laborgeräte konstruiert, welche man einfach zuhause nachbauen kann.

DIY Mikroskop aus einer Webcam
OpenPCR ein open source PCR-Gerät

Einen wichtigen Beitrag leisten Online-Plattformen wie zum Beispiel Hackteria. Sie bieten für interessierte eine Vielzahl von Projekten, wie zum Beispiel Baupläne für biotech Geräte oder Codes.

In den USA kam es in den letzten Jahren zu einer öffentlichen Debatte ob „Garagenlabore“ auch Gefahren mit sich bringen. Einige befürchten, dass es zu biologischen Unfällen kommen könnte oder dass jemand biologische Kampfstoffe entwickeln könnte. Diese Gefahren sind übertrieben, jedoch sollte man sich dieser Gefahren bewusst sein.

How to controll someone

Die Ausrüstung, welche für die Hirnforschung verwendet wird, ist sehr teuer. Dies ist der Grund weshalb die Neurowissenschaften ausschliesslich in Universitäten und grossen Institutionen gemacht werden. Greg Gage, ein Neurowissenschaftler, hatte die Vision die Neurowissenschaften auch für Schulen zugänglich zu machen, sodass diese auch dort unterrichtet werden können. Bei einem Ted-Talk präsentierte Greg Gage die von ihm gegründeten Firma «BackyardBrains». Diese Firma stellt neurowissenschaftliche DIY-Gerätschaften her. Greg zeigt bei der Präsentation, wie er mittels dieser Gerätschaften einerseits die Muskelaktivität einer Probandin visualisiert, sowie die Muskeln eines zweiten Probanden mittels den Hirnsignalen der Probandin kontrolliert.

Inputs

Wiki Nutzung

Für die Handhabung mit Wikis, wie z. B. Wikipedia, wurde eine kurze Einführung gegeben. Wikis sind Webseiten, deren Inhalt von den Nutzern gelesen und bearbeitet werden können. Das Ziel dabei ist das gemeinschaftliche Sammeln von Wissen und Erfahrung. In der Einführung wurde gezeigt, wie das Wiki bedient wird und wie Links sowie Medien, wie Fotos oder Videos, eingefügt werden können. Das Wiki soll dazu dienen die während der Blockwoche gesammelten Informationen und erarbeiteten Projekte zu dokumentieren. Dabei muss jedoch beachtet werden, dass eine simultane Bearbeitung von Texten zu Synchronisierungsproblemen führen kann und daher vermieden werden sollte.

Referat Urs Gaudenz

Am Montag hat Urs Gaudenz uns die Themen Do It Yourself und Open Source vorgestellt. Diese beiden Begriffe waren uns bereits bekannt, da wir zu Beginn die Einführungslektüren gelesen haben. Ergänzend ist zu erwähnen, dass Do It Yourself nicht unbedingt heissen muss, dass man etwas alleine macht. Deshalb wird oft das Synonym Do It Together verwendet. Die Grundidee ist, Entwicklungen zur Verfügung zu stellen und diese mit Konsens des Entwicklers weiterzuentwickeln.

Cropped-GaudiLabs2.png

Referat Ewen Chardronnet

Beim Referat am Dienstagabend hat Ewen Chardronnet uns art4med.eu vorgestellt. Auf dieser Webseite hat Ewen diverse Artikel verfasst und publiziert. Er hat uns drei seiner Artikel vorgestellt:

  • UNBORNoX9
  • Quorum Sensing: Skin Flora Signal System
  • Marine biology

Skill Share Sessions

Zahnspangen herstellen

Sabrina aus dem Team Avengers hat uns diverse Beispiele von Zahnspangen mitgebracht und diverse Sachen darüber erzählt. Sie hat uns aufgezeigt, wie die diversen Zahnspangen funktionieren und wie diese hergestellt werden. Am Ende ihrer Präsentation hatten wir noch die Möglichkeit selbst einen Draht in eine selbst gewählte Form zu biegen. Ebenfalls hat Sabrina uns noch Geschichten ihrer Karriere als Zahntechnikerin erzählt. Auf diese Geschichten wird bewusst nicht weiter eingegangen, da diese nichts für schwache Nerven sind. Der Skill Share war sehr lehrreich und interessant.

Zahnspannge1.jpegZahnspannge3.jpegGebiss.jpeg

Dumpster Dive Hack

Marc hat uns zum Dumpster-Dive mitgenommen. Zuerst haben wir uns vorbereitet, in dem wir uns mit Taschen, Handschuhen, Schraubenziehern, Taschenlampen und weitern Materialien ausgerüstet haben. Danach haben wir uns auf den Weg gemacht geeignete Abfalleimer zu finden, bei welchen sich ein Dive lohnen könnte. Als wir fündig wurden, haben wir das Objekt in die mitgebrachte Tasche gepackt. Wir haben dabei gelernt, dass man unbedingt Handschuhe tragen sollte, denn dreckige Hände oder Verletzungen sind sonst sehr wahrscheinlich. Ebenfalls haben wir erlebt, wie das Sprichwort "one man's trash is another man's treasure" zu verstehen ist.

Dumpsterdive.jpeg DumpsterDive.jpg

Modellieren mit Ton

Elias hat Lufttrocknenden Ton besorgt. Das Ziel der Skill Share Session war, das Handling mit Ton näherzubringen und ein kleines Modell zu formen. Zunächst benutzten wir nasse Zeitung, um ein Knäuel zu formen, welches als Basis für das Modell dient, den Tonverbrauch minimiert und somit auch das Gewicht des Modelles verringert. Das Knäuel wurde von einer Tonschicht umhüllt. Der Ton wurde benetzt und zuerst mit den Fingern geformt. Um eine symmetrische Form zu erstellen, hilft es die Augen zu schliessen und mit beiden Händen über den Ton zu fahren. Ungleichheiten sind mit den Fingerspitzen viel besser bemerkbar als mit den Augen. Grundformen wie z. B. Augenbrauen oder Flossen wurden angebracht und mit Hilfe eines Modellierinstrumentes mit dem restlichen Ton verbunden. Die Formen wurden grob zurechtgeschnitzt und Feinheiten mit der flachen Seite eines Modellierinstrumentes fein eingedrückt.

Tonmodellieren.jpeg

Experimente

Hack 0: Muscle SpikerShield

Der Shield wurde gemäss der Anleitung gelötet. Weil noch keiner unserer Gruppenmitglieder Erfahrung mit Löten hatte, mussten wir gemeinsam lernen zu löten. Dabei hat uns sehr der «Löten ist einfach» Comic geholfen. Die ersten Lötstellen waren oft sehr schlecht und hielten nicht genügend. Alle haben sich gegenseitig geholfen und sich gegenseitig Tipps gegeben, bis schlussendlich alle einigermassen gut löten konnten.

Soldercomic de.jpg Löten01.jpg Löten02.jpg

Dank dem sich gegenseitig helfen, war das Muscel Spiker Shield dann relativ schnell gelötet. So sieht das fertige Muscel Spiker Shield aus:

Shield fertig bestueckt.jpeg

Danach haben wir das fertig gelötete Shield auf dem Arduino installiert und den Code von backyardbrains auf das Arduino gespielt. Danach konnte das Muscel Spiker Shield in Betrieb genommen werden. Wir haben experimentiert, wo wir die drei Elektroden aufkleben können. Gut hat es am Unterarm funktioniert. Nach dem wir uns mit dem Shield vertraut gemacht haben, haben wir noch einen kleinen Lautsprecher an das Shield angesteckt, um auch die Muskelströme hören zu können. Die Töne welche wir hörten waren wie ein Rauschen wenn man kein Radiosignal hat.

ShieldMitLautsprecher.jpg

Um das Arduino nicht ständig über den Laptop mit Strom zu speisen, wurde am Muscel Spiker Shield noch eine Buchse angelötet, um dort eine 9V Batterie anstecken zu können. Damit das Muscel Spiker Shield mit 9V betrieben werden kann, musste noch ein Spannungsteiler auf das Shield gelötet werden.

Ein Problem welches wir hatten war, dass zunächst ständig 5-6 LED's leuchteten. Durch den Drehknopf (Potentiometer) wollten wir die Sensitivität herunter setzen und merkten dabei, dass der Drehknopf nicht funktioniert. Der Drehknopf wurde entfernt und ein neuer wurde angebracht, doch führte dies nur zu weiteren Problemen. Der serial-Monitor zeigte nichts mehr an und die LED's leuchteten auch nicht mehr. Nach einigen Versuchen wurde entschieden den Shield einer früheren Gruppe zu verwenden. Mit dem neuen Shield funktioniert der Hack. Die Sensitivität hätte auch im Programm angepasst werden können, doch diesen Tipp erhielten wir zu spät.

Code

Folgenden Code haben wir für den Hack 0 benutzt. Der Code stammt von backyardbrains. In der Zeile 2 hätten wir die Sensitivität im Code einstellen können ohne ein neues Potentiometer auflöten zu müssen.


# define NUM_LED 6  //sets the maximum numbers of LEDs
# define MAX 150     //maximum posible reading. TWEAK THIS VALUE!!
int reading[10];
int finalReading;
byte litLeds = 0;
byte multiplier = 1;
byte leds[] = {8, 9, 10, 11, 12, 13};
void setup(){
  Serial.begin(9600); //begin serial communications
  for(int i = 0; i < NUM_LED; i++){ //initialize LEDs as outputs
    pinMode(leds[i], OUTPUT);
  }
}
void loop(){
  for(int i = 0; i < 10; i++){    //take ten readings in ~0.02 seconds
    reading[i] = analogRead(A0) * multiplier;
    delay(2);
  }
  for(int i = 0; i < 10; i++){   //average the ten readings
    finalReading += reading[i];
  }
  finalReading /= 10;
  for(int j = 0; j < NUM_LED; j++){  //write all LEDs low
    digitalWrite(leds[j], LOW);
  }
  Serial.print(finalReading);
  Serial.print("\t");
  finalReading = constrain(finalReading, 0, MAX);
  litLeds = map(finalReading, 0, MAX, 0, NUM_LED);
  Serial.println(litLeds);
  for(int k = 0; k < litLeds; k++){
    digitalWrite(leds[k], HIGH);
  }
  //for serial debugging, uncomment the next two lines.
  //Serial.println(finalReading);
  //delay(100);
}

Hack 1: Flappy Dino World

Beim Hack 1 werden gleich drei weit bekannte Videospiele zu einem Spiel kombiniert. Die Spiele "Flappy Bird", "Super Mario World" und das "T-Rex game" von Google-Chrome werden in physischer Form kombiniert und über die Muskelaktivität angesteuert. Das Spiel ermöglicht es in einer unterhaltsamen Art und Weise seine Muskulatur zu trainieren. Die Elektroden werden dazu auf den zu trainierenden Muskel platziert. Diese müssen zum Spielen des Spiels im richtigen Moment angespannt respektive entspannt werden.

Chrome-dino.png Flappy bird 4-pc-games.jpg Super-mario-world-yoshi 6009410.jpg

Aufbau

Wie in Hack 0 beschrieben, wird ein Servomotor mittels der Aktivität der Unterarmmuskulatur angesteuert. Wenn der Unterarm stark angespannt wird, springt der Dino auf maximale Höhe. Ist der Unterarm entspannt bleibt der Dino auf dem Boden. Die Geschwindigkeit und somit auch die Schwierigkeit wird mittels Potentiometer eingestellt. Das Potentiometer ist an einer 9V Batterie und an dem DC Motor angeschlossen. Ist das Potentiometer voll aufgedreht, läuft der Motor mit maximaler Geschwindigkeit.

Potentiometer und DC Motor.jpg

An dem DC-Motor wird ein Kunststoffrohr als Welle angebracht. Dafür wurde in Siemens NX ein Adapter konstruiert und anschliessend 3D gedruckt. Parallel dazu wird ein zweites Rohr in das Gehäuse eingebaut. Da die Rohre glatt sind, muss um die Antriebswelle ein wenig Schleifpapier angeklebt werden, um das Papier bewegen zu können. Noch bevor die zwei A4-Seiten mit der bedruckten Welt auf die Wellen aufgebracht werden, müssen diese Zugeschnitten werden. Dazu wird die Grösse der Öffnung im Gehäuse übernommen. Anschliessend werden die Blätter auf der einen Seite miteinander mit Klebestreifen verklebt und über die beiden Wellen umwickelt. Dabei ist darauf zu achten, dass die Blätter auf den Wellen straff angezogen werden. Danach können die Blätter auch auf der anderen Seite miteinander verklebt werden.

Adapter Motor.PNG Einbau des Rollensystem.jpeg Gehäuse.jpg Welt.jpg Welt zusammenstellen.jpeg

Nachdem die Welt in das Gehäuse eingebaut wurde, kann Yoshi an den Servomotor montiert werden. Yoshi muss in diesem Spiel über die Röhren aus "Super Mario World" springen. Damit Yoshi fest mit dem Servomotor verbunden ist, wurde dieser mittels einer Schraube auf den Arm des Servomotors angebracht. Danach ist das Spiel spielbereit. Die Elektroden können auf ein beliebiges Körperteil angebracht werden, wodurch Yoshi auf und ab bewegt werden kann. Am Potentiometer kann die Schwierigkeit des Spiels eingestellt werden. Lets Play!

Ezgif-2-5d1bae75e8.gif
FlappyDinoWorld TheGame.jpeg

Code

Folgenden Code haben wir für den Hack 1 benutzt. Der Code stammt von backyardbrains und war ursprünglich für die "Gripper Hand" gedacht. Da dieser Code jedoch nichts anderes macht, als einen Servo anzusteuern, konnten wir diesen Code 1 zu 1 von backyardbrains übernehmen.

  /*
  * ----------------------------------------------------------------------------------------------------
  * Backyard Brains 2015
  * Muscle SpikerShield Arduino UNO Code for Control of Robotic Gripper
  *
  * Code monitors amplitude of EMG envelope, displays EMG strength on LED bar and controls 
  * robotic gripper by controlling servo motor.
  * 
  * V1.0
  * Written by Marcio Amorim
  * Updated by Stanislav Mircic
  *
  * Tested with Muscle SpikerShield V2.31
  * ----------------------------------------------------------------------------------------------------
  */
  
  #include <Servo.h>  
  #define GRIPPER_STATE_BUTTON_PIN 4          //pin for button that switches defult state of the gripper (opened/closed)
  #define SERVO_PIN 2                         //pin for servo motor
  #define SENSITIVITY_BUTTON_PIN 7            //pin for button that selects sesitivity
  #define NUM_LED 6                           //number of LEDs in LED bar
  #define GRIPPER_MINIMUM_STEP 5                 //5 degree dead zone (used to avoid aiming oscilation)
  #define OPEN_MODE 1                         //default gripper state is opened
  #define CLOSED_MODE 2                       //default gripper state is closed
  #define MINIMUM_SERVO_UPDATE_TIME 100       //update servo position every 100ms
 
  Servo Gripper;                                 //servo for gripper
  byte ledPins[] = {8, 9, 10, 11, 12, 13};    //pins for LEDs in LED bar
 
  //EMG saturation values (when EMG reaches this value the gripper will be fully opened/closed)
  int sensitivities[] = {200, 350, 520, 680, 840, 1000};
  int lastSensitivitiesIndex = 2;             //set initial sensitivity index
 
  int emgSaturationValue = 0;                 //selected sensitivity/EMG saturation value
  int analogReadings;                         //measured value for EMG
  byte ledbarHeight = 0;                      //temporary variable for led bar height
 
  unsigned long oldTime = 0;                  //timestamp of last servo angle update (ms)
  int oldDegrees = 0;                         //old value of angle for servo
  int newDegree;                              //new value of angle for servo
 
  unsigned long debouncerTimer = 0;           //timer for button debouncer         
  int gripperStateButtonValue = 0;            //temporary variable that stores state of button 
  int userReleasedButton = 1;                 //flag that is used to avoid multiple button events when user holds button
 
  int currentFunctionality = OPEN_MODE;       //current default position of claw
 


  //-----------------------------------------------------------------------------------
  //   Setup servo, inputs and outputs
  // ----------------------------------------------------------------------------------
  void setup(){
    //init servo
    Gripper.attach(SERVO_PIN); 
   
    //init button pins to input   
    pinMode(GRIPPER_STATE_BUTTON_PIN, INPUT);                             
    pinMode(SENSITIVITY_BUTTON_PIN, INPUT);                            
   
    //initialize all LED pins to output
    for(int i = 0; i < NUM_LED; i++){ 
      pinMode(ledPins[i], OUTPUT);
    }
   
    //get current sensitivity
    emgSaturationValue = sensitivities[lastSensitivitiesIndex];
  }


  //-----------------------------------------------------------------------------------
  //   Main loop
  //
  //   - Checks state of sesitivity button
  //   - Checks state of default-gripper-state button
  //   - Measure EMG
  //   - Shows EMG strength on LED bar
  //   - Sets angle of servo based on EMG strength and current mode (open/closed)
  // ----------------------------------------------------------------------------------
  void loop()
  {
  
        //-----------------------  Switch sensitivity ------------------------------------
   
        //check if button is pressed (HIGH)
        if (digitalRead(SENSITIVITY_BUTTON_PIN))
        { 
            //turn off all the LEDs in LED bar
            for(int j = 0; j < NUM_LED; j++)
            {  
              digitalWrite(ledPins[j], LOW);
            }
         
            //increment sensitivity index
            lastSensitivitiesIndex++;
            if(lastSensitivitiesIndex==NUM_LED)
            {
              lastSensitivitiesIndex = 0;
            }
         
            //get current sensitivity value
            emgSaturationValue = sensitivities[lastSensitivitiesIndex]; 
           
            //light up LED at lastSensitivitiesIndex position for visual feedback
            digitalWrite(ledPins[lastSensitivitiesIndex], HIGH);
          
            //wait user to release button
            while (digitalRead(SENSITIVITY_BUTTON_PIN)) 
            {  
              delay(10);
            }       
            //whait a bit more so that LED light feedback is always visible
            delay(100);        
        }

   
        //----------------------------  Switch gripper default position open/close --------------------
    
        //check if enough time has passed for button contact to settle down
        if((millis() - debouncerTimer) > 50)
        {
           gripperStateButtonValue = digitalRead(GRIPPER_STATE_BUTTON_PIN);
           //if button is pressed
           if(gripperStateButtonValue == HIGH)
           {
               //if last time we checked button was not pressed
               if(userReleasedButton)
               {
                   debouncerTimer = millis();
                   //block button events untill user releases it
                   userReleasedButton = 0;
                   
                   //toggle operation mode
                   if(currentFunctionality == OPEN_MODE)
                   {
                     currentFunctionality = CLOSED_MODE;
                   }
                   else
                   {
                     currentFunctionality = OPEN_MODE;
                   }
               }
            }
            else
            {
               userReleasedButton = 1;
            }
       }


       //-----------------------------  Measure EMG -----------------------------------------------
   
       analogReadings = analogRead(A0);//read EMG value from analog input A0
       
       
       //---------------------- Show EMG strength on LED ------------------------------------------
       
       //turn OFF all LEDs on LED bar
       for(int j = 0; j < NUM_LED; j++)
       {  
         digitalWrite(ledPins[j], LOW);
       }
        
       //calculate what LEDs should be turned ON on the LED bar
       analogReadings= constrain(analogReadings, 30, emgSaturationValue);
       ledbarHeight = map(analogReadings, 30, emgSaturationValue, 0, NUM_LED);
       
       //turn ON LEDs on the LED bar
       for(int k = 0; k < ledbarHeight; k++)
       {
         digitalWrite(ledPins[k], HIGH);
       }
  
       //-------------------- Drive Claw according to EMG strength -----------------------------
       
       //set new angle if enough time passed
       if (millis() - oldTime > MINIMUM_SERVO_UPDATE_TIME)
       {
             //calculate new angle for servo
             if(currentFunctionality == OPEN_MODE)
             {  
               analogReadings = constrain(analogReadings, 40, emgSaturationValue);
               newDegree = map(analogReadings, 40 ,emgSaturationValue, 190, 105); 
             }
             else
             {
               analogReadings = constrain(analogReadings, 120, emgSaturationValue);
               newDegree = map(analogReadings, 120 ,emgSaturationValue, 105, 190);
             }
         
             //check if we are in servo dead zone
             if(abs(newDegree-oldDegrees) > GRIPPER_MINIMUM_STEP)
             {
                //set new servo angle
                Gripper.write(newDegree); 
             }
             oldTime = millis();
             oldDegrees = newDegree;
       }
}

Hack 2: Calanda-Kopfkühler

Um im Sommer einen kühlen Kopf zu bewahren, wurde der Kopfkühler entwickelt. In einem Strohhut wurde ein Temperatursensor angebracht. Dieser Sensor misst die Temperatur direkt am Kopf. Wenn durch Hitzköpfe die Temperatur des Sensors über 26°C ansteigt, wird eine Kühlung aktiviert. Die Kühlung kann in einer Umhängetasche mitgetragen werden. An diese Tasche kann eine Wasserflasche angebracht werden. Wenn die Kühlung läuft, wird alle fünf Sekunden für die Dauer von jeweils einer Sekunde eine Pumpe aktiviert, welche Wasser aus der Flasche auf den Kopf des Hutträgers pumpt. Ausserdem ist oben im Hut ein Ventilator eingebaut. Dieser wird ebenfalls mit der Kühlung aktiviert und sorgt für ein angenehmes Lüftchen.

Kühlhut.jpg WhatsApp Image 2022-02-12 at 10.05.05.jpeg

Nutzen in der Medizintechnik

Paraplegiker haben teilweise das Problem, dass sie nicht schwitzen können. Das entwickelte System kann für andere Kleidungsstücke angepasst werden, um gelähmte Körperteile von Paraplegikern vor Hitze zu schützen.

Aufbau

Das Herzstück der Kühlung ist ein Arduino Uno. Sobald die Temperatur den festgelegten Wert überschreitet, schaltet das Arduino zwei Relais ein. Die Relais unterbrechen oder schliessen jeweils einen Stromkreis, welcher aus einer Batterie, dem Relais und der Pumpe bzw. des Ventilators besteht. Das Relais ist nötig, da für die Pumpe und den Ventilator eine höhere Spannung benötigt wird als die fünf Volt, welche vom Arduino kommen.

Erweiterung

Bei der aktuellen Version gibt es keine Möglichkeit die Kühlung auszuschalten, ausser dem Unterbrechen der Stromversorgung oder dem Erreichen einer tieferen Temperatur. Durch Einbau eines Schalters könnte nebst der automatischen Aktivierung und Deaktivierung der Hut auch manuell gesteuert werden. Die Kühlung sollte möglichst kompakt sein. So könnte ausprobiert werden, ob ein Arduino-Nano zur Steuerung ausreichend ist. Statt zwei einzelnen Relais könnte ein zwei-Kanal-Relais verwendet werden. Ausserdem könnte die Stromversorgung von nur einem einzigen zentralen Energiespeicher stammen, anstatt von drei verschiedenen. Da der Hut vor allem an heissen und sonnigen Tagen verwendet wird, könnten Solarzellen mit einer aufladbaren Batterie verwendet werden.

Code

//Einbinden der Bibliotheken
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 2  //Sensor DS18B20 am digitalen Pin 2
OneWire oneWire(ONE_WIRE_BUS); //
//Übergabe der OnewWire Referenz zum kommunizieren mit dem Sensor.
DallasTemperature sensors(&oneWire);
#define relaisModul 8 //1-Kanal Relaismodul am digitalen Pin 8
const float MIN_TEMP = 26; //Temperaturschwellwert zum schalten des Relais
void setup(void) { 
 Serial.begin(9600); //Starten der seriellen Kommunikation mit 9600 baud
 Serial.println("Temperatursensor - DS18B20"); 
 pinMode(relaisModul, OUTPUT); //Pin des Relaismoduls als Ausgang definieren
 sensors.begin(); //Starten der Kommunikation mit dem Sensor
} 
void loop(void){ 
   pinMode (7,OUTPUT);
   digitalWrite(7,1);
sensors.requestTemperatures(); 
//Ausgabe aller Werte der angeschlossenen Temperatursensoren.
//auslesen der Temperatur
float tempC = sensors.getTempCByIndex(0);
//ausgeben der Temperatur auf dem seriellen Monitor
printValue(tempC, "°C");
//wenn die aktuelle Temperatur grösser als die gespeicherte dann soll das Relais ausgelöst werden
if(MIN_TEMP < tempC){
   digitalWrite (relaisModul, 0);
   Serial.print("sollte laufen");
   delay(1000);
   digitalWrite(relaisModul, 1);
   Serial.print("vordelay1s");
   delay(5000);
   Serial.print("nach delay1s");
} else {
   digitalWrite(relaisModul, 1);
 
}
}
//ausgeben eines Textes auf den seriellen Monitor der Arduino IDE
void printValue(float value, String text){
  Serial.print(value);
  Serial.println(text);
}

Reflexion

Die Blockwoche Medizintechnik DIY hat uns das FabLab und die Digitale Fertigung nähergebracht. Den Umgang mit dem 3D-Drucker sowie dem Lasercutter konnten wir aktiv erlernen. Die Philosophie der DIY/DIT-Gemeinschaft haben wir kennengelernt und gelebt. Einen etwas für uns neuen Ansatz an die Projektentwicklung, nämlich einfach mal zu probieren, konnten wir in dieser Woche erlernen.

Hack 0 hat uns das Arduino nähergebracht. Wir konnten auf eine spielerische Art und Weise unser Muskelaktivität elektrisch sichtbar machen. Hack 0 war auch sehr lehrreich für uns alle, denn wir haben gelernt zu löten, was wir auch im weiteren Verlauf der Blockwoche gut brauchen konnten. Was uns überrascht hat, war wie einfach es ist Muskelströme zu messen.

Bei Hack 1 haben wir die Hardware aus Hack 0 weiterverwendet und ein spielerisches Krafttraining entwickelt. Dabei haben wir uns auch stark auf den spielerischen Aspekt konzentriert. Wir empfanden dies auch als eine gute Möglichkeit, um das Interesse für DIY und Neuroscience in Kindern zu erwecken. Auch durch das Interesse, welches die anderen Teilnehmer der Blockwoche zeigten, haben wir gelernt, dass das "spielerische" sehr gut ankommt und eine gute Möglichkeit ist, um Personen zu erreichen.

Bei Hack 2 wollten wir eine Pumpe verwenden und kamen aufgrund dessen auf die Idee ein System zu entwickeln, welches ab einer bestimmten Temperatur Wasser abgibt. Dieses System könnte bei Paraplegiker Anwendung finden.

Alles in allem hat die Blockwoche viel Spass gemacht und uns einiges gelehrt. Wir würden sie weiterempfehlen.

Präsentation

File:MedTech-DIY_Präsentation_E-gewinnt.pdf