Grafik-Display

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

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
*********************************************************

    Um diese Seiten praktisch nutzen zu können brauchen Sie unbedingt den
                        FRANZIS MARKER KIT
                  Grafikdisplays programmieren auf 88 Seiten



Untergeordnete Seiten (4):

  1 Grafik-Display               300_d_FRANZIS-x_Grafikdisplays programieren - 1 Grafik-Display_1a.pdf             (16 Seiten)
  2 Display-Grundlagen
    300_d_FRANZIS-x_Grafikdisplays programieren - 2 Display-Grundlagen_1a.pdf    (11 Seiten)
  3 TextDisplay
                   300_d_FRANZIS-x_Grafikdisplays programieren - 3 TextDisplay_1a.pdf                (12 Seiten)
  4 GrafikDisplay
               300_d_FRANZIS-x_Grafikdisplays programieren - 4 GrafikDisplay_1a.pdf              (37 Seiten)
  5 Projekte
                        300_d_FRANZIS-x_Grafikdisplays programieren - 5 Projekte_1a.pdf                      (12 Seiten)


Alles von www.schaltungen.at downloadbar.

2016-05-10
Das Franzis Maker Kit "Grafikdisplays programmieren" geht in die 2. Auflage.
Die Tage ist ein Muster bei mir angekommen.
Viel geändert hat sich nicht.
Die Hardware kommt nun mit stylisch schwarzen Tasten daher.
Zudem wurde bei den Abbildungen der einzelnen Anwendungen nachgebessert.



Grafikdisplays programmieren

In Zusammenarbeit mit Fabian Kainka und Franzis ist aus einer gemeinsamen Affinität zu kleine stromsparenden Displays
ein spannendes Lernpaket rund um das Thema Displayprogrammierung im Umfeld von Mikrocontrollern und Embedded Systems entstanden.
Hier findest Du Anregungen und Tipps und natürlich frische Ideen für neue Projekte.

Zum Grafikdisplay soll es demnächst auch etwas bei Conrad Electronic geben.

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


FRANZIS Maker Kit - Grafikdisplays programmieren   49,95 €  Shield vorhanden
 20 praxisnahe Projekte, von der grundlegenden Ansteuerung eines Displays bis zu grafischen Anzeigen einer SmartHome Steuerung.

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/
http://tiny.systems/categorie/lcdProjekt/ProportionaleFonts.html
http://tiny.systems/categorie/lcdProjekt/Zahlensysteme.html
http://tiny.systems/categorie/lcdProjekt/Lauflicht.html
http://tiny.systems/categorie/lcdProjekt/Adventskalender.html
http://tiny.systems/categorie/lcdProjekt/Grayscale.html
http://tiny.systems/categorie/lcdProjekt/Seismograph.html
http://tiny.systems/categorie/lcdProjekt/BonsaiWatchdog.html
http://tiny.systems/categorie/lcdProjekt/HallOfFame.html


Mosaic: Online Bitmap2Hex Konverter

http://tiny.systems/article/mosaic.html
http://tiny.systems/software/lcdProjekt/DXDCG12864-4330.pdf



Mitautor:
Fabian Kainka


http://fkainka.de/grafikdisplays-programmieren/





LCD-Shield mit einem 12864 LCD (128x64 Pixel, ST7565)

Graphical (128x64) monochrome LCD with LED backlight

Möchte man den Bildinhalt eines 128*64 Pixel großen monochromen LCD füllen sind bereits 1024 Bytes nötig (1024 * 8 == 128 * 64).
Kommt dann noch Farbe ins Spiel multipliziert sich der Speicherplatz durch die Farbtiefe.
Mit einer 8-bit Farbtiefe sind das bei gleicher Auflösung bereits 8kB Bilddaten.
http://www.franzis.de/elektronik/lernpakete-mikrocontroller/franzis-maker-kit-grafikdisplays-programmieren#



ISBN: 978-3-645-65278-0


http://www.franzis.de/franzis/div/book/index.jsp

Damit Sie die Zip-Datei zum BUCH herunterzuladen können müssen Sie die ISBN-Nummer des Buches eintippen.

65278-0


65278-0 Franzis Maker Kit Grafikdisplays programmieren

Der komplette Quellcode des Maker Kits zum Nachpropgrammieren und erweitern.

Erschienen am29.07.2015

bisherige Downloads 1147

Download starten
115,7 KB download


ORDNER > Grafik-Display


300_d_FRANZIS-x_65278-0 Shield Grafikdisplays programmieren - Beispiel-Programme_1a.zip
Der komplette Quellcod zum FRANZIS Grafikdisplay Shiel

Seite Sketch-Name
014 AnalogInput.ino
069 analogWatch.ino
059 analysis.ino
032 ASCII.ino
082 calendar.ino
028 CharSet.ino
048 constellation.ino
100 flappyBirdClone.ino
076 geometrie.ino
085 HardwarePlayground.ino
010 HelloWorld.ino
010 HelloWorldDIY.ino
038 Metering.ino
092 navigation.ino
056 nikolaus.ino
050 scope.ino
036 SerialTextDisplay.ino
061 smartHome.ino
008 Starter.ino
097 turtleGraphics.ino
079 vuMeter.ino

background.bmp
flappy.bmp
flappyRIP.bmp
home.bmp
watch.bmp


Display.cpp
TextDisplay.cpp
Time.cpp
Turtle.cpp


background.h
Bitmap.h
Display.h
Flappy.h
Font.h
Home.h
TextDisplay.h
Time.h
Turtle.h
watch.h


041 lib


ARDUINO UNO R3 Sketche.ino

Handbuch-Inhaltsverzeichnis                        Seite

Inhaltsverzeichnis                                                                 5
1 Einführung                                                             6
1.1    Display installieren                                                       6
1.2    Die Beispiele downloaden                                             7
1.3    Starter.ino - das erste Beispiel                                           8

2    Display - Grundlagen                                        10
2.1    HelloWorld.ino - das erste eigene Programm                      10
2.1    HelloWorldDIY.ino
2.2    AnalogInput.ino - Messergebnisse am Display anzeigen       14
2.3    Blick in die Library 1                                                     18

3 Textdisplay                                                             28
3.1    CharSet.ino - der erste Schritt zum Textdisplay                     28
3.2    ASCII.ino - der komplette Zeichensatz                                   32
3.3    SerialTextDisplay.ino - Textausgabe und PuTTY                    36
3.4    Metering.ino - Messdaten ausgeben                                      38
3.5    Blick in die Library II lib - die Klasse Textdisplay                    41

4 Grafikdisplay                                                            48
4.1    constellation.ino - wie Sterne am Himmel                                48
4.2    scope.ino - ein einfaches Oszilloskop                                     50
4.3    Blick in die Library III - die Grundlagen des Grafikdisplays    53
4.4    nikolaus.ino - ich mal das Haus vom Nikolaus                         56
4.5    analysis.ino - Matheunterricht mit Arduino                              59
4.6    smartHome.ino - Hausautomatisierung auf dem Display          61
4.7    Blick in die Library IV - Linien, Texte und Bilder                 66
4.8    analogWatch.ino - Digitaluhr mit Ziffernblatt                            69
4.9    geometrie.ino - auf zu neuen Formen                                    76
4.10  vuMeter.ino - der klassische Austeuerungsmesser                  79
4.11  calendar.ino - analoge Uhr mit erweiterten Funktionen           82
4.12  HardwarePlayground.ino - die Hardware voll im Griff                  85
4.13  navigation.ino - ein Menü mit reichlich Auswahl                        92
4.14  Blick in die Library V - die Library ist komplett                  94
4.15  turtleGraphics.ino - der kleine Zeichenroboter                           97
4.16  floppyBirdClone.ino - Spielspaß zum Abschluss                             100

5 Befehlsliste                                                           104
5.1    API Grafikdisplay                                                         104
5.2    API Textdisplay                                                           105


Grafik-Display  DXDCG12864-4330  128x64 Dots

LCD-Shield mit einem 12864 LCD (128x64 Pixel, ST7565)
8x21 Zeichen

Nach Abwägen aller Vor- und Nachteile sollte es dann ein monochromes 12864 mit einem internen ST7565r Displaycontroller sein.
In Kombination mit einem Arduino könnte man damit viel machen.
Damit stand dann auch das Zielsystem fest.
Es sollte ein Lernpaket für Arduino werden.
Für den Schaltungsentwurf ergab sich dabei eine besondere Anforderung.
Der Arduino läuft mit 5V. Alle verfügbaren Displays vertragen jedoch maximal 3,6 V.
Ein Pegelwandler musste her.

Displaycontrollers ST7565r (Seriell 3,3V)
http://www.ladyada.net/learn/lcd/st7565.html

Ähnlich ist LCD-Grafik-Modul KSB0108B-LSC 128 x 64 Pixel
mit KS0108B (Paralell 5,0V)kompatiblen Schnittstelle (0..127 x 0..63)
8 Zeilen mit je 20 Zeichen
BUCH: Arduino Workshop Seite 170



Schaltungsentwurf für das LCD Shield

Beim Entwurf wurde darauf geachtet, dass nur der obere Teil der Anschlüsse des Arduinos Verwendung finden.
Es sollten noch genug IO-Ports für eigene Zwecke übrig bleiben.
Diese Anforderung konnte gut umgestetzt werden. Es waren sogar noch 2 Ports für zusätzliche Taster frei.

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


NO. SYMBOL
1 PS
2 NC
3 C86
4 CS1B
5 RST
6 D6(SCL)
7 WR
8 RD
9 D7(SDA)
10 D5
11 D4
12 D3
13 D2
14 D1
15 D0
16 A0
17 VSS
18 VDD
19 VLED+
20 VLED-
21 NC




Anschluss Funktion
3,3V Ub = Stromversorgung
5,0V n.c.
GND Ground


S2 Taster S2
S1 Taster S1

n.c.
GND Masse
SCL Clock-Leitung der SPI-Schnittstelle
LED Hintergrund-Beleuchtung
SDA Datenleitung der SPI-Schnittstelle
CS ChipSelect - LCD-Aktivierung
RST Hardware-Reset
A0 Steuerleitung Kommando/Daten




JP2 & JP3 ARDUINO Jumper 2 LCD Funktion
Steckleiste UNO-pin Jumper 3 pin P$
10 SCL S2
Taster S2
9 SDA S1
Taster S1
8 Aref Vdd 18 Ub = 3,3V
7 GND Vss 17 Masse
6 13 (D6) SCL 6 Clock-Leitung der SPI-Schnittstelle
5 12 LED
Hintergrund-Beleuchtung (JP1-3)
4 11 (D7) SDA 9 Datenleitung der SPI-Schnittstelle
3 10 CS 1B 4 ChipSelect - LCD-Aktivierung
2 9 RST 5 Hardware-Reset
1 8 A0 16 Steuerleitung Kommando/Daten


n.c. 21


V led - 20 GND


V led + 19 3,3V


D0 15 3,3V


D1 14 3,3V


D2 13 3,3V


D3 12 3,3V


D4 11 3,3V


D5 10 3,3V


RD 8 3,3V


WR 7 3,3V


C86 3 3,3V


n.c. 2 n.c.


PS 1 GND

300_fritz-x_Grafik-Display  DXDCG12864-4330  128x64 Dots - Pinbelegung_1a.pdf



Platine 53x46mm   Ansicht Bestückungsseite




Platine 53x46mm   Ansicht Leiterbahn-Seite (ACHTUNG: IC & Taster Gehäusekontur macht Kurzschlüsse)


Franzis Maker Kit
Grafikdisplays programmieren
inkl. Arduino Grafik-Shield
Fabian Kainka

Das Maker Kit versorgt Sie mit der notwendigen Theorie und erläutert für alle, die es verstehen wollen, die Funktionsweise des Displays.


Grafikdisplays selbst programmieren  € 49,95 + € 8,00 Versandkosten
Inklusive fertiges Grafik-Shield für Arduino UNO R3

FRANZIS Artikel-Nr.:  978-3-645-65278-0


Inkl. Fertiges Grafik-Shield für Arduino
Franzis Maker Kit - Grafikdisplays programmieren
Lernpaket
sofort lieferbar
*versandkostenfrei
ISBN: 978-3-645-65278-0 vorhanden



Grafikdisplayprogrammierung leicht gemacht:
20 praxisnahe Projekte für die Ansteuerung eines Grafikdisplays am Arduino

Die Steuereinheit für das SmartHome, die Wetterstation oder gar ein Roboter –
alle haben eines gemeinsam: ein Grafikdisplay als Schnittstelle zwischen Mensch
und Maschine.

Nur wie kombiniert man ein Display mit einem Arduino?
Ganz einfach: mit dem fertig aufgebauten Shield in diesem Lernpaket!


Ob Roboter, Steuereinheit für das SmartHome oder Wetterstation, alle haben eines gemeinsam: das Display für die Anzeige.
Nur wie kombiniert man ein Display mit einem Arduino™? Ganz einfach: mit dem fertigen Shield in diesem Lernpaket!

In 20 Projekten lernen Sie alles, was Sie zur Programmierung des Grafikdisplays benötigen, ob einfache Textausgabe oder komplexe Visualisierungen.

Das Maker Kit bietet die Erklärung der notwendigen Theorie und für die, die es verstehen wollen: die Funktionsweise des Displays.
Steigen Sie ein in das Geheimnis der Mensch-Maschine-Kommunikation.
Lernen Sie die Sprache der Programme zu verstehen und visuell zu übersetzen!






Definition der Inhalte
Mit den ersten Tests entstanden schnell ein paar brauchbare Testprogramme für das Display.
Zu diesem Zeitpunkt gab es noch keinerlei Konzept für die Didaktik des Lernpakets.
Wichtig war vorerst was der Anwender generell mit einem 12864er LCD alles anstellen kann und welche Anwendungsfälle wir zeigen wollten.
20 praxisnahe Anwendungen sollten es schon sein. Und das war ist Ergebnis (unterteilt in verschiedenen Anwendungstechniken):

Hardwarenahe Kommunikation und Verwendung
• Starter - Das erste Beispiel (Kontrasteinstellung)
• HelloWorld - Das erste eigene Programm (Daten zum Display übertragen)
• AnalogInput - Messergebnisse am Display anzeigen (Messdaten als Balkenanzeige)
Verwendung als Textdisplay
• CharSet - Der erste Schritt zum Textdisplay (Eigenen Zeichensatze entwickeln)
• ASCII - Der komplette Zeichensatz (Textausgabe und Formatierung)
• SerialTextDisplay - Textausgabe und PuTTY (Ein serielles Display)
• Metering- Messdaten ausgeben (Datenaufbereitung auf einem Textdisplay)
Verwendung als Grafikdisplay
• Constellation - Wie Sterne am Himmel (Einführung Videoram und einzelnde Pixel setzen)
• Scope - Ein einfaches Oszilloskop (Messdatennormierung und Darstellung)
• Nikolaus - Das Haus vom Nikolaus (Linienalgorithmus)
• Analysis - Matheunterricht mit Arduino (Funktionen zeichnen)
• SmartHome - Hausautomatisierung auf dem Display (Grafiken und Animationen)
• AnalogWatch - Digitaluhr mit Ziffernblatt (Displaykoordinaten und die Mathematik)
• Geometrie - Auf zu neuen Formen (Kreise und andere geometrische Figuren)
• VUMeter - Der klassische Aussteuerungsmesser (Messdaten und grafische Aufbereitung)
• Calendar - Analoge Uhr mit erweiterten Funktionen (Externe Programmbibliotheken)
• HardwarePlayground - Die Hardware voll im Griff (Was kann der Displaycontroller)
• Navigation - Ein Menü mit reichlich Auswahl (einfaches UserInterface)
• TurtleGraphics - Der kleine Zeichenroboter (Displayprogrammierung mal anders)
• Flappy Bird - Spielspaß zum Abschluss (LCD-Spieleprogrammierung)

Damit waren die wichtigesten Anwendungsfälle für ein monochromes grafisches Display abgedeckt.



Projekte im Franzis Maker Kit - Grafikdisplays programmieren:
  • Pixel auf dem Display darstellen
  • Analoge Messergebnisse anzeigen
  • Nutzung als Textdisplay
  • Eigenen Zeichensatz erstellen
  • ASCII-Zeichen darstellen
  • Display über PuTTY beschreiben
  • Messdaten übersichtlich ausgeben
  • Nutzung als Grafikdisplay
  • Eigenes Oszilloskop entwickeln
  • Einfache Linien zeichnen
  • Komplexe Grafiken darstellen
  • Statusmonitor für SmartHome
  • Analoge Uhr auf dem Display
  • Geometrische Figuren zeichnen
  • VuMeter umsetzen
  • Kalender darstellen
  • Navigationsmenü auf dem Display
  • Programmierung über Turtle-Grafik
  • Flappy Bird programmieren



Grafikdisplays programmieren

In 20 Projekten lernen Sie alles, was Sie zur Programmierung des Grafikdisplays benötigen, ob einfache Textausgabe oder komplexe Visualisierungen.
Das Maker Kit bietet die Erklärung der notwendigen Theorie und für die, die es verstehen wollen: die Funktionsweise des Displays.  




Der Inhalt:
Das Kit enthält ein fertiges Grafik-Shield
mit Display für Arduino™
und ein ausführliches Handbuch mit spannenden Projekten.


Nicht enthalten ist eine Arduino™-Platine.

  • Für Kinder unter 14 Jahren nicht geeignet.
  • Nicht enthalten: Arduino™-Platine

 

Exklusiv für alle Buch-Käufer:

Der komplette Quellcod aus dem Maker Kit zum sofortigen Einsatz, stehen Ihnen nach dem Kauf des Buches kostenlos auf www.buch.cd zur Verfügung.






5. BEFEHLSLISTE

5.1 API Grafikdisplay 128 x64 dots
API-Funktion      Parameter                                            Erklärung
init                 byte contrast (0-63]         Initialisierung des Displays mit übergebendem Kontrastwert (Hardware SPI], Hintergrundbeleuchtung nicht schaltbar, maximale Übertragungsgeschwindigkeit      
initSoftSPl          byte contrast (0-63)                                            Initialisierung des Displays mit übergebenden-Kontrastwert (Software SPI), Hintergrundbeleuchtung [Pin 12] schaltbar
writeCommand         byte command                                                    Führt ein ST7565-Kommando aus
writeData            byte data                                                       Überträgt das angegebene Byte auf das Display
resetRamAddress       -                                                              Setzt den RAMzeiger auf Zeile 0 Spalte 0
setPageAddress       byte pageAddress (0-7)                                          Setzt den RAMzeiger in die angegebene Zeile
setColumnAddress     byte columnAddress [0-127]                                      Setzt den RAMzeiger in die angegebene Spalte
clearDisplayRAM       -                                                              Löscht den gesamten Inhalt des Displays
clearVideoBuffer      -                                                              Löscht den gesamten Inhalt des Videopuffers
drawPixel            byte x, byte y [x-, y-Position]                                 Zeichnet einen Punkt an die gegebene Position [Änderungen beziehen sich auf den Videopuffer]
drawLine             byte xl, byte yl [Punkt 1) byte x2, byte y2 [Punkt 2]           Zeichnet eine Linie zwischen den beiden Punkten (xl, yl] und (x2, y2] (Änderungen beziehen sich auf den Videopuffer]
drawString           byte x, byte y [x-, y-Position], Zeichenkette                   Zeichnet eine Zeichenkette an eine beliebige Position (x, y] [Änderungen beziehen sich auf den Videopuffer]
drawBitmap           byte x, byte y, byte width, byte height, const byte bitmap[]    Zeichnet eine Bitmap an Position x, y mit der Länge (width) und der Breite (height) (Änderungen beziehen sich auf den
Videopuffer]
drawEllipse          byte x, byte y, byte a, byte b                                  Zeichnet eine Ellipse/einen Kreis an Position [x,y] mit dem Radius [a, b] (Änderungen beziehen sich auf den Videopuffer)
invertRectangle      byte xl, byte yl, byte x2, byte y2                              Invertiert die Anzeige in dem angegebenen Rechteck mit der Diagonalen (xl, yl], (x2, y2] (Änderungen beziehen sich auf den Videopuffer) 
Show                  -                                                              Überträgt den Inhalt des Videopuffers auf das Display


                                                                                                   Seite 104

5.2 API Textdisplay 22x 8 Zeichen
API-Funktion      Parameter             Erklärung
init                  byte contrast [0-63]      Initialisierung des Displays mit übergebendem Kontrastwert (Hardware SPI], Hintergrundbeleuchtung nicht schaltbar, maximale Übertragungsgeschwindigkeit
println               Zeichenkette              Gibt eine Zeichenkette in der aktuellen Zeile aus [mit anschließendem Zeilenumbruch]
print                 Zeichenkette              Gibt eine Zeichenkette in der aktuellen Zeile aus
clear                  -                        Löscht den internen Textpuffer und setzt die aktuelle Position auf Anfang
getLastCharPosition   byte line [0-7]           Ermittelt die Position des letzten Zeichens in einer angegebenen Zeile
writeTextBuffer        -                        Stellt den Inhalt des Textpuffers auf dem Display dar


                                                                                                 Seite 105



*********************************************************
ARDUINO-Extensions
*.ino = ARDUINO-Sketch / ARDUINO-Datei
*.cpp = CPP-Datei (Sourcer-File)  ARDUINO\libraries = Bibliothek
*.h   = H-Datei                   ARDUINO\libraries = Bibliothek
*.bmp = BMP-Datei
*.pde = Quellcode C-File vom IDE-Editor


Wenn Du eine eigene Library (.h und .c) im Sketch-Verzeichnis liegen hast musst Du sie mit
#include "myLib.h" einbinden. Dann erwartet der Linker sie im selben Verzeichnis.


#include <myLib.h>  // sucht die Datei im Lib-Ordner.
Die entpackten Dateien müssen in deinen Arduino-Libraries Ordner - unter Windows also
z.B. C:\Benutzer\fritz\Dokumente\Arduino\libraries
und dann im Sketch natürlich die Header-Datei entsprechend eingebunden werden, also
z.B.: #include <library.h> (bei den Präprozessor-Direktiven)
Informationen zur Installation von Libraries finden sich unter:
http://arduino.cc/en/Guide/Libraries

https://www.arduino.cc/en/Hacking/LibraryTutorial
http://arduino.cc/en/Hacking/Library Tutorial beschreibt wie man eine Library schreibt.



Die ARDUINO-Plattform installieren.
Hardware = Arduino-Board = ARDUINO UNO R3 ein kleines Mikrocontroller-Board mit Mikroprozessor Atmel ATmega328p (DIL-28)
Software = Arduino-IDE 1.6.4 (Sketche)  
arduino-1.0.5-r2-windows.exe
http://www.arduino.cc/en/Main/Software

Treiber für das ARDUINO UNO Board
C:\Programme (x86)\Arduino\drivers\ArduinoUNO\arduino.inf


Board mit USB Verbindungskabel mit PC verbinden.
Rechner > Geräte-Manager (Datei-Manager / Device 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 > Blink.ino   Die eingebaute LED (an pin-13 = LED-Anode-lang) zum blinken bringen
Hackerl = Verifizieren
Pfeil = Hochladen

Nur um zu testen ob alles geht ! ! !

Dann erst weiter zu Punkt 1 EINFÜHRUNG


                                                                                      

1. EINFÜHRUNG

1.1 Display installieren
Für die Beispiele im Buch benötigen Sie ein Arduino-Board und die Arduino-Entwicklungsumgebung.
Alle Beispiele wurden auf einen Arduino Uno ausgelegt, da er am weitesten verbreitet ist, und mit der Arduino-Version 1.6 programmiert.
Es ist allerdings wahrscheinlich, dass die Beispiele mit vergleichbaren Controllern oder Arduino-Versionen kompatibel sind.
Wenn Controller und Software auf Ihrem PC funktionieren, können Sie das Displayshield auf das Board stecken.
Achten Sie zuerst auf die richtige Position des Jumpers JP1 auf der Unterseite des Display-Shields.
Überbrücken Sie, wie in der Darstellung gezeigt, den rechten und den mittleren Kontakt.
Mit dieser Einstellung ist die Hintergrundbeleuchtung des Displays aktiviert.




Abb 1.1 Das Shield mit gesetztem Jumper   Abb 1.1 Das Shield mit gesetztem Jumper   
Beachten Sie, dass Sie beim Aufstecken des Displays auf Ihren Arduino die richtigen Pins erwischen.

                                                                                            Seite 6



Das Shield sollte so orientiert sein, dass die Taster vom USB-Anschluss weg zeigen.
Außerdem sollte die komplette rechte Seite des Shields in die obere rechte Buchsenleiste des Unos gesteckt sein.
Bei der oberen linken Buchsenleiste werden die Anschlüsse GND, 5 V und 3,3 V verwendet.
Auf dem unteren Bild sehen Sie, wie das Ergebnis aussehen sollte.




Abb. 1.2: Das Shield richtig montiert


1.2  Die Beispiele downloaden
In diesem Buch werden viele verschiedene Programme zum Ausprobieren und Nachprogrammieren vorgestellt.
Alle Quelltexte komplett abzudrucken ist unmöglich.
Aus diesem Grund können Sie sich die Beispiele aus dem Netz herunterladen.
Sie finden die Zip-Datei auf der FRANZIS  Internetseite http://buch.cd
Um zum Download zu gelangen, müssen Sie lediglich die ISBN-Nummer 65278-0 dieses Hand-Buchs "FRANZIS MAKER KIT GrafikDisplays programmieren" eintippen.
Kopieren Sie den im Download enthaltenen Ordner namens DisplayBeispiele komplett in Ihren Sketchordner.
Diesen finden Sie unter Windows standardmäßig unter
C:\Benutzer\fritz\Dokumente\Arduino\DisplayBeispiele\AnalogInput\AnalogInput.ino

Wenn Sie nun die Arduino-Oberfläche starten, finden Sie unter
MENU > Datei > Sketchbook > DisplayBeispiele > Starter.ino

                                                                                            Seite 7




 
In diesem Ordner finden Sie alle Programme unter dem entsprechenden Kapitelnamen.



Abb. 1.3:  Alle FRANZIS GrafikDisplay-Beispiele dann in der ARDUINO-Entwicklungsumgebung enthalten.



Wenn Sie selbst versuchen möchten, ein Programm mithilfe des Buchs eigenständig zu entwerfen, sollten Sie das Programm HelloWolrdDlY als Vorlage benutzen und unter anderem Namen abspeichern.
Dadurch ist garantiert, dass sich alle wichtigen Library-Dateien in dem Ordner befinden.
Wenn Sie später komplett selbstständig Programme entwerfen, können Sie dieses Beispiel ebenfalls als Vorlage verwenden.




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 > Starter.ino
Hackerl = Verifizieren
Pfeil = Hochladen

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


1.3 Der Sketch "Starter" - das erste Beispiel
Damit Sie sicher sein können, dass das Display und die Software korrekt funktionieren, sollten Sie nun das erste Beispiel ausprobieren.
Dazu öffnen Sie das Programm, das genauso heißt wie dieses Kapitel, nämlich Starter.
Laden Sie dieses Programm auf Ihren Controller. Im Idealfall sehen Sie dann auf Ihrem Display das folgende Bild.

                                                                                            Seite 8

Starter.ino
#include "Display.h"
#include "SPI.h"

#define LCD_BUTTON_LEFT A4
#define LCD_BUTTON_RIGHT A5

const PROGMEM byte qrCode [] = {
  0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0x07,
  0x07, 0x07, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0xC7, 0xC7, 0xC7, 0x00, 0x00,
  0x00, 0x38, 0x38, 0x38, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x07, 0x07,
  0x07, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x00,
  0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x8E, 0x8E, 0x8E, 0x81, 0x81, 0x81, 0xF0, 0xF0,
  0xF0, 0x7E, 0x7E, 0x7E, 0xF0, 0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
  0x00, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x80, 0x40, 0x20, 0xE8, 0xE0, 0xC0, 0x80, 0x10, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x1F, 0x1F, 0x1F, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C,
  0x1C, 0x1C, 0x1F, 0x1F, 0x1F, 0x00, 0x00, 0x00, 0x1F, 0x1F, 0x1F, 0x03, 0x03, 0x03, 0xFF, 0xFF,
  0xFF, 0xE0, 0xE0, 0xE0, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x1F, 0x1F, 0x1C, 0x1C,
  0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1F, 0x1F, 0x1F,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x03, 0x04, 0x08, 0x2F, 0x0F, 0x07, 0x03, 0x10, 0x01,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x07, 0x07, 0x07, 0x3F, 0x3F, 0x3F, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x3F, 0x3F, 0x3F, 0x38,
  0x38, 0x38, 0xC7, 0xC7, 0xC7, 0x07, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x38, 0x38,
  0x38, 0xC0, 0xC0, 0xC0, 0x3F, 0x3F, 0x3F, 0xC7, 0xC7, 0xC7, 0xC7, 0xC0, 0xC0, 0xC0, 0x07, 0x07,
  0x07, 0x38, 0x38, 0x38, 0xC7, 0xC7, 0xC7, 0xC0, 0xC0, 0xC0, 0xC7, 0xC7, 0xC7, 0x38, 0x38, 0x38,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x0E, 0x0E, 0x0E, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x70, 0x70, 0x70, 0x0E, 0x0E, 0x0E, 0x0E,
  0x0E, 0x0E, 0x71, 0x71, 0x71, 0x0E, 0x0E, 0x0E, 0x81, 0x81, 0x81, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
  0xFE, 0x71, 0x71, 0x71, 0x80, 0x80, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0x71, 0x71, 0x71, 0x70, 0x70,
  0x70, 0xF0, 0xF0, 0xF0, 0x8F, 0x8F, 0x8F, 0x0F, 0x0F, 0x0F, 0xF1, 0xF1, 0xF1, 0x80, 0x80, 0x80,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xF8, 0xF8, 0xF8, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
  0x38, 0x38, 0xF8, 0xF8, 0xF8, 0x00, 0x00, 0x00, 0x3F, 0x3F, 0x3F, 0xFF, 0xFF, 0xFF, 0x07, 0x07,
  0x07, 0xC0, 0xC0, 0xC0, 0x3F, 0x3F, 0x3F, 0xC7, 0xC7, 0xC7, 0xC7, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC0, 0xC0, 0xC0, 0x3F, 0x3F, 0x3F, 0x07, 0x07, 0x07,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x18, 0x18, 0xF8, 0xF8, 0x18, 0x18, 0x00, 0xF8, 0xF8, 0x00, 0xF8, 0xF8, 0x18, 0x18, 0xF8,
  0xF8, 0x00, 0x78, 0x78, 0xE0, 0xE0, 0x78, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0x00,
  0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFE, 0xFE, 0xFE, 0xF1, 0xF1, 0xF1, 0x80, 0x80,
  0x80, 0xF1, 0xF1, 0xF1, 0x8E, 0x8E, 0x8E, 0xF1, 0xF1, 0xF1, 0xF1, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E,
  0x0E, 0x71, 0x71, 0x71, 0x8F, 0x8F, 0x8F, 0x81, 0x81, 0x81, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x10, 0x1D, 0x05, 0x00, 0x05, 0x19, 0x04, 0x00, 0x11,
  0x1D, 0x04, 0x00, 0x04, 0x1D, 0x05, 0x00, 0x1C, 0x1C, 0x15, 0x00, 0x1C, 0x0C, 0x1C, 0x00, 0x10,
  0x1C, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xFF, 0xFF, 0xFF, 0xE0, 0xE0, 0xE0, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xE0,
  0xE0, 0xE0, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0xE0, 0xE0, 0xE0, 0x1C, 0x1C,
  0x1C, 0xFC, 0xFC, 0xFC, 0x03, 0x03, 0x03, 0x1F, 0x1F, 0x1F, 0xE0, 0xE0, 0xE0, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

Display lcd = Display();
int contrast = 18;
void setup() {
  pinMode(LCD_BUTTON_LEFT, INPUT);
  digitalWrite(LCD_BUTTON_LEFT, HIGH);
  pinMode(LCD_BUTTON_RIGHT, INPUT);
  digitalWrite(LCD_BUTTON_RIGHT, HIGH);
  lcd.init(contrast);
  setContrast();
}

void loop() {

  if (!digitalRead(LCD_BUTTON_LEFT) && contrast > 0) {
    contrast--;
    setContrast();
    }
    if (!digitalRead(LCD_BUTTON_RIGHT) && contrast < 63) {
      contrast++;
      setContrast();
      }
    delay(50);
  }

  void setContrast() {
    char buffer[50];
    lcd.writeCommand(0x81);
    lcd.writeCommand(contrast);
    sprintf(buffer, "%d", contrast);
    lcd.clearVideoBuffer();
    lcd.drawBitmap(0, 0, 128, 64, qrCode);
    lcd.drawString(100, 13, buffer);
    lcd.show();
  }






Abb. 1.4: Der QR-Code des Beispiel-Sketches Starter.ino


Es kann allerdings sein, dass Sie zuerst den Kontrast des Displays anpassen müssen.
Dazu benutzen Sie die beiden unter dem Display angebrachten Taster.
Mit dem linken Taster verringern Sie den Kontrast, mit dem rechten erhöhen Sie ihn.
Durch Probieren finden Sie heraus, welcher Kontrast für Ihr Display der geeignetste ist.
Sie sollten sich diesen Wert gut merken, denn in späteren Beispielen müssen Sie den Kontrast manuell im Quelltext anpassen.
Doch dazu später mehr.
Das Bild, das Sie nun auf dem Display sehen, ist ein QR-Code.
Wenn Sie ein Smartphone besitzen, können Sie mit einer entsprechenden App den Code auslesen und werden auf die tiny.systems-Internetseite geleitet, die Ihnen später noch öfter begegnen wird.
Mit diesem ersten Beispiel haben Sie schon etwas von den Möglichkeiten des Displays erfahren, doch erst im nächsten Kapitel geht es richtig los.

                                                                                            Seite 9



*********************************************************

12864 Graphics LCD library

12864 is an unofficial Arduino library that supports 12864 Graphic LCDs that use the ST7920 chip.

Download the library here:

http://playground.arduino.cc/uploads/Code/LCD12864.zip


http://playground.arduino.cc/Code/LCD12864





*********************************************************

Arduino-Treiber unter Windows installieren


Um mit Ihrem ARDUINO UNO R3 -Board programmieren zu können, müssen Sie zunächst die Windows-Treiber installieren.
Wir zeigen Ihnen, wie es funktioniert.

Windows: Arduino-Software installieren



Arduino-Treiber installieren
Mithilfe der Open-Source IDE-Software (integrated development environment) können Sie ihre Sketche auf Ihren Arduino-Mircocontroller laden.
Laden Sie sich die Installationsdatei der Arduino-IDE herunter und starten Sie die Installation.

Treiber-Installation unter Windows



Arduino mit dem PC verbinden
Schließen Sie Ihr Arduino-Board mit einem USB-Kabels an Ihren Computer an.
Windows startet eine Treiber-Installation, die aber meistens fehlschlägt. Ist das der Fall, gehen Sie folgendermaßen vor:

Klicken Sie auf den START-Button und suchen Sie nach dem "Geräte-Manager".
Damit Sie Ihr Arduino-Board finden, drücken Sie auf des kleine Dreieck vor dem Punkt "Anschlüsse (COM & LPT)".
Klicken Sie mit der rechten Maustaste auf Ihren Arduino und wählen Sie die Option "Treibersoftware aktualisieren".
Drücken Sie auf "Auf dem Computer nach Treibersoftware suchen" und navigieren Sie zum Pfad:
"C/Programme/Arduino/drivers".
Bestätigen Sie die Treiber-Installation und folgen Sie den weiteren Schritten. Der Treiber ist nun erfolgreich installiert.

Windows: Arduino-IDE konfigurien

Damit Sie Sketche mithilfe der Software auf Ihr Arduino-Board laden können, müssen Sie das richtige Board und den richtigen Port auswählen:
Klicken Sie hierzu in der Arduino-IDE auf MENU > "Werkzeuge" und wählen Sie unter Board Ihren Arduino-Controller aus.
Wiederholen Sie diesen Schritt für den Port, den das Arduino-Board verwendet.






DIN A4 ausdrucken
*********************************************************

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







Comments