I/O Shield mit 4x20 LCD-Display

Ich war mit dem gekauften LCD-Shield nicht ganz zufrieden. Deshalb entschloss ich mich ein eigenes Shield zu bauen. Es bekam vier Taster, einen Encoder mit Druck-Taster, vier Led's und eine Buchsenleiste für einen analogen Eingang. Ebenso sind die original I/O's des Uno's als Buchsenleiste ausgeführt.

Aber Highlight ist das aufsteckbare 4x20 Zeichen LCD-Display.

Belegung:
Pin 0 = Taster 1
Pin 1 = Taster 2
Pin 8 = Taster 3
Pin 9 = Taster 4
Pin 10 = Taster Drehgeber
Pin 7 = Led 1
Pin 6 = Led 2                               
Pin 5 = Led 3
Pin 4 = Led 4
Pin 13=  Led
Pin 11, A1, A2, A3, A4, A5 = LCD

Serielles Interface für LCD-Display

Um ein LCD-Display am Arduino anzuschliesen werden 6 Pins  plus Spannungsversorgung benötigt. Da können die I/O's schon einmal knapp werden. Bei ebay bin ich auf ein "Serial Interface Port Board For Arduino 1602 LCD Converter" gestoßen. Diese sind unter 2.-€ zu haben und benötigen neben der Spannungsversorgung nur noch zwei Pins. Es gibt sogar schon ein Poti um den Kontrast einzustellen. Die kleine Platine hat schon alle Pins an Board und wird einfach in die Durchkontaktierungen des LCD-Displays gesteckt und verlötet. Alles paßt perfekt. Hier stellte sich allerdings das Problem heraus das keine Libary beim Verkäufer zum Download bereit stand. Hier wurde ich dann fündig: Library. Nachdem die Library eingebunden war, funktionierte mein kleines Testprogramm auf Anhieb.

Programm:
Das LCD-Display wird initialisiert und die Hintergrundbeleuchtung eingeschaltet.
In die erste Zeile wird das berühmte "Hello World" geschrieben
In der zweiten Zeile läuft ein Zähler hoch. 

Belegung: 
SCL: Pin A5
SDA: Pin A4
Spannungsversorgung

Testprogramm:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,16,2);    // LCD Address 0x27 und 16 Zeichen, 2 Zeilen
int i = 0;                                              // Zähler auf 0 setzen

void setup()
        {
        lcd.init();                                   // initialize das lcd
        lcd.clear();                                // LCD löschen
        lcd.setCursor(0, 0);                  // Cursor setzen
        lcd.backlight();                        // Hintergrundbeleuchtung an
        lcd.print("Hello, world!");       // schreibe auf LCD
        delay (3000);
        }

void loop()
        {
        i=i+1;                           // Zähler hoch zählen
        lcd.setCursor(0, 1);      // Cursor setzen       
        lcd.print(i);                   // schreibe auf LCD
        delay (1000);                // warte 1000ms
        }

LCD-Keypad Shield

Um Programme für den Arduino testen zu können und zu entwickeln, habe ich mir dieses LCD Keypad Shield bestellt.
Es wird einfach auf den Uno Rev 3 aufgesteckt. Leider gab es keine Belegung dazu. Doch nach etwas probieren konnte ich die Belegung herausfinden. Gewundert hat mich, daß alle Tasten nur an einen einzigen analogen Eingang angeschlossen sind.

Beschreibung:
Das Programm liest den Analogwert an Pin A0 ein und zeigt den Analogert in Zeile eins auf dem Display an. Wird eine der Tasten gedrückt ändert sich der Analogwert entsprechend und die gedrückte Taste wird in Zeile zwei angezeigt.

Belegung:
Pin A0: Taster
Pin 4-9: LCD-Display
Pin 10: LCD-Hintergrundbeleuchtung

Programm:
/*  I/O Shield.ino
 *
 *  Created on: 15.12.2014
 *  Last changed on: 16.12.2014
 *
 *  Autor: fk
 */

#include <LiquidCrystal.h>                // binde Bibliothek LiquidCrystal ein
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);       // initialisieren Bibliothek und Interface-Pins

#define Tast_All A0                            // Analog-Eingang

int Led = 10;                                        // Hintergrundbeleuchtung

int All  = 0;
int Up   = 0;
int Down = 0;
int Right= 0;
int Left = 0;
int Select=0;


void setup()
              {           
              pinMode(Led,OUTPUT);       // Pin10 als Ausgang setzen
              analogWrite(Led,40);              // Helligkeit der Hintergrundbeleuchtung setzen
              pinMode(Tast_All,INPUT);    // Pin0 als Eingang setzen             
              lcd.begin(16, 2);                      // LCD-Display initialisieren
              lcd.clear();                               // LCD löschen
              lcd.setCursor(0, 0);                 // Cursor an Pos setzen
              lcd.print("I/O Shield");           // schreiben
              lcd.setCursor(0, 1);                 // Cursor an Pos setzen
              lcd.print("Ver 1.0 by FK");     // schreiben
              delay(3000);                            // warte 3sec
              }

void loop()
              {
              delay(100);                                  // warte 0,1sec
              lcd.clear();                                   // Display löschen
              lcd.setCursor(0, 1);                     // Cursor an Pos setzen
              All = analogRead(Tast_All);       // Analogwert einlesen
              lcd.setCursor(0, 0);                      // Cursor an Pos setzen
              lcd.print(All);                               // Analogwert schreiben
              lcd.setCursor(0, 1);                      // Cursor an Pos setzen
              if (All == 0)                                 // Wenn Wert = 0
                {
                lcd.print("rechts");                    // schreiben
                }
              if (All >= 300 && All <= 312)  // Wenn Wert zwischen xx und yy
                {
                lcd.print("runter");                    // schreibe
                }
              if (All >= 124 && All <= 136)  // Wenn Wert zwischen xx und yy
                {
                lcd.print("hoch");                      // schreiben
                }
              if (All >= 474 && All <= 486)   // Wenn Wert zwischen xx und yy
                {
                lcd.print("links");                      // schreiben
                }
              if (All >= 714 && All <= 726)   // Wenn Wert zwischen xx und yy
                {
                lcd.print("Auswahl");                // schreiben
                }
              }

RGBW Shield für den 328P

Dieses Shield ist zum Ansteuern von Led-Streifen gedacht. Es hat allerdings 4 Kanäle. So kommt zu den üblichen Kanälen rot, blau und grün, noch ein extra Kanal für weiß hinzu. Somit muß weiß nicht extra aus den drei Farben gemischt werden und es können auch warmweiße Led's verwendet werden, was wesentlich angenehmer ist.

Angesteuert werden die 4 Farben über jeweils einen PWM Kanal des µControllers.


Die Schaltung ist für Led-Streifen mit gemeinsamen Plus-Anschluß konzipiert.

Experimentierplatinen für den Atmel328P

Als Experimentierplatine eignet sich hervoragend ein Arduinoboard. Dies hat auch schon eine ISP Schnittstelle an Bord und man kann direkt mit Studio4 seine geschriebenen Programme überspielen. Allerdings funktioniert es danach nicht mehr in der Arduino Umgebung.

Alternativ habe ich mir ein wesentlich billigeres und einfacheres Testboard gebaut. Auch hier können die Erweiterungen einfach aufgesteckt werden.

Anleitung zum Flashen eines Atmel328 µControllers

Zum Übertragen des Hex-Files auf den µProzessoren benutze ich das Programm AVR Studio 4. Dies ist noch nicht so überladen wie die neueren Versionen und dadurch sehr einfach zu bedienen. Die Hardware ist ein AVRISP MKII USB Brenner. Programmiert wird folglich über die 6-polige ISP-Buchse. Deshalb habe ich extra eine kleine Platine mit Nullkraftsockel fertigen lassen, an die das Flachbandkabel des Programmers direkt angesteckt werden kann. Damit können jetzt die beliebten Atmel328 Prozessoren programmiert werden.


Nachdem nun die Grundvoraussetzungen geschaffen sind, kann das erste Programm übertragen werden. Das Programm Studio4 wird aufgerufen und der "Con"-Button zum Verbindungsaufbau gedrückt.

Es öffnet sich ein Menü in dem der verwendete Programmer eingestellt wird. 

 

Danach kann die Geschwindigkeit eingestellt werden mit der der µController programmiert werden soll.

 

Jetzt kann schon einmal getestet werden ob die Kommunikation funktioniert und die Kennung des Atmels überprüft werden. Dazu wird die Signature ausgelesen. Jeder µController Typ hat eine andere Kennung und so kann man schon einmal testen ob der zuvor in der Software eingestellte Typ auch wirklich mit dem in der Fassung eingesetzten Typ übereinstimmt.

Im nächsten Schritt werden die "Software-Schalter", die sogenannten Fuses überprüft bzw angepaßt. Dies geschieht über verschiedene Auswahlfelder. Danach werden die Einstellungen durch drücken des Buttons "Program" in dem Chip gespeichert.

Nachdem jetzt die Grundeinstellungen vorgenommen wurden, kann das eigentliche Programm übertragen werden. Dazu wird unter Flash die Hex-Datei ausgewählt und mit Program übertragen. Unten erscheint ein grüner Frortschrittsbalken. Wenn alles geklappt hat steht im Eigenschaftfenster ein OK und man kann den Atmel entnehmen.

16 fach Lauflicht mit Atmel 328P

Zum Einstieg einfach Mal etwas einfaches, was man aber immer wieder gebrauchen kann. Zwei verschiedene Lauflichter. Programmiert wurde des Ganze in BASCOM.