Schieberegister-LCD vereinfachen

@Johannes

>Man schiebt in Summe 48 Bits (für die 48 Segmente) nacheinander ins LCD,
>gibt nach jedem Bit einen Clock und Lädt abschließend das
>Schieberegister über eine logische "1" am Load-Eingang in das Display.

>Nun meine Frage. Wie kann ich in C eine "Vereinfachung" schreiben. Ich

Was soll denn daran noch gross vereinfacht werden? Deine 48 Bits legst 
du sinnvoll in einem Array ab. Als Anfänger wollen wir mal ein

uint_8t daten[48];

gelten lassen, als Fortgeschrittener wirst du platzsparend ein

uint_8t daten[6];

nehmen. Das kannst du in einer einfachen Schleife in dein 
Schieberegister takten. Sind eine handvoll Zeilen Code. Wenig 
Optimierungspotential.

>muss ja schließlich für jede Veränderung des Displays die 48 Bits
>schieben,clocken und loaden.

Und?

>Wenn beispielsweise von bit20 bis bit48
>keine ungleichen werte sind, dann kann ich eine schleife machen....

Ich liebe die doppelte Verneinung ;-)
Du solltest so oder so eine Schleife machen.

MfG
Falk

P.S. Die von Jörg vorgeschlagene SPI ist nicht die Lösung deines 
Problem. Du hast noch ein grundlegendes Verständnisproblem wie man 
solche Sachen prinzipiell angeht.

wie peter zuletzt schrieb, muss ich bei jeder Änderung aufs Neue ALLE 48 
Bits schieben.

Und meine Frage war eben, wie ich beispielsweise den Zählerstand (aus 
dem Zählerregister) "direkt" auf ein LCD des von mir genannten Typs 
ausgeben kann.  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. Dann lasse ich in meiner main() abfragen in welchem Bereich 
der Zählerstand steht, und dann gebe ich beispielsweise im 100ms-Raster 
die Zahl am Display aus, dazuaddiert mit der von mir bereitgestellten 
Overflow-Variablen, wenn der Zähler von FF auf 00 geht.

Aber wie kann ich das problem eben vereinfachen?

und noch eine kleine Frage:

der Takt muss eine bestimmte Zeit auf H-pegel sein. Kann ich da einfach 
eine Schleife in einer Funktion hochzählen lassen, um damit eine 
Verzögerung hinzukriegen?


Bspl:

int Delay(laenge)
{
 for (i=0;i<laenge;i++)
 {
 }
}




int main (void)
{
 DDRA=0b00000001;     //Bit schieben ("1")

 DDRA=0b00000010;     //clocken von L nach H
 Delay(10000);         //Aufruf der Fkt. "Delay"

 DDRA=0b00000000;     //clocken von H nach L

// das ganze 48x mit verschiedenen Schiebebits

 DDRA=0b00000100;     //abschließender Load-Befehl
}

so müsste es doch klappen oder?

lol ups


DDRA/DDRB ist mit PORTA/PORTB zu ersetzen ;)    das kommt vom kopieren!

Wenn du beim Übersetzen schon die Zeitdauer für das Delay kennst 
("10000"), dann nimm die delay-Funktionen aus der avr-libc. 
http://www.nongnu.org/avr-libc/user-manual/group__util__delay.html

Willst du nun seriell etwas ausgeben oder innerhalb des Port schieben. 
Irgendwie ist mir das Ganze unklar.

Mal unterstellt du suchst eine Funktion die dir seriell etwas mit Clock 
raustakten soll dann wäre es so etwas:

1

void send_char (uint8_t dsp_char_out)  {

2

  uint8_t n;

3

4

  for (n=0; n<8; n++)  {           // Sende 8 BIT

5

  if (dsp_char_out & (0x80 >> n))  // Daten an Display ausgeben, MSB first 

6

    {

7

      PORTB |= (1 << DATA);

8

    }

9

    else

10

    {

11

      PORTB &= ~(1 << DATA);

12

    }

13

    PORTB &= ~(1 << CLOCK);        // Ausgabe des Schiebetakt, CLOCK = 0

14

    PORTB |= (1 << CLOCK);         // CLOCK = 1

15

  }

16

  wait (delay_irgendwas);

17

}

Das geht natürlich auch für deine 48 BIT.

@Johannes

>der Takt muss eine bestimmte Zeit auf H-pegel sein. Kann ich da einfach
>eine Schleife in einer Funktion hochzählen lassen, um damit eine
>Verzögerung hinzukriegen?

Nutzt für Verzögerungen die Funktionen der AVR libc, die funktionieren 
garantiert.
Ausserdem wirst du wahrscheinlich keine Delays brauche, denn die 
Schieberegister sind im allgemeinen wesentlich schneller, als du es per 
Software ansteuern kannst.

>so müsste es doch klappen oder?

Nein, du musst ein Schleife programmieren.

Hier mal die einfache Variante.

uint8_t data[48];    // Datenarray, ein Byte pro Bit

for (i=0; i<48; i++)
{
   PORTA = PORTA & data[i];    // Daten auf PA0
   PORTA = PORTA & 0x02;        // Takt auf PA1
}

   PORTA = 0;                  // Takt und Daten löschen
   PORTA = 0x04;               // LOAD am Schieberegister ist PA2
   PORTA = 0;                  // Takt, Daten und LOAD löschen

MFG
Falk

ja, die würde ich gerne nehmen, wenn sie nicht 20 % meines Speichers 
fressen würde ;)

Danke Falk, deine Löstung habe ich kurz nach deinem Thread auch 
geschrieben :)

Und zwar muss ich aber vorher noch die Array initialisieren....

array[48] {0,1,.........}


ansonsten eben die schleife, wie du es geschrieben hast.


Danke!

Peter, deine Lösung ist wahrscheinlich die Luxus-Effizienz-Super-Kanone, 
aber der OP steht glaub ich programmier-und C-technisch auf ner ganz 
anderen Stufe. Da ist Einfachheit erstmal wichtiger als Effizienz.

MfG
Falk

> da kommt ja richtig 8051-Feeling auf

Ja, die sind genial und bei mir (8051 Fan) ebenso eingepflegt ;-))

@Peter Dannegger

>Ich denke eigentlich, daß Anfänger nie früh genug damit anfangen können,
>den Code in kleine verdaubare (verstehbare) Häppchen aufzuteilen.

Ja. Auf jeden Fall.

Aber dein Code ist ausgewachsener C-Code, bei solchen Sachen wie

 __attribute__((_packed_));

wird auch mir erstmal etwas mulmig.

Und auch sowas ist nicht sonderlich für Anfänger verdaulich

for( i = 6; i; i-- ){         // 6 byte
    shift_out( *--dat );
  }
  LCD_CE = 1;                   // CE = 1 (latch data)

MfG
Falk

@ Peter Dannegger

>>  __attribute__((_packed_));

>Ist nur ein Bestandteil des Macros zur bequemen Bitdefinition (alle Bits
>werden zusammen in ein Byte "gepackt").

Das war MIR zu 99% klar. Einen Anfänger irritiert es massiv.

>> for( i = 6; i; i-- ){         // 6 byte

>Ist quasi die Standardsyntax für eine Schleife ( i = 6, also 6 mal).

Dito. Aber z.B. i als solches ist nicht sonderlich anschaulich. Jaja, 
die liebe C-Syntax. Oh wie vermisse ich Pascal seufz

ICH hab das Programm schon verstanden, aber wie gesagt. Didaktisch halte 
ich es für absolut untauglich.

Ich hoffe du verstehst mich nicht falsch. Du bist sicher absolut fit in 
der Materie, aber du kannst nur schwer auf Anfängernivau runterschalten. 
Ich hatte mal nen Prof im Studium, der war genauso. Für den war FFT und 
Laplace wie 1+1. Seine Vorlesung hab ich erst ein paar Semester später 
WIRKLICH kapiert ;-)
Es ist eine Kunst, schwierige Dinge einfach und verständlich zu 
erklären!

>Man kann diese Zeile in die einzelnen Operationen zerlegen:

>    uint8_t val;

>    dat = dat - 1;           // Zeiger runterzählen
>    val = *dat;              // Inhalt holen
>    shift_out( val );        // und ausgeben

Genau DAS würde ich machen. Der entstehende Code ist sowieso der 
gleiche. Aber die Lesbarkeit (für die wir ja als C-Programmierer 
plädieren) steigt enorm. Ausserdem verringert sich das 
"indenFusschiessenRisiko", wenn man bei diesen tierisch verketteten 
Operatoren mal wieder die Prioritäten nicht beachtet hat. ;-)

MfG
Falk