www.mikrocontroller.net

Forum: Compiler & IDEs Zahl hochzählen lassen


Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Liebe Leute!

Wer meinen Thread über das ansteuern des Schieberegister-LCDs gelesen 
hat, weiß nun, was ich vorhabe.

Das Ansteuern hat dank euerer Hilfe super geklappt!

Nun möchte ich folgendermaßen fortfahren:
Ich möchte mit 3 Lichtschranken die Zeit messen, in der ein Wagen die 
Lichtschranken durchfährt. Taster-1 soll dann auf dem Display die 
verstrichene Zeit der ersten Lichtschranke, Taster-2...usw. auf dem 
Display darstellen.

Ich habe es nun mit den Arrays gemacht, wie ihr vorgeschlagen habt. 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.
Geht das "hochzählen von Zahlen" auch einfacher? mit meiner bisherigen 
variante muss ich ja für jede einzelne Zahl die "zahl"-Funktion aufrufen 
und ich noch jede Menge funktionen für die einzelnen Bitkombinationen 
schreiben


Vielen Dank!

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: johannes (Gast)
Datum:

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


Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ok, danke.

werde es daheim mal machen, bin z.zt in der arbeit.

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ABER: wie kann ich dann aus den 48 Bits, 7 Bits herausnehmnen und diese 
dann einzeln hochzählen lassen, sofern die 7 Bits so angeordnet sind, 
dass sie wie Dualsystem-mäßig stehen.

danke

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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();


Aber ich möchte C in dem Array-Muster hochzählen lassen. (Davon 
ausgegangen, dass die letzten 7 Bits von den 48 für das letzte 7-Segment 
steht)



Danke!

Autor: Falk (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@johannes

>ABER: wie kann ich dann aus den 48 Bits, 7 Bits herausnehmnen und diese
>dann einzeln hochzählen lassen, sofern die 7 Bits so angeordnet sind,
>dass sie wie Dualsystem-mäßig stehen.

1.) Du musst dich DRINGEND mit den Grundlagen von Zahlendarstellungen 
befassen!
2.) Du musst dich DRINGEND mit den Grundlagen von Zahlendarstellungen 
befassen!
3.) Du musst dich DRINGEND mit den Grundlagen von Zahlendarstellungen 
befassen!
4.) Du musst dich DRINGEND mit den Grundlagen von Zahlendarstellungen 
befassen!
5.) Du musst dich DRINGEND mit den Grundlagen von Zahlendarstellungen 
befassen!

.
.
.

99.) Du musst unterscheiden zwischen normalen variablen zur Speicherung 
von Zählerständen, Messwerten etc. und Speichern zur Speicherung von 
7-Segmentmustern.
Mit deinen Variablen für Zählerstände kan man ganz normal rechnen, in 
jeder Programiersprache. Dann braucht du eine Funktion, die diese Zahl 
in das 7-Segmentmuser umrechnet.

MfG
Falk

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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:
i++;
und nicht anders.


Peter

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ja und was soll ich jetzt tun???

Könntet ihr mir einen Code-schnipsel zukommen lassen?

Soll ich nun die Funktionen für jede einzelne Zahl, die ich gestern 
geschreieben habe, verwenden?!

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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. 
Somit waren die threads für mich auch keine Hilfe, denn, was bringt es 
mir, den code herauszukopieren, und nicht zu verstehen?!

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Falk (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Peter Dannegger

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

Naja, am Anfang braucht man sie ne ganze Weile nicht. DIDAKTIK!
Du übberrennst einen blutigen Anfänger mit viel zu viel Details die er 
im Moment nicht mal ansatzweise einordnen kann.

>Vielleicht soltest Du doch erstmal C aufm PC lernen.

Das kann man nur doppelt unterstreichen!!
Besorg die ein C-Buch, Kernighham & Ritchy oder so.
Lies es!
Mach ALLE Übungen im Buch!
Mach ein paar mehr Übungen!

Dann bist du bereit für LCDs und mehr. Im Moment fehlen die ELEMENTARE 
Grundlagen!

MFG
Falk

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Falk (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Peter Dannegger

>Brauchen tut man sie, sobald man etwas includiert.

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

Schon klar, aber . . .

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

Alles richtig, aber ich wiederhole mich. Der OP muss sich erstmal die 
elmentaren Grundlagen erarbeiten und ist im Moment mit Macros (vor allem 
in deiner umfassenden Darstellung) hoffnungslos überfordert!
Daran sieht man mal wieder, dass Grundschullehrer auch ein Knochenjob 
ist!

MFG
Falk

Autor: Stefan Kleinwort (_sk_)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@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.

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielen Dank Stefan!

So lobe ich mir das :)

Also über das Display kann ich dir im Moment wiegesagt keine Auskunft 
geben, selbst wenn ich dir eine gebe, wirst du schwer ein Datenblatt 
herbekommen, dann geht es dir so wie mir vor einigen monaten eins 
aufzutreiben ;-)


Das mit dem Display verstehe ich ja alles. Wie ich das Ansteuere und so 
ist mir klar. Ich habe nur eben schon Funktionen geschrieben für 
gemalte-Zahlen im Display von 0-6. das heißt, es sind 7 Funktionen, die 
jeweils eine Array mit 48 Feldern beinhaltet, je Funktion eben ein 
anderes Bitmuster in der Array. Anders wüsste ich eben nicht, wie ich 
die Zahlen sonst nacheinander darstellen könnte.

Ich habe mir jedoch gerade was ausgedacht, weiß aber nicht ob das 
funktionieren wird. Habe nämlich auch hier gerade nicht die Möglichkeit, 
es auszuprobieren. und zwar.

Wenn ich jetzt meine bisherigen Arrays behalte:

int male_zahl-X(void)         !!!An der Stelle von X eine Variable 
Zahl!!
{
Array[48] = {0,0,0,0,0,1,0,1........}    //Bitmuster für "9" im Display
}

Verstehst du? Dass ich eben die einzelnen darzustellenden Zahlen mit 
einer Variablen im Funktionskopf anspreche. Will ich beispielsweise eine 
"3" darstellen, so schreibe ich eine 3 an die Stelle von "X" und in 
diese Funktion dann meine Array mit dem Bitmuster von "3".

Kann ich DIESE Idee von mir mit dem Vorschlag von Dir (Stefan) umsetzen?


Vielen dank !

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
sorry Karl-Heinz, habe gerade erst deinen Thread gelesen.

Danke für die Mühe!

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

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

Ich hoffe es hilft dir weiter.


Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ok,
ich werde es jetzt erstmal so machen, dass ich die Arrays für die 
Darstellung der Ziffernstelle und die Array der Ziffer am display 
erstelle.
Dafür kann ich ja dann die Arrays von meinen bisher angefertigten 
Funktionen für die einzelnen Zahlen (Bitmuster) verwenden.

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
aber würde es denn auch so mit meinem Vorschlag gehen, den ich vorher 
geschrieben habe?! dieses X müsste wohl in die (klammern)

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: johannes (Gast)
Datum:

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

Danke!



#include <avr/io.h>



int main (void)
{

DDRB=0xFF;


PutZiffer(4, 1);


PORTB = 0b00000100;        //Load-Bit
}




//---------------------------------------------------------------------- 
------------------------



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
{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,0,0,0,0,1,1,0},   //1
{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,1,0,1,1,0,1},   //2
{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,0,0,1,1,1,1,1},   //3
{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,0,1,1,0,1,1,0},   //4
{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,0,1,1,1,0,1,0},   //5
{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,1,1,1,0,1,1},   //6
{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,0,0,0,1,1,1,0},   //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},   //8
{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,0,0,1,1,1,1,1}    //9

};



int PutZiffer(uint8_t Ziffer, uint8_t Wo)
{
uint8_t i;

int array[45];

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

Autor: Stefan Kleinwort (_sk_)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> 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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
int PutZiffer(uint8_t Ziffer, uint8_t Wo)
{
  uint8_t i;

  int array[45];

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

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.

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Fehlermeldung :

-array undeclared
-conflicting types for "PutZiffer"
-previous implicit declaration of "PutZiffer" was here

danke

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ok sorry, wegen Prototypen am Anfang ....Habe ich vergessen einzufügen 
^^

Was mir jetzt noch fehlt ist ein clock während die einzelnen Bits 
reingeschoben werden.


danke

Autor: Falk (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@johannes

Poste bitte deinen gesamten Quelltext (als ASCII im Anhang), dann kann 
man dir auch gescheit helfen. Diese schlecht kopierten Fragmente sind 
schlecht. Ebenso solltest du die Fehlermeldungen direkt und komplett 
kopieren (CTRL-C CTRL-V).

MFG
Falk

Autor: Gast (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Zu Befehl Herr Oberst!

Autor: Stefan Kleinwort (_sk_)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@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

Autor: Gast (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Stefan

Sehe ich ein, Entschuldigung; auch an Falk :)

Autor: Falk (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Gast

>Sehe ich ein, Entschuldigung; auch an Falk :)

Angenommen. Zumal ein Oberst wohl kaum "bitte" sagen würde. ;-)

MfG
Falk

P.S. Mein militärischer Rang ist WEIT über einem Oberst. ABGÄNGER! 
Minus 4000++
;-)

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Leute!
Hier mein Code: Es gibt keine compilier-Fehler mehr. Wie kann ich nun 
ansteuern?


#include <avr/io.h>

int PutZiffer(uint8_t Ziffer, uint8_t Wo);
void clock(void);

int main (void)
{

DDRB=0xFF;


PutZiffer(4, 1);
clock();
PutZiffer(3, 2);
PutZiffer(2, 2);
PutZiffer(1, 1);

PORTB = 0b00000100;        //Load-Bit
}




//---------------------------------------------------------------------- 
------------------------

/*int Dsplshow(void)
{
int i; int Array[45];
for (i=0;i<45;i++)
{
PORTB = PORTB & Array[i];
PORTB = 0b00000010 | Array[i];
PORTB = 0b00000010;
PORTB = 0b00000000;
}
}
*/

uint8_t Digit[10][7] =
{
{1,0,1,1,1,1,1},  //0
{0,0,0,0,1,1,0},  //1
{1,1,0,1,1,0,1},  //2
{0,0,1,1,1,1,1},  //3
{0,1,1,0,1,1,0},  //4
{0,1,1,1,0,1,0},  //5
{1,1,1,1,0,1,1},  //6
{0,0,0,1,1,1,0},  //7
{1,0,1,1,1,1,1},  //8
{0,0,1,1,1,1,1}   //9
};

int array[45];

int PutZiffer(uint8_t Ziffer, uint8_t Wo)
{
uint8_t i;

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


void clock(void)
{
PORTB = 0b00000010|Digit;
PORTB = 0b00000010;
}



Danke

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Edit:

Das ist das, was ich im moment habe: Am display werden schon manchmal 
zeichen angezeigt:


#include <avr/io.h>

int PutZiffer(uint8_t Ziffer, uint8_t Wo);
void clock(void);

int main (void)
{

DDRB=0xFF;


PutZiffer(4, 1);
clock();
PutZiffer(3, 2);
PutZiffer(2, 2);
PutZiffer(1, 1);

PORTB = 0b00000100;        //Load-Bit
}




//---------------------------------------------------------------------- 
------------------------

/*int Dsplshow(void)
{
int i; int Array[45];
for (i=0;i<45;i++)
{
PORTB = PORTB & Array[i];
PORTB = 0b00000010 | Array[i];
PORTB = 0b00000010;
PORTB = 0b00000000;
}
}
*/

uint8_t Digit[10][7] =
{
{1,0,1,1,1,1,1},  //0
{0,0,0,0,1,1,0},  //1
{1,1,0,1,1,0,1},  //2
{0,0,1,1,1,1,1},  //3
{0,1,1,0,1,1,0},  //4
{0,1,1,1,0,1,0},  //5
{1,1,1,1,0,1,1},  //6
{0,0,0,1,1,1,0},  //7
{1,0,1,1,1,1,1},  //8
{0,0,1,1,1,1,1}   //9
};

int array[7];

int PutZiffer(uint8_t Ziffer, uint8_t Wo)
{
uint8_t i;

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


void clock(void)
{
PORTB = 0b00000010;
}

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.


Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ja, das stimmt soweit...


Nein es hat keinen Latch-Eingang; IC:  M5219B


Belegung:

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

Segmente:

   4.Seg.          3.Seg ............................

   xxxxxxx        xxxxxxx
f  x     x b      x     x
   x  g  x        x     x
   xxxxxxx        xxxxxxx
   x     x        x     x
e  x     x c      x     x
   xxxxxxx        xxxxxxx




wofür die einzelnen Bits stehen:

0...17. Bit interessiert nicht, das sind sonderzeichen auf dem Display 
(ph-Wert, °C, +,-,....)

18.Bit - 4e
19.Bit - 4g
20.Bit - 4f
21.Bit - 4a
22.Bit - 4b
23.Bit - 4c
24.Bit - 4d
---
25.Bit - 3e
26.Bit - 3g
usw. wie oben, nur segment3, und das gleiche für Segment2 und 1

danke

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.
#include <avr/io.h>

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

#define LEITUNGEN 46

#define DATEN     0x01
#define CLOCK     0x02

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
    0, 0, 0, 0, 0, 0, 0,            // 2: e, g, f, a, b, c, d
    0, 0, 0, 0, 0, 0, 0             // 1: e, g, f, a, b, c, d
  };

void Ausgeben()
{
  uint8_t i;

  for( i = 0; i < LEITUNGEN; ++i ) {
    //
    // Die Datenleitung korrekt setzen
    //
    if( Schiebe[LEITUNGEN - i - 1] == 0 )
      PORTB &= ~DATEN;        // Die Datenleitung zum SR auf 0
    else
      PORTB |= DATEN;         // Die Datenleitung zum SR auf 1

    //
    // und einen Clock Puls nachschicken
    PORTB |= CLOCK;
    PORTB &= ~CLOCK;
  }
}

int main()
{
  DDRB = DATEN | CLOCK;    // Daten und Clockpin vom PORT auf
                           // Ausgang setzen

  Ausgeben();

  while( 1 )
    ;
}

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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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:
    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.


Autor: Matthias (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Weshalb machst Du das alles per Hand, wenn es entsprechende ICs zur 
Ansteuerung von LCD-Displays gibt ? Gerade als Anfänger solltest Du 
nicht vom hundersten ins tausendste gehen, sondern Dich auf das 
wesentliche konzentrieren.

P.S.: Es fehlt offensichtlich ein Artikel über BCD-Code ;-)

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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
...

#define DATEN     ( 1 << PB0 )
#define CLOCK     ( 1 << PB1 )
#define LOAD      ( 1 << PB2 )

...

void Ausgeben()
{
  uint8_t i;

  for( i = 0; i < LEITUNGEN; ++i ) {
    //
    // Die Datenleitung korrekt setzen
    //
    if( Schiebe[LEITUNGEN - i - 1] == 0 )
      PORTB &= ~DATEN;        // Die Datenleitung zum SR auf 0
    else
      PORTB |= DATEN;         // Die Datenleitung zum SR auf 1

    //
    // und einen Clock Puls nachschicken
    //
    PORTB |= CLOCK;
    PORTB &= ~CLOCK;
  }

  //
  // nachdem alles uebertragen wurde, einen Load Puls nach-
  // schicken, damit die Werte auf die Anzeige uebernommen
  // werden
  //
  PORTB |= LOAD;
  PORTB &= ~LOAD;
}

...

int main()
{
  DDRB = DATEN | CLOCK | LOAD;    // Daten, Clock und Latchpin vom
                                  // PORT auf Ausgang setzen

  

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@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.

Autor: Falk (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Karl heinz Buchegger

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

Du hast den Beruf verfehlt. Hättest Lehrer werden sollen. ;-)

MFG
Falk

Autor: johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
hallo!

sorry, dass ich nicht da war, mein Vater ist schwer krank und ich muss 
ständig ins Krankenhaus fahren....

Vielen Dank für euere Antworten.


@karl-heinz:

Den Load-Eingang habe ich bisher mit PORTB = 0b00000100 angesteuert. Er 
hängt also am PortB an Pin3. Der muss auf "1" geschaltet werden, wenn 
alle Bits ins Schieberegister geschoben wurden, damit der Inhalt des 
Schieberegisters auf das Display gemalt wird.

Wäre es denn nicht mit einem anderen Display (mit einem Hitachi 
44780-Driver-Chip) einfacher? 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 ;-) Umso mehr freue ich mich natürlich, wie gut ihr mir helft, denn 
, wie du schon sagtest, Programmierübung und Umgang mit µC kann ich gut 
gebrauchen


Vielen dank

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.


Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Falk (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Peter Dannegger

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

Ja.

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

Aber deine Schrittweite ist zu gross. Du rennst immer mit 
Siebenmeilenstiefeln.
;-)

MFG
Falk

Autor: pumpkin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ich finde es echt große klasse was der Karl hier macht! dickes lob an 
dieser stelle!

pumpkin

p.s.: ich will mich zwar nicht einmischen, aber vllt ist es doch besser 
wenn du ihn gleich an das "bit-gefriemel" ranlässt; imho sollte man 
gleich an die unterschiedlichen zahlensysteme rangeführt werden weil man 
damit eher ein 'feeling' für die digitaltechnik bekommt.   : )

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.