MedTechDIY20 Bananas In Pajamas

From Hackteria Wiki
(Redirected from Bananas In Pajamas)
Jump to: navigation, search
222482 207900402574312 200286980002321 630544 7055728 n.png


Team

Bananas In Pajamas besteht aus drei Studierenden: Giona Adami, Dominic Bacher und Janick Marfurt. Das Team ist interdisziplinär aus Maschinentechnik, Medizintechnik und Wirtschaftsingenieur.

Mitglieder:

Stundenplan

Stundenplan DIY Medizintechnik

DIY Culture

Das Akronym DIY (Do It Yourself) bezeichnet die Selbst-Durchführung mit den eigenen Ressourcen eines Projekts. DIY ist eine Community von Personen, die um das Prinzip "Do it Yourself" Wissen, technische Lösungen, Ideen, Projekte usw. tauschen. Das DIY Ansatz fördert die Kreativität und die Lösungsfindung von Problemen mit gemeinverständliche Mitteln und Werkzeuge. Aus diesem Grund gleiche DIY Produkt-Ideen werden verschiedene Lösungsfindungen aufweisen. Die Vorteile von DIY sind das Wachstum eines Projekts durch das Tauschen von Entwicklungsinformationen in der Community. Viele DIY Projekte sind durch die DIY-Community von Enthusiasten oder Spezialisten verbessert worden (LINK zu Magicmirror). Ein anderer Vorteil ist, dass man durch DIY sehr viel lernt. Der Nachteil von DIY besteht in der Freiheit damit die Community das Wissen austauscht. Es gibt auch DIY-Waffenprojekte oder potenzielle DIY-Bösartige Projekte, die auch Teile der Community unterstützten (Defense Distributed).

Open-Source

Die Bezeichnung Open-Source wird für nichtlizenzierte Software angewendet und beschreibt diejenige Software, die frei von der Community modifiziert und weiterentwickelt werden können. Open-Source heisst, dass man freier Zugriff zum Source-Code besitzt. Heutzutage sind Open Source Programme sehr breit. Sie bieten semi-professionelle Lösungen um gewisse arbeiten durchzuführen. Bei CAD Workstation zählen viele Programme wie Siemens NX, CATIA und Autodesk Inventor. Das Open Source Konkurrent in diesem Fall ist FreeCAD. Diese Software ermöglicht fast alle grundliegenden Funktionen einer CAD Workstation.

Skills Share Sessions

Bei den Skills Share Sessions (SSS) will man neues Wissen übermitteln. Die Teilnehmern der SSS bieten Crash-Kurse an, basierend aus persönlichen Kenntnissen oder Erfahrungen. Jeder Person kann sich in mehrere Kurse einschreiben und das Wissen der Veranstalter aufnehmen.

Eine Skill Share Session artikuliert sich in 4 Phasen:

  • Phase 1: In dieser Phase stellt man dar, den eigenen Lerninteressen beziehungsweise was man den anderen Teilnehmern beibringen kann,
  • Phase 2: Man bewertet die dargestellten Kurse, diejenigen mit den höchsten Bewertungen werden sortiert.
  • Phase 3: Die Teilnehmer schreiben sich in den ausgewählten sortierten Kurse ein.

Bananas in Pajamas hat einen Crash-Kurs der Dauer von einer Stunde über die Grundlagen der Elektrotechnik angeboten.

Elektrotechnik Crash-Kurs

Im Elektrotechnik Crash Kurs wird dem Lernenden ein kurzer Einblick in die Welt der Elektrotechnik gegeben. Als erstes wird ein Multimeter erklärt und wie man es richtig benutzt. Anschliessend werden diverse verschiedene Komponenten, wie zum Beispiel ein Kondensator oder eine Spule erklärt. Auch das Anwendern einer Leuchtdiode wird erklärt und auf was zu achten ist. Zum Schluss wird das Schema für das «Muscle Spiker Shteld» Board erklärt. Anschliessend konnten uns die Studierenden noch Fragen stellen und es gab einen Austausch zwischen den verschiedenen Problemen die mit dem Board entstanden sind.


ET-Crash-Kurs.jpg

Schweissen mit MAG- TIG- Elektrode

Im Skill share session hat man das Kurs "Schweissen", von Team G2020 angeboten, besucht. Es war sehr interessant und Gut gestaltet. Wir konnten die drei Schweissverfahren selber ausprobieren. Das Schweissen mit dem Elektrode war die schwierigste, da man zwei Parametern (Zusatzmaterial und Temperatur) mit dem Elektrode steuern muss. Das TIG Schweissverfahren weist Analogien mit das Lötverfahren auf. Man wärmt die Metallteile auf und man deponiert das Zusatzmaterial auf. Das Zusatzmaterial schmilz auf die Metallspalte und verbindet die zwei Metallteile.

Hack 0

Hier werden Experimente durchgeführt, um die Anwendung des DIY Muscle SpykerShield kennezulernen. Den DIY Muscle SpykerShield ist einen mit Arduino kompatible Messplatine von Backyard Brains, die die Messung von elektrische Spnannungen im Körper mithilfe von Elektroden ermöglicht. D kommt in einem DIY-Kit und muss selbst montiert und gelötet werden.

LoetenSPyker 3376-kopie.jpg

Elektrische Aktivität des Muskels messen

Mit dieses Experiment misst man die elektrische Impulse des Unterarmmuskel und stellt die Intensität des Impuls mit eine Reihe von 6 LEDs dar. Die Software ist unter Backyard Brains - DIY Muscle SpykerShield verfügbar.

Beobachtungen und Erkenntnisse

Das Experiment hat gut funktioniert. Man konnte die elektrische "Aktivität" des Muskels auf dem Serial-Monitor und auf die LEDs beobachten. Durch die Verkürzung des Muskels entsteht ein elektrischen Impuls, das gemessen werden kann. In einem Muskel die Kraft wird durch die Frequenz der Muskelfaser-Zuckungen gesteuert. Je die Frequenz höher ist, desto mehrere Muskelfasern sich verkürzen. Mit dem DIY Muscle Spyker Shield sieht man diese Frequenzen nicht, da es sich um hochfrequenzen handelt. Bei dieser Experiment tritt einen Störsignal auf, der eine Schwingung in der Messung verursacht. Man hat eine Verminderung des Störsignals beobachtet, bei das Austecken von das PC-Lädegerät.

Experiment01.jpg

Die LEDs zeichnen die elektrische Aktivität des Muskels.

Musik mit den Muskeln machen

Mit diesem Experiment werden durch Muskelkontraktionen Töne erzeugt. Das Experiment ist ähnlich aufgebaut wie das vorherige. Anstelle der LEDs wird jedoch ein Lautsprecher angeschlossen. Durch verschieden starke Kontraktion der Muskeln können verschiedene Töne erzeugt werden, somit verwandelt sich der Unterarm zu einem Musikinstrument. Der Versuchs Aufbau ist sehr simpel und es macht spass

Musik Muskeln.jpg


Die Anleitung zum Versuch findet ihr hier.

Beobachtungen und Erkenntnisse

Wie in dem vorherigen Beispiel tritt hier auch einen Rauschsignal auf. Es könnte eine Netz-Störung von 50 Hz sein. Im Fablab sind verschiedene Maschinen wie Lasercutters, 3D Drucker, Luftreinigungssystem vorhanden. Diese Anlagen besitzen Motoren, die magnetische Felder erzeugen und also auch Funkstörungen.

Hack 1: DIY Digital Candle

Das erste Hack ist eine digitale Kerze. Die Idee ist eine moderne Lampe zu basteln, die wie eine konventionelle Kerze angezündet wird. Mittels eine Licht-abhängige-Widerstand (Light dependent Resistor "LDR") ist man in der Lage das verursachte Licht der Flamme eines Feuerzeug zu detektieren.

Ezgif.com-video-to-gif.gif

Demo of the candle

Funktionsweise

Das Prinzip dieser Projekt ist sehr simpel. Man will eine Lampe mithilfe von einem Feuerzeug wie eine Kerze einschalten. Die Lampe wird anhand einer Licht-abhängige Widerstand eingeschaltet und solange das Licht der Lampe auf die Widerstand kommt schlatet die Kerze nicht ab. Um die Digital Candle abzuschalten ist es nötig die Licht abhängige Widerstand vor Licht decken. Die Steuerung wird mit Arduino gewährleistet und ein modernen und effizienten SMD LEDs-Ring wird als Lichtquelle benutzt. Dieses Hack stellt einen Kontrast zwischen alte und neue Technologien dar. Eine mögliche Weiterentwicklung für medizintechnische Zwecke dieser digitalen Kerze besteht in der Anwendung von Photoresistoren um die Sauerstoff im Blut mittels Messung der Lichtabsorption durchzuführen.

Inspiration

Photoresistoren sind Licht-abhängige Widerstände. Mit diese ist man in der Lage Lichtdifferenzen zu messen und zu detektieren. Die Inspiration kommt von der schweizerische Artillerie-Systeme. Bei den Panzerhaubitzen gibt das Gefahr, dass einen Feuer im Fahrzeug ausgelöst wird. Die Feuermelder im Panzerhaubitze funktionieren mit der Licht. Man will den gleichen Konzept für den Operationssäle anwenden. Im Operationssal benutzt gefährliche Stoffe wie Sauerstoff und eine Austritt könnte eine schwerwiegende Explosion verursachen. Man könnte deswegen Photoresistoren oder ähnliche Komponenten anwenden um einen Feuerlösch-System rechtzeitig zu aktivieren.

Do the digital candle yourself!

What do you need for this project:

  • A Photoresistor (LDR)
  • A 110 ohms resistor
  • Arduino Uno or equivalent
  • Some cables
  • One cylindrical piece of wood
  • A LED's ring

The electrical draw below shows the cable connections, please note that the 110 ohms resistors is required to guarantee a difference of voltage in the analog input of arduino by differents light intensities!

Electrical connections

Here the electrical scheme of the photoresistor; You can program the LED's Ring by following the tutorial:

Adafruit 24 RGB LED Ring tutorial


DSC 0480.jpg

Source Code

The program of the digital candle is listed below.

//---------------------------------------------------------------
//DIGITAL CANDLE SOURCE CODE
//This is an Open Source code, feel free to modify and/or share it.
//---------------------------------------------------------------

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN        6
#define NUMPIXELS 24
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
#define DELAYVAL 250
#define SOL 125
int sensorPin = A0;
int sensorValue = 0;
bool schalter = false;

void setup() {
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
 clock_prescale_set(clock_div_1);
#endif
// declare the ledPin as an OUTPUT:
   pinMode(sensorValue, OUTPUT);
   Serial.begin(9600);
   pixels.begin();
/*--------------------------------------------------------------------------*/
   pixels.setPixelColor(0, pixels.Color(0, 0, 0));
   pixels.setPixelColor(1, pixels.Color(0, 0, 0));
   pixels.setPixelColor(2, pixels.Color(0, 0, 0));
   pixels.setPixelColor(3, pixels.Color(0, 0, 0));
   pixels.setPixelColor(4, pixels.Color(0, 0, 0));
   pixels.setPixelColor(5, pixels.Color(0, 0, 0));
   pixels.setPixelColor(6, pixels.Color(0, 0, 0));
   pixels.setPixelColor(7, pixels.Color(0, 0, 0));
   pixels.setPixelColor(8, pixels.Color(0, 0, 0));
   pixels.setPixelColor(9, pixels.Color(0, 0, 0));
   pixels.setPixelColor(10, pixels.Color(0, 0, 0));
   pixels.setPixelColor(11, pixels.Color(0, 0, 0));
   pixels.setPixelColor(12, pixels.Color(0, 0, 0));
   pixels.setPixelColor(13, pixels.Color(0, 0, 0));
   pixels.setPixelColor(14, pixels.Color(0, 0, 0));
   pixels.setPixelColor(15, pixels.Color(0, 0, 0));
   pixels.setPixelColor(16, pixels.Color(0, 0, 0));
   pixels.setPixelColor(17, pixels.Color(0, 0, 0));
   pixels.setPixelColor(18, pixels.Color(0, 0, 0));
   pixels.setPixelColor(19, pixels.Color(0, 0, 0));
   pixels.setPixelColor(20, pixels.Color(0, 0, 0));
   pixels.setPixelColor(21, pixels.Color(0, 0, 0));
   pixels.setPixelColor(22, pixels.Color(0, 0, 0));
   pixels.setPixelColor(23, pixels.Color(0, 0, 0));
   pixels.show();
/*--------------------------------------------------------*/
}

void loop() {
 
   
   if(analogRead(sensorPin)>SOL)
   {
     schalter = true;
   }
   else if(analogRead(sensorPin)<30)
   {
     schalter = false;
     pixels.clear();
   }
   sensorValue=analogRead(sensorPin);
   Serial.println(sensorValue);
   
       
   
   delay(1000);
   if(schalter==true)
   {
   pixels.setPixelColor(0, pixels.Color(255, 255, 255));
   pixels.setPixelColor(1, pixels.Color(255, 255, 255));
   pixels.setPixelColor(2, pixels.Color(255, 255, 255));
   pixels.setPixelColor(3, pixels.Color(255, 255, 255));
   pixels.setPixelColor(4, pixels.Color(255, 255, 255));
   pixels.setPixelColor(5, pixels.Color(255, 255, 255));
   pixels.setPixelColor(6, pixels.Color(255, 255, 255));
   pixels.setPixelColor(7, pixels.Color(255, 255, 255));
   pixels.setPixelColor(8, pixels.Color(255, 255, 255));
   pixels.setPixelColor(9, pixels.Color(255, 255, 255));
   pixels.setPixelColor(10, pixels.Color(255, 255, 255));
   pixels.setPixelColor(11, pixels.Color(255, 255, 255));
   pixels.setPixelColor(12, pixels.Color(255, 255, 255));
   pixels.setPixelColor(13, pixels.Color(255, 255, 255));
   pixels.setPixelColor(14, pixels.Color(255, 255, 255));
   pixels.setPixelColor(15, pixels.Color(255, 255, 255));
   pixels.setPixelColor(16, pixels.Color(255, 255, 255));
   pixels.setPixelColor(17, pixels.Color(255, 255, 255));
   pixels.setPixelColor(18, pixels.Color(255, 255, 255));
   pixels.setPixelColor(19, pixels.Color(255, 255, 255));
   pixels.setPixelColor(20, pixels.Color(255, 255, 255));
   pixels.setPixelColor(21, pixels.Color(255, 255, 255));
   pixels.setPixelColor(22, pixels.Color(255, 255, 255));
   pixels.setPixelColor(23, pixels.Color(255, 255, 255));
   pixels.show();
   }
   else
   {
   pixels.setPixelColor(0, pixels.Color(0, 0, 0));
   pixels.setPixelColor(1, pixels.Color(0, 0, 0));
   pixels.setPixelColor(2, pixels.Color(0, 0, 0));
   pixels.setPixelColor(3, pixels.Color(0, 0, 0));
   pixels.setPixelColor(4, pixels.Color(0, 0, 0));
   pixels.setPixelColor(5, pixels.Color(0, 0, 0));
   pixels.setPixelColor(6, pixels.Color(0, 0, 0));
   pixels.setPixelColor(7, pixels.Color(0, 0, 0));
   pixels.setPixelColor(8, pixels.Color(0, 0, 0));
   pixels.setPixelColor(9, pixels.Color(0, 0, 0));
   pixels.setPixelColor(10, pixels.Color(0, 0, 0));
   pixels.setPixelColor(11, pixels.Color(0, 0, 0));
   pixels.setPixelColor(12, pixels.Color(0, 0, 0));
   pixels.setPixelColor(13, pixels.Color(0, 0, 0));
   pixels.setPixelColor(14, pixels.Color(0, 0, 0));
   pixels.setPixelColor(15, pixels.Color(0, 0, 0));
   pixels.setPixelColor(16, pixels.Color(0, 0, 0));
   pixels.setPixelColor(17, pixels.Color(0, 0, 0));
   pixels.setPixelColor(18, pixels.Color(0, 0, 0));
   pixels.setPixelColor(19, pixels.Color(0, 0, 0));
   pixels.setPixelColor(20, pixels.Color(0, 0, 0));
   pixels.setPixelColor(21, pixels.Color(0, 0, 0));
   pixels.setPixelColor(22, pixels.Color(0, 0, 0));
   pixels.setPixelColor(23, pixels.Color(0, 0, 0));
   pixels.show();
   delay(500);
   }
}

Hack 2: DIY Crane Arm Picker

Im Hack zwei werden nochmals neue Ideen gesammelt. Es wird geschaut das wir uns möglichst in eine andere Richtung als der Hack eins begeben. Im Hack zwei hat sich das Team Bananas in Pajamas eine Kralle überlegt, die mithilfe der Muskelanspannung eines Menschen gesteuert werden kann. Diese Zange könnte in der Medizinaltechnik für Leute mit Rückenprobleme eingesetzt werden. So muss sich der Patient zum Aufnehmen eines Gegenstandes nicht mehr bücken, sondern kann mit Hilfe der Zange diverse Gegenstände vom Boden aufnehmen.

Ezgif.com-video-to-gif (1).gif

Demo of the Crane Arm Picker

Funktionsweise

Eine Zange, die mithilfe eines Servos der über die Muskulatur funktioniert, ist an einer Schnur mit einem Motor festgemacht. Der DC Motor wickelt die Schnur auf und ab und lässt dadurch die Zange nach oben oder nach unten. Als erstes muss ein Taster betätigt werden. Anschliessend bewegt sich die Zange nach unten. Ziel ist es den Gegenstand mithilfe der angespannten Muskeln zu Greifen. Anschliessend fährt der Motor automatisch wieder nach oben.

Greifer

Die einzelnen Teile des Greifers wurden aus dem 3D Drucker gedruckt und anschliessend mit Schrauben zusammengeschraubt. Die Datei für den Drucker wurde auf DIY 3D Teile gefunden. Das Greiffprinzip funktioniert mit einem Servo. Dieser wird über das Arduino angesteuert. Mit Hilfe von Elektroden wird die Spannung der Muskeln gemessen. Durch das Anspannen der Muskeln öffnet sich der Greifer. Sobald die Muskulatur entspannt ist, schliesst sich der Greifer und kann so einen beliebigen Gegenstand greifen.

Hebesystem

Das Hebesystem hat die Funktion, den Greifen runter zu fahren und wieder aufzuheben. Man hat sich für einen DC Motor entischieden, der durch Umdrehungsgeschwindigkeit und Zeit gesteuert wird. Ein Arduino UNO mit einem Adafruit Motor Shield v2.0 ist zuständig für die Steuerung der Greiferhöhe. Ein Schalter gibt den Impuls an wann man den Greifer runterfahren will.

DSC 0491.JPG DSC 0492.JPG

Der Schalter ist mit zwei Federn aufgebaut und gibt einen Impuls auf die digitale Eingang von Arduino wenn dies betätigt wird.

Die elektrische Schaltung ist in der nächste Abbildung dargestellt:

DSC 0490.JPG

Elektrische Schaltung:

DSC 0495.JPG

Do the DIY Crane Arm Picker yourself!

What do you need:

Source Code

Claw driver

 /*
 * ----------------------------------------------------------------------------------------------------
 * 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;
       }
}

DC Motor

//---------------------------------------------------------------
//-------------------- DC MOTOR MANAGER -------------------------
//This is an Open Source code, feel free to modify and/or share it.
//---------------------------------------------------------------

#include <Wire.h>
#include <Adafruit_MotorShield.h>
#include "utility/Adafruit_MS_PWMServoDriver.h"  

Adafruit_MotorShield AFMS = Adafruit_MotorShield(); 
Adafruit_DCMotor *myMotor = AFMS.getMotor(1);
#define PIN 6
int knopf = 0;

void setup() {

AFMS.begin();
Serial.begin(9600);
pinMode(PIN, INPUT);
myMotor->setSpeed(0);
myMotor->run(BRAKE);
knopf = LOW;
}

void loop() {
myMotor->setSpeed(0);
myMotor->run(BRAKE);

delay(100);
knopf = LOW;
knopf =digitalRead(PIN);
Serial.println(knopf);

if( knopf== HIGH)
{
myMotor->setSpeed(150);
myMotor->run(BACKWARD);
delay(3500);
myMotor->run(FORWARD);
delay(5000);
knopf = LOW;
 }
}

Wochenjournal

Tag 1

Wir haben uns alle am Montagmorgen im FabLab versammelt und die Blockwoche mit einer kurzen Vorstellungsrunde eingeläutet. Kurz darauf gab es einen kleinen Rundgang durch das FabLab und eine Übersicht über den Wochenablauf. Nach einer kurzen Pause konnten wir und in die verschiedenen Gruppen einteilen und unsere Arbeitsplätze einrichten. Nach dem Mittagessen gab es ein Vortrag zum Thema DIY-Kultur. Anschliessend konnten wir mit dem Zusammenbau des DIY Muscle SpykerShields beginnen und erste Experimente damit durchführen.

Tag 2

Den Dienstag haben wir im Zimmer E200 gestartet. Nach einer kurzen Einführung über die Erwartungen der Skill Share Sessions konnte jeder etwas notieren was er gerne lernen und was gerne beibringen möchte. Anschliessend wurden die Vorschläge im Plenum kategorisiert und zusammengefasst. Danach konnte jede Gruppe sich für ein Themengebiet einschreiben, welches es gerne beibringen möchte. Nach der Gruppeneinteilung konnten wir mit den Experimenten wiederfahren. Das Resultat haben wir am Nachmittag jeweils den anderen Gruppen vorgestellt und uns über aufgetretene Probleme ausgetauscht. Anschliessend hatten wir noch zeit unsere Skill Share Lektionen vorzubereiten. Am Abend gab es noch einen Kulturbeitrag in Form eines Konzerts von Simon Berz - "Sediment" mit anschliessendem Apero.

Tag 3

Der Mittwochmorgen war reserviert für die Skill Share Sessions wo jeder individuell verschiedene Kurse besuchen konnte. Es gab spannende Vorträge und Inputs zu verschiedenen Themen. Am Nachmittag war der Start off von Hack 1, wo wir selbst ein erstes Projekt realisieren konnten. Beim Durchstöbern der Elektrotechnikecke im FabLab sind wir auf einen Photoresistor gestossen. Wir entschieden für den Hack 1 etwas mit Licht zu realisieren. Gleichzeitig wollten wir erste Erfahrungen mit dem 3D-Drucker und dem Arduino machen. Das Projekt der Digitalen Kerze hat diese drei Disziplinen gut vereint und lag zeitlich in einem realisierbaren Ramen.

Tag 4

Am Donnerstag hatten wir den ganzen Tag Zeit, um an unseren eigenen Projekten zu arbeiten. Kurz vor dem Mittag haben wir einander unsere Ideen und Projekte vom Hack 1 vorgestellt und uns über Probleme ausgetauscht. Am Nachmittag gab es einen Vortrag von Dr. Christian Gehringer. Anschliessend konnten wir mit dem Hack 2 starten. Durch einen Input von Urs kamen wir auf die Idee unsere Kerze zu einem Pulsoxygenmeter aufzurüsten. Da wir nicht sicher wahren ob dies mit den vorhandenen Materialien machbar ist, haben wir parallel schon Tests für eine Muskelgesteuerte Greifkralle durchgeführt. Da wir keine Passenden LED gefunden haben und der Photowiderstand nicht sensitiv genug war, haben wir und aus zeitlichen Gründen für die Greifkralle entschieden. Diese hat den Vorteil, dass wir noch ein Projekt mit Motoren verwirklichen konnten.

Tag 5

Der Freitag stand voll zur Verfügung für den Hack 2. Am Morgen haben wird die benötigten Teile gedruckt und die Motorensteuerung getestet und anschliessend kalibriert. Der Aufbau verlief ohne Komplikationen und wir konnten schon bald erste Testversuche starten. Um noch etwas an der Dokumentation arbeiten zu können, haben wir uns vorgenommen den Hack 2 bis am Freitagnachmittag fertig zu stellen. In der zweiten Hälfte des Nachmittags konnten wir dann individuell an unserer Dokumentation arbeiten und die Präsentation vorbereiten.

Tag 6

Am Samstagmorgen konnte jedes Team ihre Hacks präsentieren. Dank diverser spannender Vorträge verging der morgen sehr schnell. Nach einer kurzen und effizienten Aufräumsession gab es einen Wochenrückblick im Plenum wo jeder seine Eindrücke der Woche mitteilen konnte. Um 12:30 war das Spektakel schliesslich vorbei und wir konnten auf eine spannende und lehrreiche Blockwoche zurückblicken.

Reflexion

Das Team Bananas in Pajamas hat sich super ergänzt, da die Studierenden interdisziplinär aus verschiedenen Studiengänge sind. Auch das Arbeitsklima untereinander war sehr angenehm. Wir konnten viel voneinander lernen. Die grössten Schwierigkeiten waren das Programmieren mit Arduino, den vom Team hatte nur jemand gewisse Erfahrungen in diesem Gebiet. Am besten hat uns das freie Arbeiten gefallen, den wir konnten unserer Kreativität freien lauf lassen. Ein grosses Highlight war der Musiker, der uns einen Einblick in seinen künstlerischen Alltag gab.


Zusammenfassung

Die Blockwoche DIY hat unsere Erwartungen im allgemein erfüllt. Wir haben gelernt wie man Geräte recyclen kann und die neue Anwendungen des Geräts (oder Teile davon) pragmatsich umsetzten kann. Das DIY Kultur braucht Erfahrung, da man nicht sofort die Lösungen von Probleme in der Realisierung von DIY Projekte sieht. Je mehr das Projekt komplex ist, desto weniger die Machbarkeit wird, aber mit viele Erfahrung in der DIY werden Projekte kaum nicht machtbar. Dieser Ansatz fanden wir sehr interessant und vielfältig. Es gibt nur nicht Programmierung sondern alle Phasen eines Projekts werden durchgeführt, vielleicht nicht in eine formelle Form wie in der professionelle Praxis. In der Zukunft die DIY-Kultur könnte neue Arbeitsmöglichkeiten öffnen.

Return to: DIY Medizintechnik