www.mikrocontroller.net

Forum: Compiler & IDEs Schieberegister-LCD vereinfachen


Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo liebe Leute!

Habe vor, mit meinem ATmega16 im AVR-Studio mit dem GCC ein LCD 
anzusteuern. Und zwar funktioniert dieses nach dem Schieberegister 
Prinzip.
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 
muss ja schließlich für jede Veränderung des Displays die 48 Bits 
schieben,clocken und loaden. Wenn beispielsweise von bit20 bis bit48 
keine ungleichen werte sind, dann kann ich eine schleife machen....


Danke!

Autor: Jörg Wunsch (dl8dtl) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Wie kann ich in C eine "Vereinfachung" schreiben.

Indem du SPI nimmst.

Autor: Falk (Gast)
Datum:

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

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sobald Du auch nur einmal schiebst, ist das ganze Bitmuster verwurstelt.

Du mußt also immer alle Bits schieben, auch wenn sich nur ein Bit 
ändert.

Ob nun HW-SPI oder SW-SPI macht in der Codegröße kaum einen Unterschied, 
das HW-SPI ist nur etwas schneller.


Vereinfachen muß man der CPU nichts, der ist egal, wie oft sie was 
wiederholen soll.
Mach Dir ne Schleife für 8 Bits, die dann 6 * aufgerufen wird.


Peter

Autor: Johannes (Gast)
Datum:

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

Autor: Johannes (Gast)
Datum:

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

Autor: Werner A. (homebrew)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das ändern des DataDirectionRegisters wird dir aber nicht viel helfen...

Autor: Johannes (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
lol ups


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

Autor: Stefan (Gast)
Datum:

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

Autor: Joe (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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:
void send_char (uint8_t dsp_char_out)  {
  uint8_t n;
  
  for (n=0; n<8; n++)  {           // Sende 8 BIT
  if (dsp_char_out & (0x80 >> n))  // Daten an Display ausgeben, MSB first 
    {
      PORTB |= (1 << DATA);
    }
    else
    {
      PORTB &= ~(1 << DATA);
    }
    PORTB &= ~(1 << CLOCK);        // Ausgabe des Schiebetakt, CLOCK = 0
    PORTB |= (1 << CLOCK);         // CLOCK = 1
  }
  wait (delay_irgendwas);
}

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

Autor: Falk (Gast)
Datum:

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

Autor: Peter Dannegger (peda)
Datum:

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

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

Was soll denn daran einfach sein. ?

Da muß man ja erst die Bitmuster auf die einzelnen Bit-Bytes aufteilen.

Das ist nicht einfach, sondern sehr aufwendig.


Peter

Autor: Johannes (Gast)
Datum:

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

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die obigen Beispiele sind ja nicht so der Brüller (bezüglich Code, SRAM, 
Laufzeit), besser gehts so:
#include <avr\io.h>
#include <inttypes.h>


struct bits {
  uint8_t b0:1;
  uint8_t b1:1;
  uint8_t b2:1;
  uint8_t b3:1;
  uint8_t b4:1;
  uint8_t b5:1;
  uint8_t b6:1;
  uint8_t b7:1;
} __attribute__((__packed__));


#define SBIT(port,pin) ((*(volatile struct bits*)&port).b##pin)


#define LCD_CLK         SBIT(PORTD, 0)  // clock
#define LCD_CLK_DIR     SBIT(DDRD, 0)
#define LCD_DAT         SBIT(PORTD, 1)  // data
#define LCD_DAT_DIR     SBIT(DDRD, 1)
#define LCD_CE          SBIT(PORTD, 2)  // chip enable
#define LCD_CE_DIR      SBIT(DDRD, 2)


void shift_out( uint8_t b )     // send byte
{
  uint8_t i;

  for( i = 8; i; i-- ){         // 8 bits
    LCD_DAT = 0;
    if(b & 0x80 )               // high bit first
      LCD_DAT = 1;
    b += b;
    LCD_CLK = 0;
    LCD_CLK = 1;
  }
}


void lcd_out48( uint8_t * dat ) // send 48 bits (= 6 byte)
{
  uint8_t i;

  LCD_DAT_DIR = 1;              // output
  LCD_CLK_DIR = 1;              // output
  LCD_CE_DIR = 1;               // output
  LCD_CE = 1;
  LCD_CLK = 1;

  LCD_CE = 0;                   // CE = 0 (enable shift register)
  dat += 6;                     // last byte first

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

Und für Delays dann noch die Funktionen aus der delay.h nehmen.


Peter

Autor: Johannes (Gast)
Datum:

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

Autor: Falk (Gast)
Datum:

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

Autor: Peter Dannegger (peda)
Datum:

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

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

Darin liegt meine Einfachheit.

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.


Peter

P.S.:
Die Bitmacros hab ich hier geklaut:

Beitrag "sbit macro für avr-gcc"

Besten Dank an Volker, da kommt ja richtig 8051-Feeling auf.

Autor: Joe (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> da kommt ja richtig 8051-Feeling auf

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

Autor: Falk (Gast)
Datum:

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

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Falk wrote:

> wird auch mir erstmal etwas mulmig.

Dann sollte man sich nicht scheuen, den Autor zu fragen.


>  __attribute__((_packed_));

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


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

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


>     dat += 6;                     // last byte first
...
>     shift_out( *--dat );

Das ist zugegeben die einzige etwas verzwickte Zeile:

dat ist der übergebene Zeiger auf das Feld mit den 6 Bytes.

Damit nun mit dem höchstwertigen angefangen wird, wurde 6 addiert und er 
zeigt hinter das Feld.

Bei jedem Schleifendurchlauf wird vor dem Zugriff wieder 1 abgezogen 
"--dat", so daß erst Byte 5, 4, 3, 2, 1 und 0 ausgegeben werden.

Man will nun aber nicht den Zeiger (Adresse) ausgeben, sondern das Byte, 
welches unter dieser Adresse abgelegt wurde und das macht der * 
Operator.

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


>   LCD_CE = 1;                   // CE = 1 (latch data)

Das ist wieder einfach: Pin CE auf 1 (high) setzen


Peter

Autor: Falk (Gast)
Datum:

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

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.