Zahl hochzählen lassen

Das klingt jetzt allerdings als hättest du eine enorme
Fleissaufgabe gemacht.

Zeig doch mal, das kann man mit Sicherheit auch in ein
paar Zeilen Code samt einer Tabelle abhandeln.

Johannes wrote:

> Ich habe es nun mit den Arrays gemacht, wie ihr vorgeschlagen habt.

Welches denn, Bits oder Bytes ?


> Ich
> habe jetzt lauter Funktionen geschrieben, jede Funktion für eine Zahl in
> einem Segment. Das es in Summe 4 x 7-Segment sind, und jeweils eine Zahl
> von 0-9, habe ich so viele Funktionen geschrieben.

Ich dachte, Du weißt bereits, was ein Array ist.
Dann mach einfach ein Array aus 10 Bytes mit den 7-Segment-Mustern.

Ich nehme mal an, daß die 48 Bits = 6 * 7-Segment sind.
Dann nimmst Du jede Ziffer als Arrayindex und schreibst den Arraywert in 
das Array mit den 6 Ausgabebytes.


> Geht das "hochzählen von Zahlen" auch einfacher?

Gerechnet wird C-intern immer Binär (8, 16 oder 32Bit breit).


Peter

johannes wrote:
> die 48 bits sind nicht (!) für 6 7-segment-anzeigen. Es sind in Summe
> 4x7-Segment-Anzeigen plus Sonderzeichen (ph-Wert,°C,+,-,.....)

Ist auch kein Beinbruch.

Du solltest erstmal die komplette Segmentzuordnung rauskriegen.

Wenn eine Ziffer nicht in nur einem Byte liegt, muß man sie eben auf die 
2 Byte aufteilen (schieben + maskieren).


Peter

johannes wrote:
> bei mir siehts so aus:
>
> array[48] = {0,0,0,0,0,1.......}  // Da steht momentan noch  jeweils das
>
> Bitmuster für jede einzelne zahl.

Genau das habe ich natürlich kommen sehen, als ich sagte:

> Ich halte es im Gegenteil für komplizierter, die 48 Bits als monolitisch
> verschweißten Block zu betrachten. Spätestens, wenn er dann die
> einzelnen Ziffern drauf aufteilen will, wirds haarig.



Du must Dir die Antworten natürlich auch durchlesen:

Beitrag "Re: Schieberegister-LCD vereinfachen"


> Aber ich möchte C in dem Array-Muster hochzählen lassen.

Das ist viel zu aufwendig. In C zählt man:

1

i++;

und nicht anders.


Peter

johannes wrote:
> zum Thema, "Thread anschauen",
>
> wie ihr wisst, bin ich blutiger Anfänger in Sachen Mikrocontroller UND
> C, darum lohnt es dann auch nicht die Threads anzuschauen, wenn es um
> Makros geht und mir nicht mal mitgeteilt wird, was das überhaupt ist.

Der Link, auf den ich verwies, hat gar keine Macros.

Hier nochmal der Linkinhalt direkt:
=======================================================================
Johannes wrote:

> Ich kann natürlich eine Funktion schreiben, in der ich
> für jede einzelne Zahl auf dem Display von 1-1000 jeweils 48 Bitmuster
> schreibe.

Sag bloß, Du hast in der Schule alle Zahlen 0...1000 auswendig gelernt.

Ich hab nur die Ziffern 0..9 gelernt und genau so macht man es eben in
der CPU:

- Zahl in Ziffern zerlegen
- Bitmuster pro Ziffer aus Tabelle lesen
- alle Bitmuster in die 6 Bytes reinschreiben
- die 6 Bytes rausschieben.
=======================================================================


Peter

johannes wrote:

> Makros geht und mir nicht mal mitgeteilt wird, was das überhaupt ist.

Dann mußt Du es lernen, C ohne Macros geht nicht.

Vielleicht soltest Du doch erstmal C aufm PC lernen.

Hier z.B. der Hilfetext aus Borland C++ zu Macros:

=======================================================================
  ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
   #define (Anweisung)
  ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
 Definiert ein Makro.

  Syntax:  #define <Bez1>[( <Bez2>, ... )] <Bezeichnerstring>

 Makros stellen einen Mechanismus zum Ersetzen von Symbolen bereit, mit 
oder
 ohne funktionsähnlichen Parametern. Alle folgenden Vorkommen von <Bez1> 
im
 Quelltext werden durch den in <Bezeichnerstring> angegebenen Text 
ersetzt.

 Wenn unmittelbar auf <Bez1> eine runde Klammer folgt, behandelt der
 Präprozessor folgende Bezeichner (<Bez2> usw.) nicht als Teil des
 Bezeichnerstrings, sondern als Parameter einer Funktion.

 Alle Vorkommen von <Bez2> im Bezeichnerstring werden durch den jeweils 
dafür
 definierten Text ersetzt, wenn <Bez1> im Quelltext referenziert ist.

 Das Zeichen \ dient als »Zeilenverlängerung«.

  Beispiel
  ▀▀▀▀▀▀▀▀
   #define MAXINT 32767
   #define ctrl(x) ((x) \
     - 64)  /* Fortsetzung der vorhergehenden Zeile */

 Es ist legal, aber nicht sehr günstig Schlüsselwörter von Borland C++ 
als
 Makrobezeichner zu verwenden. Beispielsweise ist

    #define int long

 legal, aber höchstwahrscheinlich katastrophal.

 Die folgenden globalen Bezeichner dürfen nicht unmittelbar nach einer
 #define- oder #undef-Anweisung angegeben werden:

    _DATE__    __FILE__    __LINE_
    _STDC__    __TIME_


 Siehe auch:
   #undef
   #if
   Symbole verbinden
======================================================================== 
=


Peter

Falk wrote:
> @Peter Dannegger
>
>>Dann mußt Du es lernen, C ohne Macros geht nicht.
>
> Naja, am Anfang braucht man sie ne ganze Weile nicht. DIDAKTIK!

Brauchen tut man sie, sobald man etwas includiert.

Es mag einem vielleicht nicht bewußt sein, aber Includes strotzen nur so 
vor Macros.

Und es schadet auch nichts, zu wisssen, daß Includes lesbarer Quelltext 
sind.

Z.B. wenn man mal nicht weiß, wie eine Funktion genau heißt und welche 
Parameter sie benötigt, schaut man eben im Include nach.


Peter

Hallo Johannes,

Du musst 3 Sachen unterscheiden:

* Zahlen

* Ziffern
  Eine Ziffer kann Werte zwischen "0" und "9" haben, sie ist der Wert
  EINER Stelle in einer Zahl.

* Graphische Darstellung von Ziffern auf Deinem LCD
  Wahrscheinlich werden die Ziffern auf Deinem LCD NICHT im Binärformat
  angezeigt, sondern als eine (sehr einfache) graphische Darstellung.
  Jedes Bit schaltet ein Segment an. Um eine Ziffer darzustellen, musst 
Du das graphische Muster dieser Ziffer auf das LCD ausgeben.

Da ich Dein Display nicht kenne, ein Beispiel: Im Display seien die 
Segmente so angeordnet:

  00000
 1     2
 1     2
 1     2
  33333
 4     5
 4     5
 4     5
  66666   7

Um eine "1" auf Dein LCD zu "malen", musst Du die Segmente 2 und 5 
einschalten.
Um eine "0" zu malen, die Segmente 0, 1, 2, 4, 5 und 6.
Wie Du siehst, hat das Ganze nichts mit einer Binärdarstellung zu tun!

Um Ziffern darzustellen, solltest Du nicht für jede Ziffer eine eigene 
Funktion schreiben, sondern eine einzige Funktion, die als Parameter den 
Wert der Ziffer bekommt und diese auf das LCD ausgibt:

void male_ziffer_auf_lcd(uint8_t ziffer){
  ...
}

Du solltest also so vorgehen:

* Funktion schreiben, um eine Ziffer auf dem LCD auszugeben
* Funktion so erweitern, dass eine Ziffer an alle 4 Positionen des LCD
  geschrieben werden kann.
* Erst wenn Du an alle 4 Positionen des LCD Ziffern schreiben kannst,
  kannst Du die Ausgabe Deiner Zahl angehen.

* Wenn Du weitere Hilfe brauchst, solltest Du posten, welches Display Du
  verwendest und wie die einzelnen LCD-Segmente darin angeordnet sind.

Viele Grüße, Stefan

@Peter, Falk
Ich gehe mit Peter konform, dass eine Bit-Array Lösung
besser wäre. Allerdings sehe ich auch, dass Johannes damit
völlig überfordert wäre. Die Byte-Array Lösung hat einen
grossen Vorteil: Es sieht so aus als ob er sie verstehen würde.
Daher mach ich dort weiter.

@Johannes
> bei mir siehts so aus:
>
> array[48] = {0,0,0,0,0,1.......}  // Da steht momentan noch
>                                   //  jeweils das Bitmuster
>                                   //  für jede einzelne zahl.
>
> Jedes Array-Muster habe ich in eine Funktion gefasst:
> bspl:
>
> segment-1_zahl8();

Das war unnötig.

Mach dir eine Tabelle, in der für jede einzelne Ziffer,
das Muster enthalten ist.

uint8_t Digit[10][7] = {
    { 1, 0, 0, 1, 0, 1, 1 },      // Bitmuster für 0
    { 0, 1, 0, 1, 0, 1, 1 },      // Muster für 1
    { 0, 1, 0, 1, 1, 0, 0 },      // Muster für 2
    ....
    { 1, 1, 0, 0, 1, 1, 0 }       // Muster für 9
};

Die 0-en und 1-en hab ich jetzt zufällig eingesetzt, da musst
du natürlich deine konkreten Werte einsetzen.

Soweit so gut.
Angenommen, da hast jetzt eine einzelne Ziffer (keine Zahl!)
und du willst diese Ziffer an einer bestimmten Stelle in deiner
Anzeige stehen haben. Dann musst du doch das jeweilge Muster
für diese Ziffer, welches du aus der Tabelle erhältst, in
dein 48-er Array an eine bestimmte Stelle schreiben.
Ich geh mal davon aus, dass das 48-Array so organisiert ist, das
ab Array Position 0 die erste Stelle beginnt, ab Array Position 7
die zweite Stelle, ab 14 die dritte Stelle, etc. Wenn das
bei dir nicht so ist, dann musst du etwas anpassen.

Gesucht ist also eine Funktion, die eine Ziffer übernimmt und
der man sagt an welcher Display-Position diese Ziffer aufscheinen
soll:

void PutZiffer( uint8_t Ziffer, utin8_t Wo )
{

Das Bitmuster welches in die Anzeige geschrieben werden muss,
erhält man ganz leicht: Dafür ist die Tabelle Digit zuständig.
Alles was du tun musst, ist mit Ziffer als Index in dieses
Array zu gehen und die Indexpositionen 0 bis 7 sagen dir dann
ob eine 0 oder eine 1 in das 48-er Array muss. Nur an welche
Stelle vom 48-er Array muss diese 0 oder 1? Das kann man sich
ausrechnen. Wir wissen ja, dass für jede Ziffer genau 7 Einträge
benötigt werden, also beginnt die n-te Ziffer an der Array-
Position n * 7. Und wir wissen natürlich auch, dass für
jede Ziffer genau 7 Einträge zu setzen sind.

In Summe ist das dann:

void PutZiffer( uint8_t Ziffer, utin8_t Wo )
{
  uint8_t i;

  for( i = 0; i < 7; ++i )
    array[ Wo * 7 + i ] = Digit[ Ziffer][ i ];
}

Fertig. Um also die Zahl 0175 an die Display Stellen
3 4 5 und 6 zu schreiben, genügt es folgendes aufzurufen:

   PutZiffer( 0, 3 );
   PutZiffer( 1, 4 );
   PutZiffer( 7, 5 );
   PutZiffer( 5, 6 );

Jeder PutZiffer Aufruf schreibt das jeweilige korrekte 'Bitmuster'
für die übergebene Ziffer in das 48-er Array und zwar an
die jeweils richtige Position, sodass beim Raustakten die
0 oder 1 an der richtigen Stelle zu liegen kommt.

array ist übrigens ein denkbar schlechter Name für diese
Variable. Variablennamen werden nach der Funktion der Variable
gewählt, nicht nach dem Datentyp. Die Funktion dieser Variablen
ist es nicht Array zu sein, sondern als Zwischenspeicher für das
Hinaustakten der Bits zu dienen. 'BitBuffer' wäre in der
Tat ein wesentlich besserer Name dafür, da er beschreibt, wozu
diese Variable benutzt wird.

Soweit, so gut.
Du hast aber nicht einzelne Ziffern, sondern du hast eine
Zahl, die du darstellen möchtest. Die Frage ist daher,
wie man eine Zahl in einzelne Ziffern zerlegt.
Das geht ganz einfach mittels Division durch 10 und
entsprechende Restbildung.

   7492  % 10             ->  2
   7492  / 10    ->  749

    749  % 10             ->  9
    749  / 10   ->   74

     74 % 10              ->  4
     74 / 10   ->    7

      7 % 10              ->  7
      7 / 10   ->    0

Wenn du dir die rechte Spalte ansiehst, dann tauchen,
in umgekehrter Reihenfolge, die einzelnen Ziffern der
Zahl auf. Die Zahl war 7492. Die Ziffer sind 2 9 4 7

Um eine 4 stellige Zahl also in einzelne Ziffern zu
zerlegen und diese Ziffern in die Anzeige übertragen zu
lassen, kannst du eine Funktion machen:

void PutZahl( uint16_t Zahl, uint8_t Wo )
{
  uint8_t Ziffer;

  Ziffer = Zahl % 10;
  PutZiffer( Ziffer, Wo + 3 );
  Zahl = Zahl / 10;

  Ziffer = Zahl % 10;
  PutZiffer( Ziffer, Wo + 2 );
  Zahl = Zahl / 10;

  Ziffer = Zahl % 10;
  PutZiffer( Ziffer, Wo + 1 );
  Zahl = Zahl / 10;

  Ziffer = Zahl % 10;
  PutZiffer( Ziffer, Wo + 0 );
  Zahl = Zahl / 10;
}

und jetzt hast du alles beisammen um zb. sowas
machen zu können:

int main()
{
  uint16_t Zaehler = 0;

  for( Zaehler = 0; Zahler < 2000; Zaehler += 5 ) {
    PutZahl( Zaehler, 0 );
    Das_48_Array_ausgeben();
  }
}

Zaehler ist eine ganz normale int-Variable, mit der du rechnen
kannst, wie du lustig bist. Die Funktion PutZahl übernimmt
diese Zahl, zerlegt sie in die einzelnen Ziffern und benutzt
jeweils die Funktion PutZiffer um jede Ziffer an die korrekte
Position ausgeben zu lassen. Die Funktion PutZiffer wiederrum
erledigt die Umsetzung jeder einzelnen Ziffer in das entsprechende
Muster, welches in das 48-er Array an die jeweilig korrekte
Position geschrieben werden muss.

Falk hat recht: du solltest dir wirklich etwas Literatur
besorgen und vorab auf dem PC ein paar Übungen durchführen.
Arbeiten mit Arrays ist absolutes Grundlagenwissen.

johannes wrote:
> sorry Karl-Heinz, habe gerade erst deinen Thread gelesen.
>
> Danke für die Mühe!

Ich hoffe es hilft dir weiter.

johannes wrote:
> aber würde es denn auch so mit meinem Vorschlag gehen, den ich vorher
> geschrieben habe?! dieses X müsste wohl in die (klammern)

Selbst wenn das syntaktisch gehen würde (was es nicht tut):
Dann landest du wieder unnötigerweise bei einem
Haufen Funktionen.

>soo...habe jetzt mal nach dem Schema gearbeitet. Es tritt aber noch ein
>Compilier-Fehler auf. Wo ist der ???

Die Frage stellen wir uns auch.
Normalerweise sagt der Compiler Dir, was nicht stimmt. Wenn Du das nicht 
verstehst, solltest Du wenigstens die Fehlermeldung posten.

Stefan

> uint8_t Digit[10][7] =
> {
>
> {0,0,0,0,0,0,0,0,0,0,0,0,
>  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1},
//0


Wie bitte soll den der Compiler diese Zahlenwust in
7 Stück uint8_t unterbringen?

Du brauchst nur 7 Stück für das Muster für 1 Digit.
Vergiss doch mal die 48. Die 48 hast du erst dann
wenn alles zusammengestellt ist und fertig zum raustakten
auf das Schieberegister.

1

int PutZiffer(uint8_t Ziffer, uint8_t Wo)

2

{

3

  uint8_t i;

4

5

  int array[45];

6

7

  for (i=0;i<7;i++)

8

  {

9

    array[Wo * 7+i] = Digit [Ziffer][i];

10

  }

11

}

Wie soll das den funktionieren?
array kann keine lokale Variable sein. Du brauchst mehrere
PutZiffer Aufrufe um die komplette Zeile zusammenzusetzen.
Ergo muss das Array in dem alles zusammenkommt den Aufruf
von PutZiffer überleben. Ergo muss dieses Array eine
globale Variable sein.

@Gast:
Wenn Du mit Falk Probleme hast, dann trag das bitte in dem Thread aus, 
in dem Deine Probleme begonnen haben.

Unter "Gast" so einen Müll zu posten ist peinlich und feige.

Stefan

So wird das nichts.
Fangen wir nochmal ganz am Anfang an.

Du hast also eine Anzeige die über ein
Schieberegister angeschlossen wird.

Das Schieberegister verfügt über 45 Stellen.

Angeschlossen ist das Schieberegister am Port B
und zwar so:

PORTB
   Bit 0       Daten
   Bit 1       Clock

Um ein Datenbit in das Schieberegister zu übernehmen,
wird der Dateneingang je nachdem mit einer 0 oder einer
1 belegt und danach ein Clock-Impuls erzeugt. Ein Clock
Impuls bedeutet: Die Clockleitung geht auf 1 und danach
wieder auf 0.

Stimmt das soweit? Welches Schieberegister ist das überhaupt
(IC Nummer). Hat das einen Latch Eingang?

Die 45 Stellen im Schieberegister, wie sind die belegt?

   0 ... 7       Digit 1, Segmente a - g ( 0 ist a, 1 ist b, etc
   8             Dezimalpunkt für Digit 1
   9 .. 16       Digit 2, Segmente a - g ( 9 ist a, 10 ist b, etc
   17            Dezimalpunkt für Digit 2
   18 .. 25      Digit 3, Segmente a - g ( 18 ist a, 19 ist b, etc
   26            Dezimalpunkt für Digit 3
   27 .. 34      Digit 4, Segmente a - g ( 27 ist a, 28 ist b, etc
   35            Dezimalpunkt für Digit 4
   36 .. 45      andere Anzeigen, bzw. Led


Jedes einzelne Digit hat folgende Zuordnung

          d
      *********
              
   c           e
         b    
      *********
              
   a           f
         g    
      *********

Eine LED leuchtet auf, wenn der entsprechende Ausgang auf 1
gezogen wird.

Korregier für mich erstmal diese Anschlussbelegung, damit
wir mit konkreten Dingen arbeiten können.

Mal nachzählen:
0 bis 17  uninteressant
18 bis 24  Segment 4
25 bis 31  Segment 3
32 bis 38  Segment 2
39 bis 45  Segment 1

Das ( 0 bis 45 ) sind aber 46 Leitungen, nicht 45!


OK, nachdem jetzt die Hardware soweit geklärt ist:
fangen wir an.

Der erste Schritt ist mal irgendwas auf die Anzeigen zu
kriegen. Dazu bauen wir uns mal das Array auf und sehen
zu, dass dieses korrekt auf das Schieberegister rausgetaktet
wird.

1

#include <avr/io.h>

2

3

//       a

4

//    xxxxxxx

5

// f  x     x b

6

//    x  g  x

7

//    xxxxxxx

8

//    x     x

9

// e  x     x c

10

//    xxxxxxx

11

//       d

12

13

#define LEITUNGEN 46

14

15

#define DATEN     0x01

16

#define CLOCK     0x02

17

18

uint8_t Schiebe[LEITUNGEN] = 

19

  { 0, 0, 0, 0, 0, 0, 0, 0, 0,      // 0 bis 9: uninteressant

20

    0, 0, 0, 0, 0, 0, 0, 0, 0,      // 10 bis 17: uninteressant

21

    0, 0, 0, 0, 0, 0, 0,            // 4: e, g, f, a, b, c, d

22

    0, 0, 0, 0, 0, 0, 0,            // 3: e, g, f, a, b, c, d

23

    0, 0, 0, 0, 0, 0, 0,            // 2: e, g, f, a, b, c, d

24

    0, 0, 0, 0, 0, 0, 0             // 1: e, g, f, a, b, c, d

25

  };

26

27

void Ausgeben()

28

{

29

  uint8_t i;

30

31

  for( i = 0; i < LEITUNGEN; ++i ) {

32

    //

33

    // Die Datenleitung korrekt setzen

34

    //

35

    if( Schiebe[LEITUNGEN - i - 1] == 0 )

36

      PORTB &= ~DATEN;        // Die Datenleitung zum SR auf 0

37

    else

38

      PORTB |= DATEN;         // Die Datenleitung zum SR auf 1

39

40

    //

41

    // und einen Clock Puls nachschicken

42

    PORTB |= CLOCK;

43

    PORTB &= ~CLOCK;

44

  }

45

}

46

47

int main()

48

{

49

  DDRB = DATEN | CLOCK;    // Daten und Clockpin vom PORT auf

50

                           // Ausgang setzen

51

52

  Ausgeben();

53

54

  while( 1 )

55

    ;

56

}

Das sollte mal alle Anzeigen löschen. Nichts darf leuchten.
Es geht nur darum, mal ein Anfangsprogramm zu haben. Wenn
du einen Messpark hast, müsstest du eigentlich am Clock
Ausgang die 46 Impulse sehen, die jeweils eine 0 durch
das Schieberegister treiben.

(Ich habe keinen gcc Compiler hier, kann hier also
nicht compilieren.  D.h. es ist durchaus
moeglich, dass ich da einen oder zwei Syntaxfehler eingebaut
habe. Wenn dem so ist, dann sag mir Bescheid)

Jetzt wollen wir mal an den Anzeigen was sehen. Und zwar
wollen wir an der Anzeige 2 eine '0' anzeigen.
Dazu muessen laut Tabelle:

      a
   xxxxxxx
f  x     x b
   x  g  x
   xxxxxxx
   x     x
e  x     x c
   xxxxxxx
       d

die LEDs  a, b, c, d, e und f auf 1 gesetzt werden.
Dies entspricht einem Schieberegister Array:

uint8_t Schiebe[LEITUNGEN] =
  { 0, 0, 0, 0, 0, 0, 0, 0, 0,      // 0 bis 9: uninteressant
    0, 0, 0, 0, 0, 0, 0, 0, 0,      // 10 bis 17: uninteressant
    0, 0, 0, 0, 0, 0, 0,            // 4: e, g, f, a, b, c, d
    0, 0, 0, 0, 0, 0, 0,            // 3: e, g, f, a, b, c, d
    1, 0, 1, 1, 1, 1, 1,            // 2: e, g, f, a, b, c, d
    0, 0, 0, 0, 0, 0, 0             // 1: e, g, f, a, b, c, d
  };

ändere das mal so um und lass das Programm laufen.
Ist die '0' an der Anzeige sichtbar?
(Das ist der erste Schritt. Getestet wird damit
* ob die Zuordnung der Arraypositionen zu den Hardwarepins
  stimmt
* ob das Raustakten funktioniert

Prüfe das mal.

Eine Frage hab ich noch:

Wenn du sagst: 0.Bit

ist das dann das Bit am Eingang des Schieberegisters oder
am anderen Ende.


 Daten
  |
  |
  v
  +--+--+--+--+--+--+--+--+--+-    -+--+--+--+
  |  |  |  |  |  |  |  |  |  |      |  |  |  |
  +--+--+--+--+--+--+--+--+--+-    -+--+--+--+

    ^                                       ^
    |                                       |
  Ist das hier das Bit 0                    |
                                            |
                                            |
                       oder ist das hier das Bit 0

Ich bin jetzt mal davon ausgegangen, dass das Bit 0
an dem Ende liegt an dem die Daten eingespeist werden.
Daher auch:

1

    if( Schiebe[LEITUNGEN - i - 1] == 0 )

weil ja zuerst das am weitesten rechts liegende Bit
in das SR eingespeist werden muss, damit es nach
46 Clock-Takten ganz rechts zu liegen kommt.

Matthias wrote:
> Weshalb machst Du das alles per Hand, wenn es entsprechende ICs zur
> Ansteuerung von LCD-Displays gibt ?

Da kommt dann sowies noch ein dicker Hund auf ihn zu.
Ich sag nur: Gleichspannungsfreie Ansteuerung.
Im Moment hab ich noch keine Idee wie ich ihm das
naeher bringen werde.

:-)

Aber zur Übung wie man mit einem Scheiberegister umgeht
und ein bischen Programmierübung ist es schon ganz
brauchbar. So wie es aussieht kann er beides gut gebrauchen.

Karl heinz Buchegger wrote:
> Matthias wrote:
>> Weshalb machst Du das alles per Hand, wenn es entsprechende ICs zur
>> Ansteuerung von LCD-Displays gibt ?
>
> Da kommt dann sowies noch ein dicker Hund auf ihn zu.
> Ich sag nur: Gleichspannungsfreie Ansteuerung.
> Im Moment hab ich noch keine Idee wie ich ihm das
> naeher bringen werde.

Das nehm ich wieder zurück:
Der 5219 ist ein kompletter LCD Ansteuerbaustein.

PS: Der hat sehr wohl einen Latch Eingang. Beim 5219
heist der "Load".
Johannes: Was hast du mit diesem Eingang gemacht?
Der muss auch angesteuert werden.

Ich geh mal davon aus, dass der ebenfalls am PORTB hängt
und zwar am Pin PB2

1

...

2

3

#define DATEN     ( 1 << PB0 )

4

#define CLOCK     ( 1 << PB1 )

5

#define LOAD      ( 1 << PB2 )

6

7

...

8

9

void Ausgeben()

10

{

11

  uint8_t i;

12

13

  for( i = 0; i < LEITUNGEN; ++i ) {

14

    //

15

    // Die Datenleitung korrekt setzen

16

    //

17

    if( Schiebe[LEITUNGEN - i - 1] == 0 )

18

      PORTB &= ~DATEN;        // Die Datenleitung zum SR auf 0

19

    else

20

      PORTB |= DATEN;         // Die Datenleitung zum SR auf 1

21

22

    //

23

    // und einen Clock Puls nachschicken

24

    //

25

    PORTB |= CLOCK;

26

    PORTB &= ~CLOCK;

27

  }

28

29

  //

30

  // nachdem alles uebertragen wurde, einen Load Puls nach-

31

  // schicken, damit die Werte auf die Anzeige uebernommen

32

  // werden

33

  //

34

  PORTB |= LOAD;

35

  PORTB &= ~LOAD;

36

}

37

38

...

39

40

int main()

41

{

42

  DDRB = DATEN | CLOCK | LOAD;    // Daten, Clock und Latchpin vom

43

                                  // PORT auf Ausgang setzen

@Johannes

Was ist los?
Mitlerweile musst du das doch am Laufen haben oder
sagen können das es nicht geht, bzw. was nicht geht.

Ich steh schon in den Startlöchern für den nächsten Schritt.

johannes wrote:
> Den Load-Eingang habe ich bisher mit PORTB = 0b00000100 angesteuert. Er
> hängt also am PortB an Pin3.

OK.
Also genau so wie ich es angenommen habe.

(Noch was: Gewöhn dir an dass wir bei 0 anfangen zu zählen.
0b00000100 ist Pin 2, nicht Pin 3:  0, 1, 2

> Der muss auf "1" geschaltet werden, wenn
> alle Bits ins Schieberegister geschoben wurden, damit der Inhalt des
> Schieberegisters auf das Display gemalt wird.

Ganz genau.
Die Codeerweiterung, die ich zuletzt gemacht habe, macht genau das.

>
> Wäre es denn nicht mit einem anderen Display (mit einem Hitachi
> 44780-Driver-Chip) einfacher?

Von der Softwareseite her ist es auch nicht unbedingt
einfacher. AUch für so ein LCD muss man erst mal eine
Ansteuerung programmieren. Die ist, grade im Bereich der
Initialisierung, sogar etwas aufwändiger.

Allerdings ist so ein LCD dann universeller, da man auch
Zeichen damit anzeigen kann und vor allem: Es passt wesentlich
mehr aufs Display.

> Weil bevor ich jetzt die Kirche ins Dorf
> trage, kaufe ich mir lieber um 3 Euro ein anderes Display, das ohnehin
> mehr "kann" als mein 7-Segment-Display.
> Ich möchte schließlich auch nicht, dass ihr euch jetzt reinstresst wegen
> mir ;-)

Von 'reinstressen' kann keine Rede sein.

Ich halte es ja immer noch für einen Fehler 48 Bytes statt 48 Bits zu 
nehmen.

Vielleicht sollte man erst mal lernen, daß ein Byte aus 8 Bits besteht 
und wie man die Bits eines Bytes anspricht (AND, OR, Schieben).

Z.B. mit 8 Tasten und 8 LEDs (STK500).

Grundlagenwissen sollte man nicht überspringen.


Peter

Peter Dannegger wrote:
> Ich halte es ja immer noch für einen Fehler 48 Bytes statt 48 Bits zu
> nehmen.
>
> Vielleicht sollte man erst mal lernen, daß ein Byte aus 8 Bits besteht
> und wie man die Bits eines Bytes anspricht (AND, OR, Schieben).
>
> Z.B. mit 8 Tasten und 8 LEDs (STK500).
>
> Grundlagenwissen sollte man nicht überspringen.

Ich geb dir grundsätzlich recht.
Allerdings kommen dann auf Johannes einige Lektionen
in Bitpfriemelei zu. Und da steh ich eher auf dem Standpunkt:
eines nach dem anderen. Er hat so schon Schwierigkeiten, da jag
ich ihn nicht da auch noch hinein. 7 Bits in einem Array von
6 Bytes an eine beliebige Stelle einsetzen, ist nicht so ohne
wenn man gerade frisch angefangen hat. Er braucht ja auch ein
paar schnelle Erfolgserlebnisse :-)

Erst bringen wirs mal zum Laufen, dann optimieren wir den
Speicherverbrauch. Ob das jetzt 48 Bytes oder 48 Bits sind,
spielt ja ausserhalb dieser paar Funktionen keine grosse
Rolle (vom Speicherverbrauch mal abgesehen), das ist also
auch im Nachhinein, wenn er erst mal ein bischen Sicherheit
hat, noch austauschbar.

Peter. Nichts gegen dich. Ich hab im Bereich µC-Programmierung
viel von dir gelernt. Aber du tendierst dazu einem Neuling
zu komplexe Dinge in einem Rutsch an den Kopf zu werfen, weil
du ihm natürlich die elegantesten und sparsamsten Funktionen
zeigen willst. Nur: Einem Neuling ist damit selten geholfen.
Der hat (noch) ganz andere Probleme als ein paar Byte hier
und da, ein paar Zyklen hier und da einzusparen. Für Neulinge
sind if und for noch geheimnisvoll, von einem halbwegs
vernünftigen Programmaufbau mit sinnvollen Funktionen mal
gar nicht geredet. Überspitzt ausgedrückt gibst du gerne Tips
wie man an einen New York Marathon herangeht, wenn der Neuling
sich grade mal von allen Vieren erhoben und noch wackelig auf
2 Beinen steht.

Karl heinz Buchegger wrote:

> Überspitzt ausgedrückt gibst du gerne Tips
> wie man an einen New York Marathon herangeht, wenn der Neuling
> sich grade mal von allen Vieren erhoben und noch wackelig auf
> 2 Beinen steht.

Ganz so eng würde ich es nicht sehen

Ob Top-down oder Bottom-up beides kann zielführend sein.

Und ich bin eben mehr für Bottom-up.


Peter