Team Auslöten

From Hackteria Wiki
Revision as of 12:48, 23 September 2021 by Robin.schaumlechner (talk | contribs) (Code)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search


Einleitung

Herzlich willkommen auf der offiziellen Seite vom Team "Auslöten". Auf dieser Seite werden die Ergebnisse der Blockwoche "MEdtech DIY" vorgestellt. Die Daten unserer Projekte werden hier zur Verfügung gestellt, wenn man diese nachbauen möchte. Wir wünschen viel Vergnügen!

Einführung Tools

Lasercutter

Beim Lasercutter werden Platten aus verschiedenen Materialien wie Holz, Karton, Plexiglas, Kunststoff, Leder, ect. mit einem Hochleistungslaser durchtrennt oder graviert. Mit einem Zeichnungsprogramm werden die 2D Pläne erstellt oder von vorhandenen OpenSource Daten übernommen und angepasst. Wenn die Pläne bereitstehen, werden diese mittels Stick auf den Lasercutter übertragen, da werden die Pläne gelasert. Eines der Vorteile ist der schnelle Herstellungsprozess, so können zum Beispiel hochwertige Gehäuse für Prototypen hergestellt werden. Im FabLab in Horw stehen zwei von Acctek (AKJ6090 und AKJ9060).

3D-Drucker

Im FabLab stehen drei Original Ultimaker 3D-Drucker und vier neuere Versionen. Für die Herstellung eines 3D-Teils wird ein CAD Plan vom Objekt und eine PLA-Kunststoff-Rolle gebraucht, das beim Drucker eingefädelt ist. Ein Roboterarm druckt den flüssigen Kunststoff und nach dem abkühlen stehen die Objekte bereit. Gegenüber dem Lasercutter ist der 3D-Drucker extrem langsam, was bei der Planung berücksichtigt werden muss.

Mitglieder

Jan Scala

Jan Scala.jpg Medizintechnikstudent, 5. Semester

Jan Scala hat eine Lehre als Orthopädist und anschließend die Berufsmatura absolviert. Seinen Militärdienst hat er als Hundeführer mit seinem Holländischen Schäferhund gemeistert. Er studiert nun Medizintechnik an der HSLU.

Susmida Jeyakanthan

Susmida Jeyakanthan.jpg Medizintechnikstudent, 5. Semester

Susmida ist gelernte Ingenieur-Bauzeichnerin. Nach der Lehre arbeitete sie im erlernten Beruf und ging anschließend für 4 Monate nach Kanada um ihrem geliebten Hobby, der Pinguinfotografie, nachzugehen. Die Berufsmatura hat sie vor dem Studium im Vollzeitstudium durchgezogen. Jetzt studiert sie Medizintechnik.

Robin Schaumlechner

Robin Schaumlechner.jpg Medizintechnikstudent, 5. Semester

Robin ist das kleine Schlitzohr in unserem Team. Er Absolvierte eine Lehre als Elektroniker. Anschließend an die Lehre hat Robin den Militärdienst als Loadmaster im Durchdiener Modell vollzogen. Danach Absolvierte er die Berufsmatura. Jetzt studiert er Medizintechnik an der HSLU.

Hack 0

Material

  • Muscle SpikerShield mit Kit
  • Lötkolben
  • Lötzinn
  • Auslötlitze

Planung und Durchführung

Wir bekamen einen Bausatz zum Hack und fanden die Beschreibung dazu im Internet. Gleich darauf begannen wir das Board zu löten. Als das Board fertig war positionierten wir die Elektroden am arm. Nachdem der Code, welcher zum Download auf der Seite des Entwicklers zur Verfügung steht, auf das Arduino geladen wurde, konnten wir loslegen.

Löten

Löten2.jpeg

Beim Löten sollte man sich konzentrieren, denn wenn Teile falsch positioniert sind wird es mühsam, diese wieder zu entfernen.

Muscle SpikerShield

Musclespiker.jpeg

Auf diesem Foto sieht man den Versuchsaufbau. Die Elektroden greifen das Signal am Muskel ab und leiten es auf das Board weiter. Im Board wird das signal verstärkt. Die Intensität wird dann mithilfe der LED`s angezeigt.

Resultat

Nachdem das Board RICHTIG gelötet wurde ging alles ohne weitere Probleme. Die LED haben die Intensität des Signals pflichtbewusst angezeigt. Wichtig ist die Positionierung der Elektroden, wenn diese falsch positioniert wurden, ist die Weiterleitung nicht gewärleistet.

Code

#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 - CO2 Detector mit LCD

In diesem Projekt geht es darum einen CO2 Detektor zu bauen, welcher den CO2 Gehalt in der Luft in ppm (parts per million) anzeigen soll. Zudem soll visuell angezeigt werden, ob der Wert im Normalbereich liegt oder zu hoch ist. Da der hierzu verwendete Sensor ebenfalls die Luftfeuchtigkeit und Temperatur messen kann, werden diese Werte auch angezeigt. Nachfolgen findest man alle Informationen sowie den Code um das Projekt "CO2 Detector mit LCD" selbst umzusetzen.

Material

  • Arduino UNO
  • LCD-Display
  • Holz für Gehäuse
  • CO2-Sensor
  • Breadboard
  • Zwei LEDs
  • 9V Batterie
  • Stiftleisten
  • Steckerkabel
  • Schalter
  • Widerstände
  • Potenziometer

Gehäuse: File:co2-Messgerät-Gehäuse.svg

Planung und Durchführung

Sensirion SCD41 Co2 Sensor

Da wir vor Ort den Sensirion SCD41 CO2 Sensor zur Verfügung hatten, haben wir diesen verwendet. Der Sensor zeichnet sich durch eine Hohe Genauigkeit aus.

Eigenschaften:

  • Photoacoustic sensor
  • Temperatur
  • Luftfeuchtigkeit
  • CO2 Gehalt
  • High accuracy, specified range 400 – 5’000 ppm
  • Ca. 60$

Weiterführende Infos zum Messprinzip findet man hier: Sensirion SCD41 Messprinzip

Verkabeln

Hier sieht man die Verkabelung vom LCD 1602 zusammen mit einem 10k Ohm Poti für das einstellen der Lichtstärke des LCDs und einen 220 Ohm Widerstand.


Verdrahtung LCD.PNG


Da der Sensor über I2C kommuniziert wurde er wie folgt angeschlossen:

  • VDD an 3.3V
  • GND an GND
  • SCL an Pin D19
  • SDA an Pin D18

Die LEDs wurden mit jeweils einem 220 Ohm Vorwiderstand auf Pin 6 (grün) und Pin 7 (rot) gelegt.

Der Schalter wurde seriell in den Batterie Kreislauf geschalten.

Code

Nachfolgend findet man den Code zum Projekt. Der Grenzwert für den Normalbereich wurde auf 1399 gesetzt. Dieser kann natürlich auch nach eigenem bedarf abgeändert werden.

C02_Sensor_mit_LCD

/*Co2 Detector made my Team Auslöten */

#include <Arduino.h>
#include <SensirionI2CScd4x.h>
#include <Wire.h>
#include <LiquidCrystal.h>
#include "LED.h"

#define LED_GREEN  6
#define LED_RED  7

SensirionI2CScd4x scd4x;
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
LED ledG(LED_GREEN);
LED ledR(LED_RED);

void printUint16Hex(uint16_t value) {
    Serial.print(value < 4096 ? "0" : "");
    Serial.print(value < 256 ? "0" : "");
    Serial.print(value < 16 ? "0" : "");
    Serial.print(value, HEX);
}

void printSerialNumber(uint16_t serial0, uint16_t serial1, uint16_t serial2) {
    Serial.print("Serial: 0x");
    printUint16Hex(serial0);
    printUint16Hex(serial1);
    printUint16Hex(serial2);
    Serial.println();
}

void setup() {

    Serial.begin(115200);
    lcd.begin(16, 2);
    lcd.print("Co2 Detector");
    while (!Serial) {
        delay(100);
    }

    Wire.begin();

    uint16_t error;
    char errorMessage[256];

    scd4x.begin(Wire);

    // stop potentially previously started measurement
    error = scd4x.stopPeriodicMeasurement();
    if (error) {
        Serial.print("Error trying to execute stopPeriodicMeasurement(): ");
        errorToString(error, errorMessage, 256);
        Serial.println(errorMessage);
    }

    uint16_t serial0;
    uint16_t serial1;
    uint16_t serial2;
    error = scd4x.getSerialNumber(serial0, serial1, serial2);
    if (error) {
        Serial.print("Error trying to execute getSerialNumber(): ");
        errorToString(error, errorMessage, 256);
        Serial.println(errorMessage);
    } else {
        printSerialNumber(serial0, serial1, serial2);
    }

    // Start Measurement
    error = scd4x.startPeriodicMeasurement();
    if (error) {
        Serial.print("Error trying to execute startPeriodicMeasurement(): ");
        errorToString(error, errorMessage, 256);
        Serial.println(errorMessage);
    }

    Serial.println("Waiting for first measurement... (5 sec)");
}

void loop() {
    uint16_t error;
    char errorMessage[256];

    delay(5000);

    // Read Measurement
    uint16_t co2;
    float temperature;
    float humidity;
    error = scd4x.readMeasurement(co2, temperature, humidity);
    lcd.clear();
    if (error) {
        Serial.print("Error trying to execute readMeasurement(): ");
        errorToString(error, errorMessage, 256);
        Serial.println(errorMessage);
        lcd.print("Error");
    } else if (co2 == 0) {
        Serial.println("Invalid sample detected, skipping.");
        lcd.print("Error");
    } else {
        lcd.setCursor(0,0);         //setCursor(col, row)
        lcd.print("Co2: ");
        lcd.print(co2);
        Serial.print(" Co2: ");
        Serial.print(co2);
        Serial.print("\t");
        Serial.print("Temperature:");
        Serial.print(temperature);
        lcd.setCursor(0,1);         //setCursor(col, row)
        lcd.print("Temp: ");
        lcd.print(temperature);
        Serial.print("\t");
        Serial.print("Hum: ");
        Serial.println(humidity);
        lcd.setCursor(9,0);         //setCursor(col, row)
        lcd.print("Hum: ");
        lcd.print(humidity);
        if (co2 < 1399) {           //<----------------GRENZWERT
          ledG.on();
          ledR.off();
        } else {
        ledG.off();
        ledR.on();
        } 
    }
}

LED.cpp

#include "LED.h"

LED::LED(const int pin) : Switchable(pin){
  
}

LED.h

#ifndef RGBLED_H
#define RGBLED_H

#include "Switchable.h"

class LED : public Switchable
{
  public:
    LED(const int pin);
};

#endif //__LED_H

Switchable.cpp

#include "Switchable.h"
#include <Arduino.h>

Switchable::Switchable(const int pin) : m_pin(pin)
{
    // Set pin as output
    pinMode(m_pin, OUTPUT);
    // Start state if off
  off();
}

//turn on:
void Switchable::on()
{
  digitalWrite(m_pin, 1); //high
  m_state = true;
}

//turn off:
void Switchable::off()
{
  digitalWrite(m_pin, 0); //low
  m_state = false;
}

void Switchable::toggle()
{
  digitalWrite(m_pin, !m_state); //low
  m_state = !m_state;
}

// dim pin
void Switchable::dim(int dimVal)
{
    analogWrite(m_pin, dimVal);
}
    
bool Switchable::getState()
{
    return m_state;
}

void Switchable::setState(bool state)
{
    digitalWrite(m_pin, state);
    m_state = state;
}

Switchable.h

#ifndef _SWITCHABLE_H_
#define _SWITCHABLE_H_

//Base class for output that can be switched on/off via single digital pin:
class Switchable  
{
  public:

    // Consturcutor accepts pin number for output
      Switchable(const int pin);
    
    // Turn pin on
    void on();
      
      // Turn pin off
    void off();
    
    // Toggle pin
    void toggle();
    
    // dim pin
    void dim(int dimVal);
    
    // Get current state
    bool getState();
    
    // Set state with bool variable
    void setState(bool state);
  
  private:
  
    const int m_pin;  //output pin
    bool m_state;   //current state
};

#endif // _SWITCHABLE_H_
 

Resultat

Rückschläge gehören auch dazu, eines davon ist die Vorderseite der Hülle. Beim ersten Versuch haben wir keine Löcher für die LED's und den Sensor eingeplant. Beim zweiten Versuch war der Fehler, eine Einstellung vor dem Lasern. Beim dritten Versuch war alles ausser den Augen vom Totenkopf gut. Da hätten wir zwei Linien für die Augen machen müssen, das haben wir dann schlussendlich nicht mehr korrigiert. Das Messen funktioniert, somit das wichtigste am Laufen.

Vorn1.jpeg

So sieht das fertige Projekt aus.

Bild1.PNG

Recherche für weitere Projekte

Drawbot (Hack 2)

Kurzbeschreibung

Der Drawbot braucht für den Antrieb zwei 42 Schrittmotoren und einen Servo, dazu braucht er noch ein Arduino. Die Teile können mit dem 3D-Drucker gedruckt werden. Ziel respektive Funktion von diesem Drawbot ist das Schreiben und Zeichnen. Da wir keine passenden Riemen gefunden haben, war hier die Ausführung schwer und auch zeitlich ein wenig knapp. Deshalb haben wir 2 kleine Hacks gemacht, welche noch vorgestellt werden.

Youtube Video, wie es aussehen könnte:

Für weitere Informationen zum Hack hier zum Link. Drawbot

Krawatte

Kurzbeschreibung

Da uns der Lasercutter und dessen Fertigungsprozess interessiert hat, haben wir nach verschiedene Objekte gesucht. Bei der Suche haben wir diese Krawatte (Bild unten) gefunden und haben diese gelasert. Faszinierend wie das Material, welches einst stabil und fest war zu so beweglich verändert werden konnte.

Krawatte2.jpeg

Stoppuhr

Kurzbeschreibung

Für die Stoppuhr haben wir ein Arduino, eine vierstellige Sieben-Segment-Anzeige, zwei Taster und ein Breadboard gebraucht. Dieses Hack brauchte nicht viele Komponente, daher haben wir diese auch einfach gefunden und konnten es durchführen. Die Funktion ist ziemlich einfach. Zuerst zeigt die Stoppuhr einfach nur vier Nullen an. Wenn der Start-Taster gedrückt wird, fängt die Segmentanzeige an, Sekunden hochzuzählen. Drückt man den Zwischenzeit-Taster, stoppt die Zeit auf dem Display. Im Hintergrund wird aber weitergezählt. Ein erneuter Druck auf den Zwischenzeit-Taster zeigt wieder die aktuell laufende Zeit an. Drückt man den Start-Taster, stoppt die Uhr sowohl im Display, als auch im Hintergrund. Nun kann man die Uhr entweder per Druck auf den Zwischenzeit-Taster weiterlaufen lassen oder durch erneuten Druck auf den Start-Taster auf Null zurücksetzen. Diese Stoppuhr könnte man nun vertiefen in einen weiteren Hack.


Stoppuhr2.jpeg

Code


#include <TM1637Display.h>

#define numberOfSeconds(_time_) ((_time_ / 1000) % 60)
#define numberOfMinutes(_time_) (((_time_ / 1000) / 60) % 60)

int startPin = 9; // start, stop, delete
int zwischenzeitPin = 8; // pause, continue

int stateStart;
int stateZwischenzeit;

int lastStateStart;
int lastStateZwischenzeit;

int programState = 0;

unsigned long startZeit = 0;
long zwischenzeit = 0;
long zeitAngehalten = 0;

TM1637Display display(2, 3);

void setup() {
  Serial.begin(115200);

  pinMode(startPin, INPUT_PULLUP);
  pinMode(zwischenzeitPin, INPUT_PULLUP);

  // Set brightness
  display.setBrightness(0x0c);

}

void showTime(long theTime) {

  unsigned long myTime = theTime - startZeit;

  int seconds = numberOfSeconds(myTime);
  int minutes = numberOfMinutes(myTime);

  display.showNumberDecEx(seconds, 0, true, 2, 2);
  if (seconds % 2 == 0) {
    display.showNumberDecEx(minutes, 0b01000000, true, 2, 0);
  } else {
    display.showNumberDecEx(minutes, 0, true, 2, 0);
  }
}

void loop() {

  stateStart = digitalRead(startPin);
  stateZwischenzeit = digitalRead(zwischenzeitPin);

  switch (programState) {
    case 0: // gestoppt
      startZeit = 0;
      display.showNumberDecEx(0, 0b01000000, true, 2, 2);
      display.showNumberDecEx(0, 0b01000000, true, 2, 0);
      // start
      if ((stateStart == LOW) && (stateStart != lastStateStart)) {
        startZeit = millis();
        programState = 1;
      }
      break;
    case 1: // gestartet
      showTime(millis());
      // zwischenzeit
      if ((stateZwischenzeit == LOW) && (stateZwischenzeit != lastStateZwischenzeit)) {
        zwischenzeit = millis();
        programState = 2;
      }
      // stop
      if ((stateStart == LOW) && (stateStart != lastStateStart)) {
        zeitAngehalten = millis();
        programState = 3;
      }
      break;
    case 2: // zwischenzeit
      showTime(zwischenzeit);
      // zwischenzeit ausblenden
      if ((stateZwischenzeit == LOW) && (stateZwischenzeit != lastStateZwischenzeit)) {
        programState = 1;
      }
      break;
    case 3: // gestoppt
      // weiter laufen lassen
      if ((stateZwischenzeit == LOW) && (stateZwischenzeit != lastStateZwischenzeit)) {
        startZeit = startZeit + (millis() - zeitAngehalten);
        programState = 1;
      }
      // löschen
      if ((stateStart == LOW) && (stateStart != lastStateStart)) {
        programState = 0;
      }
      break;
  }

  lastStateStart = stateStart;
  lastStateZwischenzeit = stateZwischenzeit;

}

Wearable Heart Rate Monitor

Kurzbeschreibung

Zu einem drahtlosen Herzfrequenzmesser am Handgelenk haben wir eine Recherche durchgeführt, aber hatten nicht alle Komponenten vor Ort. Für diesen Hack hätten wir die Komponenten uECG, Arduino nano, nRF24-Chip, Batterie und LED-Ring gebraucht. uECG misst die Daten und berechnet die BPM. Im Direktverbindungsmodus sendet es alle Informationen (ECG-Daten) über ein Funkprotokoll, das mit dem generischen nRF24-Chip kompartibel ist. Die Verwendung von einem Arduino nano ist sehr praktisch, da es genau unter den LED-Ring passt.

Bildschirmfoto 2021-09-17 um 22.52.01.png

Youtube Video, wie es aussehen könnte:

Code

Die Software kann auf der folgenden Seite heruntergeladen werden. Heart-rate-monitor

Car

Kurzbeschreibung

Street racing car ist ein Projekt, welches in einer Woche gut durchgeführt werden kann. Die meisten Teile können mit dem 3D-Drucker hergestellt werden. Diesen Hack haben wir erst in einer späteren Recherche gefunden, daher konnte dieser Hack auf Grund der Zeit nicht durchgeführt werden.


Bildschirmfoto 2021-09-17 um 23.22.09.png

Reflexion

Die Gruppe Auslöten hat während der Blockwoche "Medizintechnik DIY" einen funktionsfähigen CO2 Detektor entwickelt. Die "Anleitung" dazu findet ihr auf unserer Gruppen Homepage und kann ganz einfach nachgebaut werden. Wir haben ebenfalls für weitere Projekte recherchiert, welche ihr bei uns auf der Homepage findet. Die Blockwoche hat uns allen sehr gut gefallen. Wir konnten unsere Ideen durch die freie Arbeitsweise gut umsetzen und einiges neues dazu lernen. Vor allem das Lasercutten war für alle etwas neues. Zu dem lernten wir auch noch mehr über die DIY Kultur und werden in Zukunft versuchen unser Wissen so weiter zugeben. Denn nur wenn man Wissen teilt, verdoppelt es sich!

Präsentation

File:Gruppe A.pdf