Herzschlag-Sensor ansteuern

(English version) Wenn man bei ebay nach "heartbeat sensor" sucht, findet man eine kleine Platine, welche mit LED und Phototransistor bestückt ist, welche angeblich den Herzschlag messen kann. Ich habe mir so ein Teil gekauft und es ausprobiert. Leider gibt es sehr wenig (ok, gar keine) Dokumentation dazu und nichtmal eine Seriennummer, alles was ich weiß ist das auf meinem Sensor xinda und Lcup drauf steht.

Der Herzschlag-Sensor

Der Sensor hat 3 Anschlüsse welche auch sehr toll beschriftet sind. Einer mit -, das ist der Anschluss für GND. Der nächste Anschluss hat ein S, das steht für Sensor, hier wird der Phototransistor ausgelesen. Dann gibt es noch den Pin in der Mitte ohne Beschriftung, das ist der Pin für die LED. Beschaltet wird der Chip ganz einfach: +5V an die LED und den Sensor-Ausgang an einen Analog-Eingang des Arduinos.

Das Programm liest nun praktisch den Sensor-Wert und sendet diesen über die serielle Schnittstelle an den Computer wo die Daten weiterverarbeitet werden können (z.B. mit Matlab, darüber werde ich vielleicht im nächsten Post etwas schreiben). Hier ist ein Bild von den geplotteten Daten mit Matlab und darunter der Code für den Arduino.

//Define pins for LED and sensor.
int ledPin = 13;
int sensorPin = 0;
//alpha is used in the original proposed code by the company (see below).
double alpha = 0.75;
//lasttime is used to have a very precise measurement of the time so the calculated pulse is correct.
unsigned long lasttime;

void setup ()
{
  //Switch on the LED.
  pinMode (ledPin, OUTPUT);
  digitalWrite(ledPin,HIGH);
  Serial.begin (9600);
  lasttime = micros();
}

void loop ()
{
  //Also used for smoothening the signal.
  static double oldValue = 0;
  
  //Wait 10 ms between each measurement.
  while(micros() - lasttime < 10000)
  {
    delayMicroseconds(100);
  }
  
  //Read the signal.
  int rawValue = analogRead (sensorPin);
  lasttime += 10000;
  
  //In the "original" code example, "value" was sent to the computer. This calculation basically smoothens "rawValue".
  //double value = alpha * oldValue + (1 - alpha) * rawValue;
  
  //Send back the measured value.
  Serial.println (rawValue);
  oldValue = value;
}

Eine Spieltisch für Tabletops

(English version) Für Tabletop-Spiele benötigt man natürlich eine Unterlage auf der man spielen kann. Für den Anfang reicht ein kleiner Tisch oder auch der Boden, wer aber große Schlachten austragen will braucht dann etwas größeres. Die standard-Größe bei Tabletop-Tischen für 28 mm Tabletops ist etwa 6 x 4 Fuß, das entspricht etwa 183 x 122 cm. So ein Tisch ist ziemlich groß und nimmt viel Platz weg, wenn man nur eine kleine Wohnung hat ist das dann nicht mehr so einfach möglich da mit so einem großen Tisch bereits ein ganzer Raum in Anspruch genommen wird. Daher habe ich einen Tisch gebaut, welchen man in 2 Minuten auf- und abbauen kann.

Die Grundidee ist simpel: Auf einen bestehenden Couch-Tisch wird eine große Holzplatte gelegt. Da mein Couch-Tisch nur 110 x 70 cm groß ist würde eine Platte der Größe 183 x 122 cm herunterhängen. Also benötigt der Spieltisch auch noch Füße. Das Ergebnis besteht nun aus zwei Platten der Größe 183 x 61 cm, welche man zusammenstecken kann. Eine Seite des Spielfeldes wird dann auf den Couch-Tisch gelegt, unter dem anderen Ende sind 2 Füße angebracht. Ich will nun auf die einzelnen Teile eingehen.

Der komplette Tisch.

Die Platten
Für die Platten habe ich eine 8 mm starke Spanplatte benutzt. Eine dickere Platte ist natürlich generell stabiler und verbiegt sich nicht so stark, jedoch erhöht sich dabei auch das Gewicht und der Preis. 8 mm funktionieren bei mir ziemlich gut, auf den Tisch sollte man sich jedoch nicht setzen.

Die Füße
Am Ende jeder Platte ist ein Fuß über ein Scharnier befestigt. Wird der Tisch weggeräumt, so klappt man den Fuß ein und er nimmt nicht übermäßig Platz weg. Für den ausgeklappten Zustand ist noch die Befestigung mit einem Spannverschluss geplant, davon kann ich allerdings keine Bilder zeigen, da ich noch auf den Artikel warte. Die Scharniere gibt es in jedem Baumarkt billig zu kaufen, ebenso das Holz für die Tischbeine.

Die Befestigung des Tischbeines.

Das Zusammenstecken
Beim Obi gibt es spezielle Schranktür-Verschlüsse, welche man einfach ineinander stecken kann. Diese habe ich an die beiden Platten gebaut sodass die Platten ineinander gesteckt werden können.

Die Steckverbindung zwischen den Platten.

Positionierung auf dem Couchtisch
Am Ende habe ich noch kleine Holzblöcke unten an die Platten geklebt, sodass der Tisch sich nicht mehr bewegen kann, und perfekt auf dem Couch-Tisch sitzt.

Links im Bild der Couch-Tisch mit dem Holzblock unten an der Tischplatte.

Auf dem Tisch kann nun das Gelände verteilt werden oder eine Grasmatte ausgebreitet werden. Alternativ könnte man die Platten auch mit Gras bedecken oder einem farbigen Stoff, oder, wenn man es ganz simpel halten will, einfach in einer Farbe anmalen, das könnte z.B. für große Wasserflächen praktisch werden.

Arduino - Keypad auslesen

(English version) Heute möchte ich kurz vorstellen wie man ein simples Keypad, wie im folgenden Bild zu sehen, mit dem Arduino auslesen kann. Man könnte dazu z.B. dieses hier von ebay nehmen: Keypad.

Das Keypad hat 8 Anschlüsse. Jeweils 4 sind dabei für die Zeilen bzw. Spalten. Ein Tastendruck verbindet nun zwei dieser Anschlüsse. 4 Anschlüsse werden am Arduino als Output genutzt, die anderen 4 als Input. Ich habe Pin 22, 24, 26 und 28 als Output benutzt und 30, 32, 34, 36 als Input, man kann das Display dadurch sehr einfach anschließen, indem man eine Stiftleiste benutzt.
Nun legt man nacheinander an jeden Output eine Spannung an und misst dabei, welcher Input diese Spannung abbekommt. Dadurch weiß man sofort welche Tasten gedrückt wurden. Mein Code liest die Tasten aus und sendet, sobald sich der Status einer Taste geändert hat, dies über die serielle Schnittstelle an den Computer.

//For different sizes of Keypads, you can adjust the numbers here. Important: Also change the keyValues array!
const int numOuts = 4;
const int numIns = 4;
//These are the 4 output pins, adjust it if you use a different pin mapping
int outs[numOuts] = {22, 24, 26, 28};
//These are the 4 input pins, adjust it if you use a different pin mapping
int ins[numIns] = {30, 32, 34, 36};
//This array contains the values printed to the different keys
char keyValues[numOuts][numIns] = {{'1','2','3','A'},{'4','5','6','B'},{'7','8','9','C'},{'*','0','#','D'}};
//This array contains whether a pin is pressed or not
boolean pressed[numOuts][numIns];

void setup() {  
  Serial.begin(9600);
  //Define all outputs and set them to high
  for (int i = 0; i < numOuts; i++)
  {
    pinMode(outs[i], OUTPUT);
    digitalWrite(outs[i], HIGH);
  }
  //Define all inputs and activate the internal pullup resistor
  for (int i = 0; i < numIns; i++)
  {
    pinMode(ins[i], INPUT);
    digitalWrite(ins[i], HIGH);
  }
}

//Read whether a key is pressed
void KeyPressed()
{
  for (int i = 0; i < numOuts; i++)
  {
    //Activate (set to LOW) one output after another
    digitalWrite(outs[i], LOW);
    //Wait a short time
    delay(10);
    for (int j = 0; j < numIns; j++)
    {
      //Now read every input and invert it (HIGH = key not pressed (internal pullup), LOW = key pressed (because the output was set to LOW)
      boolean val = !digitalRead(ins[j]);
      //If the value changed, send via serial to the computer and save the value in the "pressed" array
      if (pressed[i][j] != val)
      {
        char str[255];
        sprintf(str, "%c pressed: %d", keyValues[i][j], val);
        Serial.println(str);
        pressed[i][j] = val;
      }
      
    }
    //Deactivate (set back to HIGH) the output
    digitalWrite(outs[i], HIGH);
  }
}

//Yeah, do this forever...
void loop()
{
  KeyPressed();
}