Forum: Mikrocontroller und Digitale Elektronik Schieberegister-LCD


von joh! (Gast)


Lesenswert?

Hallo Leute!

Ich steh grad vor einem richtig knackigen Problem. Ich habe ein LCD 
welches nach dem seriellen Schieberegister-Prinzip anzusteuern geht.
Es hat 4x 7-Segment-Anzeigen und diverse "Sonderzeichen" wie "°C", "kg" 
usw.
Ich kann mal einen kleinen Ausschnitt der Tabelle schreiben.

 Bit 45:   Segment: 1d
 Bit 44:   Segment: 1c
 Bit 43:   Segment: 1b
 Bit 42:   Segment: 1a
 Bit 41:   Segment: 1f
 Bit 40:   Segment: 1g
 Bit 39:   Segment: 1e

Die nächsten 3 7-Segment-Gruppen verhalten sich vom 
Bitmuster/-reihenfolge identisch.

Um nun die Daten aufs LCD schreiben zu können, müssen nacheinenader die 
Bits (in Summe 45) nacheinander ins LCD geschoben werden. Bit, Clock, 
Bit,Clock usw. und am Schluss ein LOAD-Befehl.

Das Problem an dem Ganzen ist jetzt die Umsetzung.

Ich habe mir jetzt erstmal überlegt, wie sich die dargestellten Ziffern 
von 0 bis 9 in der 7 Segment anzeigen lassen sollen.
Dazu habe ich mir eine weitere Tabelle gemacht:

Anzeige 0:   1011111    (Alle gesetzt bis auf Segment-G)
.
.
.
usw.


Nun habe ich mir in C eine Funktion geschrieben:
1
void put_LCD(float wert,char sonderzeichen)              
2
{
3
  if (wert>=0)
4
  {
5
    
6
  
7
  if (wert>9)
8
  {
9
    
10
  }  
11
  if (wert>99)
12
  {
13
14
  }
15
  if (wert>999)
16
  {
17
18
  }
19
}

Darin soll nun abgefragt werden, wie groß die Zahl (Übergabeparameter 
"wert") ist, die auf dem LCD angezeigt werden soll.. Der Sinn des ganzen 
ist, dass ich -wenn ich EINE (1!) 7-Segment-Gruppe von der Bitmaske von 
0-9 habe, diese Bitmaske auf die nächste 7-Segment-Gruppe (also dann 
zwei-drei-vierstellige Werte) mit logischen Verknüpfungen übertragen 
kann.

ich habe es mir wie folgt vorgestellt.

(anstatt 45 Nullen sinds jetzt erstma 20):

  000000 | 0000000 | 0000000       --> Würde "nichts" auf dem LCD 
anzeigen.
  000000 | 0000000 | 1101101       --> Würde eine "2" auf dem LCD 
ausgeben.
  000000 | 1101101 | 1101101       --> Würde zweistellig "22" ausgeben.

Wie aber realisiere ich das ganze in C?

Gibt es eine Array des Datentyps "bool", denn wenn ich einen 
"speichersparenden" Datentyp (z.B. char -> 8bit) nehme, dann braucht 
dieser Datentyp ja erstens mal massig Speicher und zweitens: Wie kann 
ich eine Array (deren Werte) mit einer anderen Array UND-verknüpfen?
Wenn ich es mit Arrays löse, dann brauch ich ja für JEDE Zahl von 0-9 je 
eine Array mit 45 Elementen!

Die eine Array würde z.B. "AnzahlSchieberegister[45]" heißen. Die 
default-Werte gebe ich ihr durch
1
char AnzahlSchieberegister[45] = {0,0,0,0...};

Nur wie verknüpfe ich diese Array (!!) mit beispielsweise einer define
1
#define LCD_ANZEIGE_0  0b000000000000000000000000000000000000001011111



Danke!

von Michael U. (amiga)


Lesenswert?

Hallo,

vorweg: ich programmiere nicht in C, mehr in ASM.

Du hast 45Bit, die zum Display müssen.
Also 6 Byte (48Bit), wo hinte 3 Bit unbenutzt bleiben.

Die werden also wenn nötig komplett zum Display geschoben.
Due hast einen Buffer, der die auszugebenen Zeichen enthält, also 4 Byte 
für jede Stelle und weitere Bytes für die Sonderzeichen?

Sagen wir mal 10 Byte (Du hast ja nicht verraten, wie die anderen Bits 
belegt sind).

Dein Hauptprogramm schreibt also die auszugebenden Werte in diesen 
Buffer, die Ziffern als ASCII, die Sonderzeichen dahinter definiert.

Die Umrechenroutine muß also vom Ausgabebyte erstmal 0x30 abziehen 
(ASCII-0),
dann das zugehörige Bitmuster aus der Tabelle holen, entsprechend dem 
Stellenindex im Buffer passend zurechtschieben und an die richtige 
Stelle im Ausgabebuffer ablegen.

Sind also Eingabebuffer (10 Byte?), Ausgabebuffer (6 Byte), Tabelle 
(0...9 und sonstige Zeichen, Buchstaben, ??? vielleicht so 30-40 auf 
7-Segment darstellbare Zeichen.

Speicherbedarf also so um 16 Byte im Ram für die Buffer, 40 Byte im 
Flash für die Tabelle.

Programmcode fpr die Umrechnerei in ASM wohl so um 100 Byte für Schieben 
und Maskieren der Bits und vielleicht 20 Byte fpr die Ausgabe zum 
Display.

Nun muß es nur noch C werden... ;)

Gruß aus Berlin
Michael

von Peter D. (peda)


Lesenswert?

Vergiß das mit den mönströsen Bitfeldern, das ist viel zu umständlich 
und erzeugt nur lahme Codemonster.

Hier mal ein Beispiel für ne 4-stellige LED-Anzeige:

http://home.tiscali.de/peterd/appl/soft/c51/tsm6755/index.htm


Vermutlich benutzt Dein LCD die gleiche IC-Serie, der LCD-Treiber müßte 
MM5452 heißen.


Peter

von joh! (Gast)


Lesenswert?

Danke erstmal, aber der IC auf dem LCD heißt   MSM 5219

von joh! (Gast)


Lesenswert?

Gibts denn eine Möglichkeit, den Inhalt einer Variablen (beispielsweise 
einer Char (= 8bit)) binär aufzutrennen?

beispielsweise Binär  0b01101010

Sende 1.bit, sende 2.bit, sende 3.bit usw?

Danke!

von Falk B. (falk)


Lesenswert?

@ joh! (Gast)

>Gibts denn eine Möglichkeit, den Inhalt einer Variablen (beispielsweise
>einer Char (= 8bit)) binär aufzutrennen?

Sicher, nennt sich Bitmanipulation.

MFG
Falk

von Peter D. (peda)


Lesenswert?

joh! wrote:
> Gibts denn eine Möglichkeit, den Inhalt einer Variablen (beispielsweise
> einer Char (= 8bit)) binär aufzutrennen?
>
> beispielsweise Binär  0b01101010
>
> Sende 1.bit, sende 2.bit, sende 3.bit usw?

Warum guckst Du denn meinen Code nicht einmal an?

Um Bits der Reihe nach rauszuschieben, nimmt man den Schiebeoperator:
1
dat <<= 1;


Peter

von joh! (Gast)


Lesenswert?

ich glaub du hast mich falsch verstanden...

ich habe jetz zum beispiel eine long-variable deklariert:
1
                                              Bit:   87654321      
2
long Bitmaske = 0b0000000000000000000000000000000000000000101110;


soo und jetzt will ich nacheinander Bit1,bit2,bit3,bit4,usw. von der 
Var. "Bitmaske"  auf einem Pin am AVR ausgeben.


Danke!

von joh! (Gast)


Lesenswert?

ich habe übrigens deinen Code angeschaut...Aber wie sieht es nun mit dem 
Schiebeoperator aus? Gehen mir da nicht die Bits verloren? ich schiebe 
die ja nur IN der variablen hin- und her aber was bringt mir das wenn 
ich EIN EINZIGES Bit aus der 64bit-Variable in eine andere variable 
schreiben will...

von Peter D. (peda)


Lesenswert?

joh! wrote:
> ich habe übrigens deinen Code angeschaut...Aber wie sieht es nun mit dem
> Schiebeoperator aus? Gehen mir da nicht die Bits verloren?

Na und?
Die sollen doch ins LCD, danach brauchst Du sie nicht mehr.
Außerdem gehen sie nicht verloren, die Schieberoutine kriegt eine Kopie 
als Argument übergeben.


> ich EIN EINZIGES Bit aus der 64bit-Variable in eine andere variable
> schreiben will...

Wozu solltest Du das tun wollen?
Ich denken, Du willst auf ein LCD ausgeben.

Du legst Dir ein Array mit 4 Byte an, in das Du die 4 Ziffern schreibst.
Dann rufst Du die Schieberoutine auf, die nimmt sich ein Byte, wandelt 
es nach 7-Segment und schiebt es raus.
Nachdem sie das 4-mal gemacht hat, sendest Du den Latchimpuls.

Ob bei mir Startbit oder bei Dir Latchimpuls, ist kein großer 
Unterschied.


Peter


P.S.:
Und vergiß 64Bit, das ist mit dem AVR-GCC noch aufwendiger und langsamer 
als float.
Und außerdem ist
1
long long x = 0b11000000001011000000000000000000000000001011100001;
in keinster Weise leserlich.

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.