LCD 16x2 mit I2C mit großen Zeichen

Hallo zusammen,
ich möchte ein LCD 16x2 mit I2C mit großen Zeichen über zwei Zeilen betreiben. Die Inhalt der Zeichen ändert sich ständig über eine Variable. Hat jemand eine Vorstellung, wie ich hier beginnen könnte?
Bin Dankbar für jede Hilfe.

Soweit mir bekannt, sind nur acht frei definierbare Zeichen möglich, die Du ja wahrscheinlich benötigst. Kommst Du damit hin?

Die 8 Zeichen beziehen sich auch nur auf eine Zeile. Ich habe den TO so verstanden, dass er Zeichen über beide Zeilen generieren will oder war das ein Trugschluss?

Gruß Tommy

Tommy56: Ich habe den TO so verstanden, dass er Zeichen über beide Zeilen generieren will oder war das ein Trugschluss?

Ich auch. Wie will man Zeichen über zwei Zeilen generieren? Mein Ansatz war, zwei Zeichen übereinander darzustellen:

[color=blue]AB[/color]CDEFGHIJKLMNOP
[color=blue]QR[/color]STUVWXYZ123456

Also A, B, Q, R bilden ein Zeichen.

Wer eine bessere Idee hat, nur zu :)

Das dürfte bei den maximal 8 User-Defined-Zeichen nicht machbar sein. Es sei denn, der TO btaucht nur 4 Zeichen.

Da wäre ein Punktdisplay eher sinnvoll.

Gruß Tommy

Meistens geht es doch nur um das Anzeigen einer Zahl und dafür gibt es viele Beispiele. Soll der TO mal konkreter werden

|500x248

|500x267

Schön, kannst Du dem TO auch mit einem Code helfen?

Gruß Tommy

Vincent67: Hallo zusammen, ich möchte ein LCD 16x2 mit I2C mit großen Zeichen über zwei Zeilen betreiben. Die Inhalt der Zeichen ändert sich ständig über eine Variable. Hat jemand eine Vorstellung, wie ich hier beginnen könnte? Bin Dankbar für jede Hilfe.

Was für "Zeichen" möchtest Du darstellen?

Nur Ziffern? Auch Großbuchstaben? Auch Kleinbuchstaben? Auch Sonderzeichen?

Solange es nur um "große Ziffern über zwei Zeilen" geht, ist das praktikabel. Das habe ich selbst schon gemacht. Du kannst "Ziffern mit gerundeten Ecken" haben. Oder "Ziffern mit sehr eckigem Aussehen".

Aber wenn Du einen vollständigen Zeichensatz brauchst, mit Ziffern, Großbuchstaben, Kleinbuchstaben und Sonderzeichen, dann befürchte ich, kommst Du mit den maximal 8()! gleichzeitig zu definierenden "benutzerdefinierten Matrixzeichen nicht aus. Bei weitem nicht.

Mit großen Zeichen über zwei Zeilen wirst Du Dich im darstellbaren Zeichensatz stark beschränken müssen. Zum Beispiel auf "nur Ziffern".

Hehe, nö. Hab das nie selbst gemacht sondern immer was fertiges benutzt, gibt so viele fertige Sketche im Netz. Einfach mal in Google "arduino lcd big font" oder "arduino lcd big numbers" eingeben.

Die Kontroller der LCD Displays (HD44780) können nur 8 Zeichen frei definieren Diese gelten dann für die gesamten Zeilen. Außnahme könnte ein 4x40 Display sein das 2 Controller drauf hat.

Die großen 4 Zeilen-Zeichen werden aus wenigen Sonderzeichen bzw standartzeichen zusammengestellt und darum reichen die 8 selbstdefinierbaren Zeichen.

Grüße Uwe

Hallo, danke erst einmal für die vielen Antworten.

Vielleicht habe ich mein Problem nicht genau genug erklärt. Ich lese einen sich ständig ändernden Zahlenwert mit aus dem Internet aus. Und möchte diesen danach groß über zwei Zeilen auf dem 16x2 über i2c darstellen. Verstehe aber nicht, wie ich es möglich mache, wenn zum Beispiel die Ziffernfolge: 52468 ausgelesen wird, diese groß darzustellen. Der Zahlenwert ändert sich laufend und wird in eine Variable (temp) geschrieben. Im Augenblick schreibe ich " lcd.print(temp); ".

Danke vorab, für Eure Hilfe

Allen einen guten Rutsch ins neue Jahr

Vincent67: zum Beispiel die Ziffernfolge: 52468 ausgelesen wird, diese groß darzustellen.

Das geht NICHT, weil die Zahl schon zu lang für ein 16x2 Display mit Big Number Darstellung ist!

Die "großen" Zahlen sind nämlich nicht nur höher und gehen über zwei Zeilen des Displays, sondern sie sind auch breiter!

Bei einer "big number" gehen zur Darstellung jeder Ziffer vier(!) Stellen in der Breite drauf: 3 Zeichen ist das eigentliche "big number" Zeichen breit, plus eine Stelle "Trennzeichen", damit die Ziffern optisch getrennt sind und nicht in der Anzeige "ineinander verlaufen".

Also kannst Du auf einem 1602 Display maximal vierstellige Zahlen als "big number" darstellen.

Um gleichzeitig fünf big numbers darzustellen, brauchst Du ein 20x2 display, mit einem 16x2 Display wird das eher nichts und da bekommst Du eher nur 4-stellige "big number" Zahlen unter.

Eventuell ginge es bei Uhrzeiten im HH:MM Format, noch einen Doppelpunkt dazwischen zu schummeln, für HH:MM Formatierung. Das geht, weil man die big number '1' schmaler als andere big numbers machen kann und es vor einer '1' in einer 2-stelligen Stundenangabe keines Leerzeichens bedarf, um die Zahl 1 gut lesen zu können. Also 12:45 ginge auf einem 1602 Display wohl gerade noch, aber anstelle der führenden 1 und des Doppelpunkts zwei beliebige andere Ziffern darzustellen, dann brauchst Du eher ein 2002 Display.

Hallo jurs,

danke schön für die Info.

Wie wäre es denn bei einer drei stelligen Zahl? Wie binde ich da denn eine sich verändernde Variable ein?

Ich verstehe leider nicht, wie ich hier mit der Variable umgehe.

P.S.: Ich habe auch schon Schriften gesehen, die brauchen kein Zeichen, für ein Trennzeichen (siehe auch oben die Bilder von Scherheinz)

Hast Du schon mal darüber nachgedacht, ein Grafikdisplay für die Textausgabe zu verwenden?

Cocktails_tft.png

Hallo agmue,

klasse Idee mit dem Grafikdisplay.

Wollte nur eigendlich die 16x2 verwenden, weil ich davon noch einige rumliegen habe ;-)

Darüber hinaus sind die 16x2 schon verbaut, wo ich die Änderung durchführen wollte.

Also war bei mir eine Softwareänderung am naheliegensten.

Vincent67: P.S.: Ich habe auch schon Schriften gesehen, die brauchen kein Zeichen, für ein Trennzeichen

Dann besorge oder mache Dir so eine Schrift und nimm die für Dein Vorhaben!

Hier im Forum habe ich jedenfalls noch nicht gesehen, dass jemand eine schmale/zierliche "big digits" Schrift für doppelt hohe Zeichen auf 1602 Display gepostet hätte, ich kenne nur die vollfetten "big digits" Schriften , die inklusive Trennung vier Zeichen Breite pro Ziffer belegen.

Vielleicht sollten wir mal eine Sammlung verschiedener big-digits Schriften machen, so dass sich bei den häufiger auftretenden Fragen nach big-digits Darstellung dann vielleicht einen Thread findet, in dem es eine Sammlung verschiedener big-digits-Darstellungen zur Auswahl nach Bedarf gibt?

Die Idee mit der Sammlung finde ich nicht schlecht. Es gibt so viele verschiedene Display und noch mehr Design Varianten an Schriftarten.

@ agmue: Ich hätte gerne einmal die 2 :)

Ja finde ich auch eine Klasse Idee, mögliche Varianten der unterschiedlichen Displays in einer Sammlung dazustellen.

@ jurs: Es war nicht so gemeint, dass ich gleich eine neue Schriftart erstellen wollte. Wird bestimmt meinen Programmierhorizont übersteigen.

Was ich brauche, ist das Verständnis dafür, wie ich eine große Schrift ansteuere. Beispielsweise bei einer dreistelligen Zahl. Wobei sich die Ziffern ständig ändern.

Vielleicht könnt ihr mir an dieser Stelle ein wenig unter die Arme greifen?

Zum Beispiel so, musste aber noch auf I²C ändern.

/*
A set of custom made large numbers for a 16x2 LCD using the
LiquidCrystal librabry. Works with displays compatible with the
Hitachi HD44780 driver.
The Cuicuit:
LCD RS pin to D12
LCD Enable pin to D11
LCD D4 pin to D5
LCD D5 pin to D4
LCD D6 pin to D3
LCD D7 pin to D2
LCD Vee tied to a pot to control brightness
LCD Vss and R/W tied to ground
LCD Vcc to +5V
 
Ronivaldo Sampaio (ronivaldo@gmail.com) for 3 lines
2013/05/15 -> change for character with only 3 lines
Original Made by Michael Pilcher
2/9/2010
character created using:
http://mikeyancey.com/hamcalc/lcd_characters.php
*/
 
// include the library
#include <LiquidCrystal.h>
 
// initialize the interface pins
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
// the 8 arrays that form each segment of the custom numbers
byte bar1[8] =
{
B11100,
B11110,
B11110,
B11110,
B11110,
B11110,
B11110,
B11100
};
byte bar2[8] =
{
B00111,
B01111,
B01111,
B01111,
B01111,
B01111,
B01111,
B00111
};
byte bar3[8] =
{
B11111,
B11111,
B00000,
B00000,
B00000,
B00000,
B11111,
B11111
};
byte bar4[8] =
{
B11110,
B11100,
B00000,
B00000,
B00000,
B00000,
B11000,
B11100
};
byte bar5[8] =
{
B01111,
B00111,
B00000,
B00000,
B00000,
B00000,
B00011,
B00111
};
byte bar6[8] =
{
B00000,
B00000,
B00000,
B00000,
B00000,
B00000,
B11111,
B11111
};
byte bar7[8] =
{
B00000,
B00000,
B00000,
B00000,
B00000,
B00000,
B00111,
B01111
};
byte bar8[8] =
{
B11111,
B11111,
B00000,
B00000,
B00000,
B00000,
B00000,
B00000
};
 
 
 
void setup()
{
// assignes each segment a write number
lcd.createChar(1,bar1);
lcd.createChar(2,bar2);
lcd.createChar(3,bar3);
lcd.createChar(4,bar4);
lcd.createChar(5,bar5);
lcd.createChar(6,bar6);
lcd.createChar(7,bar7);
lcd.createChar(8,bar8);
// sets the LCD's rows and colums:
lcd.begin(16, 2);
 
}
 
void custom0(int col)
{ // uses segments to build the number 0
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(8);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
 
void custom1(int col)
{
lcd.setCursor(col,0);
lcd.write(32);
lcd.write(32);
lcd.write(1);
lcd.setCursor(col,1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
 
void custom2(int col)
{
lcd.setCursor(col,0);
lcd.write(5);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(6);
}
 
void custom3(int col)
{
lcd.setCursor(col,0);
lcd.write(5);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(7);
lcd.write(6);
lcd.write(1);
}
 
void custom4(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(6);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
 
void custom5(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(3);
lcd.write(4);
lcd.setCursor(col, 1);
lcd.write(7);
lcd.write(6);
lcd.write(1);
}
 
void custom6(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(3);
lcd.write(4);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
 
void custom7(int col)
{
lcd.setCursor(col,0);
lcd.write(2);
lcd.write(8);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(32);
lcd.write(32);
lcd.write(1);
}
 
void custom8(int col)
{
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(2);
lcd.write(6);
lcd.write(1);
}
 
void custom9(int col)
{
lcd.setCursor(col, 0);
lcd.write(2);
lcd.write(3);
lcd.write(1);
lcd.setCursor(col, 1);
lcd.write(7);
lcd.write(6);
lcd.write(1);
}
 
void printNumber(int value, int col) {
if (value == 0) {
custom0(col);
} if (value == 1) {
custom1(col);
} if (value == 2) {
custom2(col);
} if (value == 3) {
custom3(col);
} if (value == 4) {
custom4(col);
} if (value == 5) {
custom5(col);
} if (value == 6) {
custom6(col);
} if (value == 7) {
custom7(col);
} if (value == 8) {
custom8(col);
} if (value == 9) {
custom9(col);
}
}
 
void printRPM(int rpm) {
int m , c, d, u, number;
number = rpm;
if (number > 999) {
m = (number - (number % 1000)) / 1000;
number = number % 1000;
} else {
m = 0;
}
if (number > 99) {
c = (number - (number % 100)) / 100;
number = number % 100;
} else {
c = 0;
}
 
if (number > 9) {
d = (number - (number % 10)) / 10;
number = number % 10;
} else {
d = 0;
}
u = number;
lcd.setCursor(0, 0);
lcd.print("KMH: ");
printNumber(m, 4);
printNumber(c, 7);
printNumber(d, 10);
printNumber(u, 13);
}
 
void loop()
{
printRPM(millis() % 10000);
delay(200);
}

Schau mal hier: https://gist.github.com/ronivaldo/5587355 Da besteht eine große Ziffer jeweils aus 3 Spalten auf 2 Zeilen. Damit gehen sich 5 Ziffern auf einem 1602 Disply aus.

Der Code ist zwar nicht der aller eleganteste und vielleicht ist noch ein wenig Anpassung an dein Display nötig, aber als Anregung ist das durchaus geeignet, denke ich.

Edit: Und Scherheinz war schneller :)