http://sites.schaltungen.at/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
*********************************************************

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.

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




Tomas Baum  TINY.Systems
Espenstraße 135
D-66346 Püttlingen
mailto:[email protected]
Tel. +49 (0)6898 / 964296
http://tiny.systems/

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

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?

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:

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() {}

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

binär 01101001 = hexadezimal 69

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)

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.

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 A5const 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();}

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

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.

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 A5const 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();}

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

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

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 A5Display 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);}

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

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.

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);  }}

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

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.

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 anword store = 50;// Pixelbreite der Signaldarstellungbyte focus = 3;// Signalverschiebung in y-Richtungbyte 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.

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

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.

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.

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.

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 HilfsmasseDisplay 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.

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

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE