AdSense

Sonntag, 14. Dezember 2014

Arduino - Barometrischen Höhensensor GY-65 auslesen

(English version) Eine weit verbreitete Möglichkeit, relative Höhen zu messen ist das Benutzen eines barometrischen Höhensensors. Dieser misst einfach den Druck und aus der barometrischen Höhenformel (Wikipedia) lässt sich daraus eine Höhe bestimmen. Da der Luftdruck sehr stark vom Tag abhängt wird normalerweise an einer bekannten Höhe der Sensor kalibriert und dann die restlichen Höhen relativ zu dieser Höhe und dem dort gemessenen Druck berechnet. Das liefert Höhen mit einer Genauigkeit von bis zu 1 Meter.

Wenn man bei ebay nach GY-65 sucht, findet man den entsprechenden Sensor für ca. 5 Euro. Der Sensor hat ein normales I2C-Interface, sodass nur 2 Kabel nötig sind. Für den Arduino braucht man dann die I2Cdev Library, die gibt es hier zum runterladen. Der Quellcode an sich ist maximal simpel, zuerst wird der Sensor initialisiert, dann wird eingestellt, dass der Druck gemessen werden soll und anschließen der Druck ausgelesen und daraus die Höhe berechnet. Ein komplettes, simples Beispielprogramm sieht so aus:


#include <I2Cdev.h>
#include "BMP085.h"
#include <Wire.h>

BMP085 barometer;

double pressure;
double altitude;


void setup() {
  Wire.begin();
  
  Serial.begin(9600);
  Serial.println("starting...");
    
  //initialize the barometer
  barometer.initialize();
}

void loop()
{
  // request pressure (3x oversampling mode, high detail, 23.5ms delay).
  // Let's just wait a bit more to be sure...
  barometer.setControl(BMP085_MODE_PRESSURE_3);
  delay(30);
  // read calibrated pressure value in Pascals (Pa)
  pressure = barometer.getPressure();
  // calculate absolute altitude in meters based on known pressure
  // (may pass a second "sea level pressure" parameter here,
  // otherwise uses the standard value of 101325 Pa)
  altitude = barometer.getAltitude(pressure); 
  
  // print back the calculated altitude
  Serial.println(altitude);
  // do this every second
  delay(1000);
}

I2C OLED Display

(english version) Wer bei Ebay nach "Arduino OLED Display" sucht, stößt auf ein OLED-Display mit einer Bildschirmdiagonale von ca. 1 Zoll und einer Auflösung von 128x84 Pixel. Das Display ist für weniger als 4 Euro zu haben. Angesteuert wird es über I2C. 1 Zoll ist natürlich nicht viel, aus Interesse habe ich mir das Display aber dennoch bestellt. Damit man sich vorstellen kann, wie klein es wirklich ist, habe ich eine Münze zum Vergleich daneben gelegt:

Dank Ansteuerung über I2C ist die Verkabelung denkbar übersichtlich: neben der Spannungsversorgung sind nur zwei Kabel für den I2C-Bus nötig, das wars. Nun stellt sich natürlich die Frage: wie steuere ich das Ding an? Nach kurzer Recherche habe ich heraus gefunden, dass es sich bei dem Display um einen Nachbau des OLED-Displays mit der Bezeichnung SSD1306 von Adafruit handelt. Dafür bietet Adafruit eine fertige Arduino-Library an, welche HIER erhältlich ist. Außerdem muss die Adafruit-GFX-Library herunter geladen und installiert werden. In der Arduino IDE findet sich dann unter "Adafruit_SSD1306" das Beispiel "ssd1306_128x64_i2c". Wer dieses Beispiel nun einfach so 1:1 auf den Arduino überträgt sieht erstmal: gar nichts. Das China-Display hat eine andere I2C-Adresse wie das Original von Adafruit, daher muss in der setup()-Funktion eine kleine Änderung durchgeführt werden: die Adresse muss von 0x3D in 0x3C geändert werden. Aus
  display.begin(SSD1306_SWITCHCAPVCC, 0x3D);  // initialize with the I2C addr 0x3D (for the 128x64)
wird
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x64).
Dann dann kann das Beispiel auf den Arduino übertragen werden. Ihr solltet jetzt eine kleine Demonstration der verschiedenen Funktionen der GFX-Library auf dem Display sehen. Da die Funktionen und somit auch das Beispiel sehr umfangreich sind, werde ich sie nicht im Detail erläutern. Im Prinzip sind die Funktionen im Beispiel alle selbsterklärend. Bei Unklarheiten schaut in die Header-Datei der GFX-Library, dort ist auch erläutert, welche Parameter die einzelnen Funktionen erwarten. Es gibt die Möglichkeit Text auszugeben, außerdem lassen sich Linien und diverse Formen (Rechteck, Dreieck, ...) mit und ohne Füllung zeichnen. Auch das Invertieren des Bildschirms sowie das Scrollen sind möglich.

Außerdem kann ein vordefiniertes Bitmap ausgegeben werden. Dies möchte ich kurz näher erklären:

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

#define XPOS 50
#define YPOS 25
#define BITMAP_HEIGHT 16 
#define BITMAP_WIDTH  16 
static const unsigned char PROGMEM bitmap[] =
{ B00000001, B10000000,
  B00000010, B01000000,
  B00000100, B00100000,
  B00001000, B00010000,
  B00010000, B00001000,
  B00111111, B11111100,
  B00101000, B00010100,
  B00100100, B00100100,
  B00100010, B01000100,
  B00100001, B10000100,
  B00100010, B01000100,
  B00100100, B00100100,
  B00101000, B00010100,
  B00110000, B00001100,
  B00111111, B11111100,
  B00000000, B00000000 };

void setup()   {                

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x64)
  
  //clear display buffer
  display.clearDisplay();
  //draw a bitmap stored in variable bitmap with given size at XPOS, YPOS in color white
  display.drawBitmap(XPOS, YPOS, bitmap, BITMAP_WIDTH, BITMAP_HEIGHT, WHITE);
  display.display();
 
}


void loop() { 
}

In diesem Beispiel zeichnen wir ein Bitmap mit einer Größe von 16x16 Pixeln. Die Größe des Bitmaps kann natürlich angepasst werden. Das Bitmap muss in einem Character-Array hinterlegt sein. Besonders wichtig ist hier bei der Deklaration das Schlüsselwort "PROGMEM". Es sorgt dafür, dass die Variable im Flash-Speicher des Arduinos abgelegt wird. Dies wird von der Library so erwartet. Im Beispiel speichern immer jeweils zwei Character in insgesamt 16 Bit den Inhalt einer Zeile. Ist ein Bit gesetzt, wird beim später Zeichnen ein Pixel gesetzt. Der Übersicht halber habe ich im Code Zeilenumbrüche eingefügt. Eine Zeile im Code entspricht nachher eine Zeile des Bitmaps. Zur Darstellung des Bitmaps wird dann der Befehl drawBitmap() aufgerufen. Als Parameter werden übergeben: die X- und Y-Position des Bitmaps, die Variable, in der das Bitmap gespeichert ist, die Breite und die Höhe des Bitmaps sowie die Farbe (WHITE oder BLACK), in der ein gesetzter Pixel dargestellt werden soll.
Das Ergebnis:

Freitag, 5. Dezember 2014

Einen Pinsel wieder anspitzen

(English version) Ein neu gekaufter Pinsel ist normalerweise sehr spitz und auch etwas hart, sodass man damit sehr gut feine Linien malen kann. Nach einer Weile fangen die Häärchen aber an, in alle Richtungen abzustehen, sodass man den Pinsel eigentlich nicht mehr benutzen kann. Um den Pinsel wieder so spitz wie am Anfang zu bekommen kann man einen ganz einfachen Trick benutzen.
Ein benutzer Pinsel mit welchem keine feinen Malarbeiten mehr möglich sind.
Zuerst wird Zuckerwasser hergestellt. Einfach Wasser und Zucker mischen und gut umrühren. Danach wird der Pinsel in die Lösung getaucht. Die Oberflächenspannung hält die Pinselhaare dann schon grob zusammen.
Pinselspitze mit Zuckerlösung. Die Haare werden von alleine zusammengehalten (Oberflächenspannung).
Um den Pinsel jetzt perfekt spitz zu bekommen streicht man ihn sehr vorsichtig ab, dadurch wird er noch spitzer. Wenn man ihn jetzt noch trocknen lässt bildet sich wieder die Spitze wie bei einem neu gekauften Pinsel. Ich benutze Pinsel der Größe 00, die gibt es meistens ganz billig (1 €) in jedem Spielwarenhandel. Wenn man den Pinsel dann entsprechend pflegt bleibt die Spitze auch so perfekt und man kann ihn nahezu unendlich lange benutzen.
Der wieder spitze Pinsel.