Grafik-Display‎ > ‎

5 Projekte

http://sites.prenninger.com/arduino-uno-r3/grafik-display-1/5-projekte

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2016-06-12

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************

Untergeordnete Seiten (4):

1 Grafik-Display
2 Display-Grundlagen
3 TextDisplay

4 GrafikDisplay
5 Projekte



Kopieren Sie den im Download enthaltenen Ordner namens DisplayBeispiele komplett in Ihren ARDUINO-Sketch-Ordner.
Diesen finden Sie unter Windows standardmäßig unter
C:\Benutzer\fritz\Dokumente\Arduino\DisplayBeispiele\Projekte\proportionalFont\proportionalFont.ino

Wenn Sie nun die Arduino-Oberfläche starten, finden Sie unter
MENU > Datei > Sketchbook > DisplayBeispiele > Projekte > proportionalFont.ino
In diesem Ordner finden Sie alle Programme unter dem entsprechenden Kapitelnamen.

Anleitung:
Grafik-Display auf ARDUINO UNO R3 aufstecken.
Mit USB Verbindungskabel mit PC verbinden.
Rechner > Geräte-Manager > Anschlüsse (COM & LPT) > Arduino Uno (COM5)

MENU > Datei > Voreinstellungen > Sketchbook-Speicherort: C:\User\fritz\Documents\Arduino\
MENU > Werkzeuge > Platine: "Arduino Uno"
MENU > Werkzeuge > Port: "COM5 (Arduino Uno)"
MENU > Datei > Sketchbook > DisplayBeispiele > Projekte > proportionalFont.ino
Hackerl = Verifizieren
Pfeil = Hochladen

ORDNER Starter    |  Starter.ino  |  Display.cpp  |  Display.h  |  Font.h  | 




Autor:
Tomas Baum  TINY.Systems
Espenstraße 135
D-66346 Püttlingen
mailto:th.baum@online.de
Tel. +49 (0)6898 / 964296
http://tiny.systems/

http://tiny.systems/categorie/lcdProjekt/



1. ProportionaleFonts.zip
2. Zahlensysteme.zip
3. Lauflicht.zip
4. Advent.zip
5. Grayscale.zip
6. Seismograph.zip
7. BonsaiWatchdog.zip





*********************************************************
1. ProportionaleFonts

Proportional versus Monospace

Die Typografie unterscheidet zwischen proportionalen Schriftarten (variable Breite) und Schiftarten mit fester Breite (monospace).
Das Lernpaket beschäftigt sich nur mit Schriftarten fester Breite.
Wie aber geht man an die Sache heran wenn man eine proportionale Darstellung von Texten auf einem Display abbilden möchte?


Darstellungsarten bei Schriften


Mehrere Lösungswege
Prinzipiell gibt es zwei Herangehensweisen.
Die erste setzt voraus, dass bereits in der Font-Datei selbst die Informationen über die Zeichenbreite enthalten sind.
So wird hier neben der Bildinformation zusätzlich die Breite hinterlegt.
Die Zeichenfunktion wertet diese Information aus und kann so Zeichen variabler Breite ausgeben.

Hier ein Beispiel:
0x03, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00,  // Code for char i
                    
Jedes Zeichen hat für die Darstellung eine maximale Breite von 5 Pixel.
Das erste Byte (3) zeigt an, dass nur die ersten drei Bytes gezeichnet werden sollen. (0x00, 0x7D, 0x00)

Lösung mit minimalem Aufwand
Die zweite Möglichkeit ist, einen bestehenden Font mit fester Breite bei der Darstellung auf seine sichtbaren Bereiche zu reduzieren.
Die Zeichenfunktion erkennt leere Bereiche und überspringt sie einfach.
Dazu sind folgende Änderungen im Code nötig.

void Display::drawString(byte x, byte y, const char *c, boolean proportional) {
  if(y > HEIGHT) {
    return;
  }
  byte page = y/8;
  do {
    char character = c[0];
    if (! character)
      return;
      
    for (byte i=0; i<CHARACTER_WIDTH; i++ ) {
      word charBuffer = pgm_read_byte(font7x5+(character*6)+i) << y%8;
      if (proportional && charBuffer == 0) {
        continue;
      }
      videoBuffer[x+(page*WIDTH)] |= charBuffer;
      videoBuffer[x+(WIDTH*(page+1))] |= charBuffer >> 8;
      x++;
    }   
    if (proportional) {
      x=x+1;
      if (character == ' ') {
      x++;
      } 
    }
  } 
  while (c++);
}
Leere Stellen "charBuffer == 0" werden mit einem "continue" übersprungen.
Zusätzlich wird nach jedem Zeichen ein Abstand mit der Breite von einem Pixel eingefügt (x=x+1).
Bei einem Leerzeichen wird auf zwei Pixel erhöht (x++).
Darstellungsart auswählen
Die Darstellungsart wird einfach über einen weiteren Übergabeparameter (boolean proportional) beim Aufruf der Funktion gewählt. "1" zeigt eine proportionale Darstellung an. "0" ergibt eine Darstellung in fester Breite.
Der Code für die oben gezeigte Anwendung sieht folgendermaßen aus:

MENU > Datei > Voreinstellungen > Sketchbook-Speicherort: C:\User\fritz\Documents\Arduino\
MENU > Werkzeuge > Platine: "Arduino Uno"
MENU > Werkzeuge > Port: "COM5 (Arduino Uno)"
MENU > Datei > Sketchbook > DisplayBeispiele > Projekte > proportionalFont.ino
Hackerl = Verifizieren
Pfeil = Hochladen

ORDNER proportionalFont    |  proportionalFont.ino  |  Display.cpp  |  Display.h  |  Font.h  | 

#include "Display.h"
#include "SPI.h"

Display lcd = Display();

void setup() {
  lcd.init(20);
  lcd.clearVideoBuffer();
  lcd.drawString(0, 0, "Proportional", 1);
  lcd.drawString(50, 8, "vs. MONOSPACE", 0);
  lcd.drawString(0, 40, "Lorem ipsum dolor sit", 1);
  lcd.drawString(0, 55, "Lorem ipsum dolor sit", 0);
  lcd.show();
}

void loop() {
}
C:\Users\fritz\Desktop\Grafik-Display\proportionalFont.zip


Quelle:
http://tiny.systems/categorie/lcdProjekt/ProportionaleFonts.html




*********************************************************
2. Zahlensysteme  - binär auf dezimal und hexadezimal Umrechner

binär 01101001 = hexadezimal 69
Binär-Dezimal-Hexadezimal Umrechner
http://binaer-dezimal-hexadezimal-umrechner.miniwebapps.de/

Zahlensysteme - Display als Lernhilfe

Ob Ausbildung, Studium oder Hobby.
Ohne Grundlagen weiß man nur bedingt was man tut.
Am Anfang jeder Einführung in die Informatik stehen die Zahlensysteme.
Trotz trockener Mathematik kann man sich dem Thema auch praktisch nähern.
Oder zumindest ein Tool zur Überprüfung der Umrechnung programmieren.
Die folgende Anwendung stellt eine Erweiterung des Programms aus dem Artikel "Lauflicht" dar.
Die Darstellung und Formatierung der einzelnen Werte übernimmt die Funktion "sprintf" (siehe Anwendung "Metering" aus dem GrafikDisplay-Lernpaket)



Hexadezimal-Zahlensysteme auf dem ARDUINO UNO R3

Bedienung
Die Eingabe der Werte geht über die beiden Displaytasten.
Dabei werden wie bei einem Schieberegister die einzelnen Bits von rechts nach links ( < ) eingeschoben.
Eine
"1" mit der linken Taste und eine "0" mit der rechten Taste.


MENU > Datei > Voreinstellungen > Sketchbook-Speicherort: C:\User\fritz\Documents\Arduino\
MENU > Werkzeuge > Platine: "Arduino Uno"
MENU > Werkzeuge > Port: "COM5 (Arduino Uno)"
MENU > Datei > Sketchbook > DisplayBeispiele > Projekte > Zahlensysteme.ino
Hackerl = Verifizieren
Pfeil = Hochladen

ORDNER Zahlensysteme    |  Zahlensysteme.ino  |  Display.cpp  |  Display.h  |  Font.h  | 

#include "Display.h"
#include "SPI.h"

#define LCD_BUTTON_LEFT A4
#define LCD_BUTTON_RIGHT A5

const PROGMEM byte ledOn [] = {
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};
const PROGMEM byte ledOff [] = {
  0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF,
};

Display lcd = Display();
byte x = 0;

void setup() {
  lcd.init(20);
  pinMode(LCD_BUTTON_LEFT, INPUT_PULLUP);
  pinMode(LCD_BUTTON_RIGHT, INPUT_PULLUP);
  draw();
}

void loop() {
  if (!digitalRead(LCD_BUTTON_LEFT)) {
    x = x<<1;
    x = x | 0b00000001;
    draw();
    delay(200);
  } else if (!digitalRead(LCD_BUTTON_RIGHT)) {
    x = x<<1;
    draw();
    delay(200);
  }
}

void draw() {
  lcd.clearVideoBuffer();
  for (byte i=0; i<8; i++) {
    if (x & (1<<i)) {
      lcd.drawBitmap(120 - (i*16), 8, 8, 8, ledOn);
    } else {
      lcd.drawBitmap(120 - (i*16), 8, 8, 8, ledOff);
    }
  }
  char buffer[50]; 
  sprintf(buffer, "Dec: %03d ", x);
  lcd.drawString(8, 30, buffer);
  sprintf(buffer, "Hex: 0x%02X", x);
  lcd.drawString(8, 40, buffer); 
  lcd.show();
}



Quelle:
http://tiny.systems/categorie/lcdProjekt/Zahlensysteme.html






*********************************************************
3. Lauflicht

LCD-Lauflicht vom Kultauto K.I.T.T

Die Tage ist mir mein alter C64 im Keller aufgefallen. Am USER-Port hing noch eine selbstgebastelte 8-bit LED-Leiste.
Ich kann mich noch gut an das Projekt erinnern. Ich wollte unbedingt ein Lauflicht programmieren. Und zwar das von K.I.T.T.

         Virtuelles 8-bit LED Lauflicht- Experimente mit 8-bit

Neben einem Lauflicht lässt sich auch die Arbeitsweise eines Binärzählers besonders anschaulich mit ein paar Leuchtdioden darstellen.
In diesem Fall virtuell am Display.
Die Darstellung aller Bits der Variable x ist in einer Funktion ausgelagert und kann zur Veranschaulichung verschiedener bit-Operationen verwendet werden.
Die Anwendung vereint in diesem Fall drei Funktionen (bitte jeweils in der loop() auskommentieren).

MENU > Datei > Sketchbook > DisplayBeispiele > Projekte > Lauflicht.ino
Lauflicht, Binärzähler und manueller Zähler (steuerbar über die beiden Displaytasten).
ORDNER Lauflicht    |  Lauflicht.ino  |  Display.cpp  |  Display.h  |  Font.h  | 
#include "Display.h"
#include "SPI.h"

#define LCD_BUTTON_LEFT A4
#define LCD_BUTTON_RIGHT A5

const PROGMEM byte ledOn [] = {
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};
const PROGMEM byte ledOff [] = {
  0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF,
};

Display lcd = Display();
byte x = 0;

void setup() {
  lcd.init(20);
  pinMode(LCD_BUTTON_LEFT, INPUT_PULLUP);
  pinMode(LCD_BUTTON_RIGHT, INPUT_PULLUP);
  draw();
}

void loop() {
  //automaticCount();
  //count();
  kitt();
}

void automaticCount() {
  x++;
  draw();
  delay(200);
}

void count() {
  if (!digitalRead(LCD_BUTTON_LEFT)) {
    x--;
    draw();
    delay(200);
  } else if (!digitalRead(LCD_BUTTON_RIGHT)) {
    x++;
    draw();
    delay(200);
  }
}

void kitt() {
  for (byte i=0; i<8; i++) {
    x = 0b00000111<<i;
    draw();
    delay(100);     // Geschwindugkeit von links nach recht
  }
  for (byte i=0; i<8; i++) {
    x = 0b11100000>>i;
    draw();
    delay(100);    // Geschwindugkeit von rechts nach links
  }
}

void draw() {
  lcd.clearVideoBuffer();
  for (byte i=0; i<8; i++) {
    if (x & (1<<i)) {
      lcd.drawBitmap(120 - (i*16), 20, 8, 8, ledOn);
    } else {
      lcd.drawBitmap(120 - (i*16), 20, 8, 8, ledOff);
    }
  }
  lcd.show();
}



Quelle:
http://tiny.systems/categorie/lcdProjekt/Lauflicht.html




*********************************************************
4. Adventskalender

Adventskalender - Warten auf Weihnachten

Ein elektronischer Adventskalender.
Mit Hilfe eines Arduinos und dem 12864 LCD aus dem Franzis Lernpaket geht das recht einfach.
Mit jedem Tag darf ein neues Türchen mit der rechten Displaytaste geöffnet werden.

Nummer verschwindet Grafik wird vervollständigt



Adventskalender auf dem Arduino

Die Anwendung
Die Funktionalität der Anwendung ist auf das Wesentliche reduziert. In einer Endlosschleife werden die beiden Displaytaster abgefragt.
Die linke Taste zählt die Tage um eins nach unten.
Die rechte Taste zählt die Tage um eins nach oben.
Zuerst wird in den Videobuffer das Hintergrundbild geladen. Im Anschluss folgt die Darstellung der einzelnen Türchen.
Eine Variable für den aktuellen Tag dient als Indikator ob das jeweilige Türchen dargestellt wird oder nicht.
Der Adventskalender verwendet den Standardbefehlssatz der Display-API.

MENU > Datei > Sketchbook > DisplayBeispiele > Projekte > Advent.ino
ORDNER Advent    |  Advent.ino  |  Advent.h  |  Display.cpp  |  Display.h  |  Font.h  | 

#include "Display.h"
#include "SPI.h"
#include "Advent.h"

#define LCD_BUTTON_LEFT A4
#define LCD_BUTTON_RIGHT A5

Display lcd = Display();
byte day = 0;

void setup() {
  lcd.init(20);
  pinMode(LCD_BUTTON_LEFT, INPUT_PULLUP);
  pinMode(LCD_BUTTON_RIGHT, INPUT_PULLUP);
  draw();
}

void loop() {
  if (!digitalRead(LCD_BUTTON_LEFT)) {
    if (day != 0) {
      day--;
    }
    draw();
    delay(200);
  } else if (!digitalRead(LCD_BUTTON_RIGHT)) {
    if (day < 24) {
      day++;
    }
    draw();
    delay(200);
  }
}

void draw() {
  lcd.clearVideoBuffer();
  lcd.drawBitmap(0, 0, 128, 64, background);
  if (day < 1) { drawWicket(15, 33, 1); }
  if (day < 2) { drawWicket(46, 33, 2); }
  if (day < 3) { drawWicket(1, 34, 3); }
  if (day < 4) { drawWicket(78, 1, 4); }
  if (day < 5) { drawWicket(40, 1, 5); }
  if (day < 6) { drawWicket(34, 49, 6); }
  if (day < 7) { drawWicket(25, 4, 7); }
  if (day < 8) { drawWicket(30, 33, 8); }
  if (day < 9) { drawWicket(3, 2, 9); }
  if (day < 10) { drawWicket(1, 45, 10); }
  if (day < 11) { drawWicket(1, 20, 11); }
  if (day < 12) { drawWicket(66, 30, 12); }
  if (day < 13) { drawWicket(51, 50, 13); }
  if (day < 14) { drawWicket(114, 2, 14); }
  if (day < 15) { drawWicket(60, 8, 15); }
  if (day < 16) { drawWicket(94, 27, 16); }
  if (day < 17) { drawWicket(80, 27, 17); }
  if (day < 18) { drawWicket(95, 45, 18); }
  if (day < 19) { drawWicket(16, 48, 19); }
  if (day < 20) { drawWicket(114, 17, 20); }
  if (day < 21) { drawWicket(114, 32, 21); }
  if (day < 22) { drawWicket(114, 45, 22); }
  if (day < 23) { drawWicket(64, 47, 23); }
  if (day < 24) { drawWicket(95, 1, 24); }
  lcd.show();
}

void drawWicket(byte x, byte y, byte number) {
  lcd.drawBitmap(x, y, 14, 14, empty);
  lcd.invertRectangle(x, y, x+13, y + 13);
  char buffer[50];
  sprintf(buffer, "%d", number); 
  lcd.drawString(x+1, y+3, buffer);
}


Quelle:
http://tiny.systems/categorie/lcdProjekt/Adventskalender.html





*********************************************************
5. Grayscale

Grayscale - Methoden der Graustufenerzeugung

Graustufen auf einem monochromen (einfarbigen) Display erzeugen? Zur Lösung dieses Problems gibt es generell zwei Lösungsansätze.
Graustufen per Rasterung
Der erste Ansatz nutzt das begrenzte Auflösungsvermögen des menschlichen Auges aus und erzeugt die unterschiedlichen Graustufen mittels Rasterung. Ähnlich der Graustufenrasterung im Druckbereich werden mit der Anzahl gesetzter Pixel verschiedene Helligkeitswerte erreicht. Das wohl bekannteste Muster zur Graustufenerzeugung ist das Schachbrettmuster das den Mittelwert zwischen Schwarz und Weiß markiert. Die meisten Grafikanwendungen bieten die Möglichkeit verschiedene Grautöne mittels Stufenrasterung zu erzeugen. Leider geht das je nach Abstufung (Anzahl der Grautöne) mit einem massiven Verlust an Auflösung einher. Die nachfolgende Abbildung zeigt eine einfache Testanwendung zur Demonstration. Die Rasterung im unteren Farbverlauf ist deutlich zu erkennen. Erst mit genügend Abstand zum Display werden die verschiedenen Pixeldichten als unterschiedliche Grautöne erkannt.



Graustufenerzeugung auf einem monochromen Display

Balken OBEN: Flackern erzeugt Graustufen (experimentell)
Die zweite Methode ist etwas aufwendiger und ist vergleichbar mit dem Verfahren zur Helligkeitssteuerung von LEDs mittels Pulsweitenmodulation. Einzelne Pixel wirken bei hohen Frequenzen abhängig von ihrer Anzeigedauer dunkler oder heller. In der Demoanwendung wird dies mit einem einfachen Binärzähler (Variable "pattern") erreicht. Im oberen Teil der Anzeige werden so 8 verschiedene Graustufen erzeugt. Das Experiment zeigt, dass manche Grautöne flackern und andere stabil erscheinen. Dies ist auf den Alias-Effekt zurückzuführen. Der Displaycontroller zeigt den Displayinhalt mit einer bestimmten Bildwiederholfrequenz an und es kommt zum Stroboskopeffekt.
Die Demoanwendung kommt mit dem Standardbefehlssatz der Display-API aus. Hier geht's zum Download.

MENU > Datei > Sketchbook > DisplayBeispiele > Projekte > grayscala.ino
ORDNER grayscale    |  grayscale.ino  |  Bitmap.h  |  Display.cpp  |  Display.h  |  Font.h  | 


#include "Display.h"
#include "SPI.h"
#include "Bitmap.h"

Display lcd = Display();
byte pattern = 0;

void setup() {
  lcd.init(20);
  lcd.drawBitmap(0, 0, 128, 62, bitmap);
  lcd.show();
}

void loop() {
  lcd.setPageAddress(0);
  lcd.setColumnAddress(0);
  drawWhiteRect();
  for (int i=0; i<8; i++) {
    if(pattern & (i+1) * (i+1)) {
      drawBlackRect();
    } else {
      drawWhiteRect();
    } 
  }
  drawBlackRect();
  pattern++;
}

void drawBlackRect() {
  for (int i=0; i<8; i++) {
    lcd.writeData(0xFF);
  }
}

void drawWhiteRect() {
  for (int i=0; i<8; i++) {
    lcd.writeData(0x00);
  }
}


Quelle:
http://tiny.systems/categorie/lcdProjekt/Grayscale.html

https://de.wikipedia.org/wiki/Druckraster
https://de.wikipedia.org/wiki/Alias-Effekt
https://de.wikipedia.org/wiki/Stroboskopeffekt



*********************************************************
6. Seismograph

Seismograph mit Piezolautsprecher

Ein Seismograph ist ein Messgerät zur Ermittlung von Bodenerschütterungen.
Er wird meist für die Aufzeichnung von Vulkanaktivitäten und Erdbeben verwendet.
Erschütterungen werden dabei mit einer frei schwingenden Masse erfasst.
Kann man so etwas mit einem Arduino nachbauen?
Klar.
Auch ein Piezolautsprecher kann als Erschütterungssensor eingesetzt werden.
Zusammen mit dem Franzis GrafikDisplay LCD-Shield lässt sich daraus ein einfacher Seismograph bauen.




Erschütterungssensor mit Piezolautsprecher

Der Piezolautsprecher an sich ist gegenüber Erschütterungen noch recht unempfindlich.
Dies ändert sich jedoch sobald eine bewegliche Masse ins Spiel kommt.
Eine einfache AA Batterie sorgt bereits für eine ausreichende Empfindlichkeit.
Leichtes klopfen auf der Tischplatte wird zuverlässig erkannt.
Die Anwendung basiert auf dem Quellcode des Beispielprogramms "scope" aus dem Lernpaket "Grafikdisplays programmieren".
Es wurden lediglich ein paar Anpassungen in den Settings und in der Zeichenroutine vorgenommen.
Der Eingangspin für den Piezo ist pin-A0.

MENU > Datei > Sketchbook > DisplayBeispiele > Projekte >
Seismograph.ino


ORDNER seismograph    |  seismograph.ino  |  Display.cpp  |  Display.h  |
#include "Display.h"
#include "SPI.h"

/****************Settings*****************/
// Zeige Messspeicher für X ms an
word store = 50;
// Pixelbreite der Signaldarstellung
byte focus = 3;
// Signalverschiebung in y-Richtung
byte yPos = 0;
// Zeitbasis - Prescaler ADC - Werte von 0-7 
byte time = 4;
// Signalstärke über Division des ADC Wertes (/2^volts)
byte volts = 3;

Display lcd = Display();
byte values[128] = {};

void setup() {
  ADCSRA &= ~7;
  ADCSRA |= time;
  lcd.init(18);
  pinMode(A0, INPUT);
}

void loop() {
  lcd.clearVideoBuffer();
  for (byte x=0; x<128; x++) {
    delay(store);
    values[x] = (analogRead(A0) >> volts) + yPos;
    for (byte p=0; p<focus; p++) {
      lcd.drawPixel(x, 64-values[x] - p + 1);
      lcd.show();
    }
  }
}

Die Empfindlichkeit erhöhen.
Je wackeliger die Konstruktion auf dem Piezo aufgebaut ist umso empfindlicher wird das System gegenüber Schwingungen.
Zudem kann durch Vergrößerung der Fläche (z.B. durch anbringen eines Stück Karton) Luftbewegungen wahrgenommen werden.

Nachtrag:
Parallel zum Piezo hat sich ein Widerstand (1MOhm) bewährt, der für bessere Ergebnisse gesorgt hat.
Dies führt zu einer Glättung des Ausgangssignal.
Als Schwungmasse hat sich eine aufgeklebte Mutter bewährt, der Vorteil ist das man unterschiedlich lange Schrauben verwenden kann und somit flexibel mehrere Massen testen kann.

Noch besser der Ohmsche Sensor MEAS-SPEC.com Fa. EXP-Tech EXP-R05-463  SEN-09197

Artikelnummer EXP-Tech: EXP-R05-463
Hersteller: Sparkfun Hersteller-Artikelnummer: SEN-09197

Piezo Vibrationssensor - Groß mit Gewicht

https://www.sparkfun.com/products/9197



Quelle:
http://tiny.systems/categorie/lcdProjekt/Seismograph.html

https://de.wikipedia.org/wiki/Seismograph




*********************************************************
7. Erdfeuchtigkeit Watchdog


Bonsai Watchdog - Feuchtigkeitstester für Blumenerde

Wer einen Bonsai hat kennt das Problem wenn es Sommer wird.
Tägliches Gießen und das sogar mehrfach. Denn die Erde darf nicht austrocknen sonst ist das Bäumchen dahin.
Staunässe bekommt den Wurzeln aber auch nicht gut.
Da bleibt nur eins "Ständig die Feuchtigkeit per Finger prüfen" oder ein elektronisches Helferlein basteln.

Bonsai Watchdog im Einsatz
Die Feuchtigkeitsmessung orientiert sich am Verfahren zum Feuchtigkeitstester für Blumenerde , eine SparrowApp von Leander Hackmann.
Das Programm wurde hier um die Vorzüge einer grafischen Darstellung erweitert.
Als Basis für die Anwendung wird ein ARDUINO UNO R3 zusammen mit dem GrafikDisplay 12864 LCD von Franzis verwendet.
Der Messwert wird intuitiv als Füllstandsanzeige dargestellt.

Bleistiftminen als Messelektroden
Als Elektroden kommen einfache 0,5 mm Bleistiftminen zum Einsatz.

Mechanische Bleistifte - Druckbleistifte, Drehbleistifte


Die Verwendung von metallischen Elektroden ist aufgrund von Oxidation und des galvanischen Effekts nicht empfehlenswert.


Feuchtigkeitsanzeige auf dem Display

Die beiden Anschlüsse für die Messelektroden sind pin-A0 und pin-1 bzw. GND
Die Anwendung ist sehr einfach aufgebaut.
Bis auf den grafischen Füllstand sind alle grafischen Elemente in einem Hintergrundbild  Bonsai.bmp zusammengefasst.
Die Höhe der Füllstandsanzeige wird aus dem ermittelten Messwert errechnet und in Form mehrerer Linien gezeichnet.

MENU > Datei > Sketchbook > DisplayBeispiele > Projekte > BonsayWatchdog.ino

ORDNER BonsaiWatchdog    |  BonsaiWatchdog.ino  |  Bonsai.h  |  Display.cpp  |  Display.h  |  Font.h  |
#include "Display.h"
#include "SPI.h"
#include "Bonsai.h"

#define HUMIDITY_SENSOR A0                  //Messeingang an A0
#define FAKE_GND 1                          //Pin 1 als Hilfsmasse

Display lcd = Display();

void setup() {
  lcd.init(20);                             //Displayinitialisierung
  pinMode(FAKE_GND, OUTPUT);                //Pin 1 auf Low
  digitalWrite(FAKE_GND, LOW);
}

void loop() {
  lcd.clearVideoBuffer();                   //Videoram löschen
  lcd.drawBitmap(0, 0, 128, 64, bonsai);    //Hintergrundbild laden
  byte value;
  pinMode(HUMIDITY_SENSOR, INPUT);          //Feuchtigkeitsmessung
  digitalWrite(HUMIDITY_SENSOR, HIGH);
  value = analogRead(HUMIDITY_SENSOR);
  digitalWrite(HUMIDITY_SENSOR, LOW);
  pinMode(HUMIDITY_SENSOR, OUTPUT); 
  value = (value / 2) - 70;                 //Wertenormierung
  for (byte i = 108; i<123; i++) {
    lcd.drawLine(i, 55, i, value);          //Messbalken zeichnen
  }
  lcd.show();                               //anzeigen
}

Experimente mit verschiedenen Bodenarten
Es hat sich gezeigt, dass mit der Bodenbeschaffenheit (lehmig bzw. sandig) der absolute Feuchtigkeitsgehalt der Blumenerde stark schwankt.
Gegebenenfalls muss die Wertenormierung an die Blumenerde angepasst werden.


Quelle:
http://tiny.systems/categorie/lcdProjekt/BonsaiWatchdog.html





DIN A4 ausdrucken
*********************************************************
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE








Comments