Denkfehler bei Displayansteuerung

[gru (Gast)]

Hallo,

bin grad ein bisschen durcheinandergekommen bei der LCD 
Ansteuerungsroutine, die es hier gibt.

Es wird ja erwartet, dass alle Pins an einem Port liegen und 
aufeinanderfolgend sind. Das trifft bei mir auch zu, jedoch erwartet das 
Programm für DB4-7 die Pins PB0-3. Bei mir liegt DB4-7 jedoch auf den 
Pins PB3-0. Also genau umgekehrt.

Hab nun angefangen mir Bitweise die lcd-routines.c anzusehen bzw. 
genauer was in der Funktion lcd_out() passiert.

z.B. wird mit

lcd_out( LCD_SOFT_RESET );

 auf DB4 und DB5 ein Bit gesetzt. Mit

LCD_PORT |= (data>>(2-LCD_DB));

 kriegt man das auch wieder hin. Werden nun jedoch andere Daten 
übergeben, stimmt das alles nicht mehr.

 lcd_out( LCD_SET_FUNCTION |
             LCD_FUNCTION_4BIT );

Hier z.B. wird mit der obigen Veränderung Bit 3, anstatt Bit 1 gesetzt 
(von 0 gezählt), also an DB4, anstatt an DB5.

Hat jemand eine ganz einfache Methode um das zu umgehen/anzupassen, oder 
sollte ich mich lieber nach einer anderen Routine umsehen?

[Karl H. (kbuchegg)]

gru schrieb:
> Hallo,
>
> bin grad ein bisschen durcheinandergekommen bei der LCD
> Ansteuerungsroutine, die es hier gibt.
>
> Es wird ja erwartet, dass alle Pins an einem Port liegen und
> aufeinanderfolgend sind. Das trifft bei mir auch zu, jedoch erwartet das
> Programm für DB4-7 die Pins PB0-3. Bei mir liegt DB4-7 jedoch auf den
> Pins PB3-0. Also genau umgekehrt.

Man kann es in Software ausgleichen, indem man die Bits entsprechend in 
sich spiegelt. Aber eigentlich ist das ein Fall, den man besser 'im 
Kabel' löst.

[Karl H. (kbuchegg)]

gru schrieb:

>

lcd_out( LCD_SOFT_RESET );

>  auf DB4 und DB5 ein Bit gesetzt. Mit
>

LCD_PORT |= (data>>(2-LCD_DB));

>  kriegt man das auch wieder hin.

Nein, kriegst du nicht.
Du brauchst eine Spiegelung und kein Verschieben.
Du argeumentierst gerade so: da 2+2 gleich 4 ist und das auch dasselbe 
ist wie 2*2, braucht eigentlich kein Mensch Multiplikation.

> Werden nun jedoch andere Daten
> übergeben, stimmt das alles nicht mehr.

Du zäumst das Pferd an der falschen Stelle auf.
Alles was dich interessiert, ist die eine Funktion, die 1 Byte in die 4 
Bits zerlegt und auf die Reise schickt. Diese 4 Bits musst du in sich 
spiegeln, um deine Torheit die Datenleitungen genau falsch herum 
anzuschliessen, wieder auszugleichen. So etwas macht man nicht ohne Not, 
die Bitnummern zu vertauschen. Und wenn dann nur mit vorgehaltener 
Waffe.

[gru (Gast)]

Die Platine ist leider fertig und das Display wird direkt aufgesteckt. 
Die Pins jetzt noch umzulenken wäre eine sehr unschöne Lösung.

Den Inhalt von data spiegeln wäre natürlich eine Lösung, aber ist das 
denn auch so ohne weiteres möglich? bzw. wie genau?

Hmm, sonst wäre mein weiterer Ansatz die Bitmasken in der LCD 
Headerdatei zu ändern, sodass es wieder passen dürfte.

[Karl H. (kbuchegg)]

gru schrieb:
> Die Platine ist leider fertig und das Display wird direkt aufgesteckt.
> Die Pins jetzt noch umzulenken wäre eine sehr unschöne Lösung.

Es gibt nichts was man nicht mit Teppichmesser und Fädeldraht lösen 
könnte.
In Zukunft wird es dich lehren erst mal einen Testaufbau zu machen, ehe 
du dann eine Platine ätzt (oder ätzen lässt). Das werd ich sowieso nie 
verstehen, wie man ohne Vortest, ob auch alles funktioniert, gleich mal 
eine Platine ätzt.

> Den Inhalt von data spiegeln wäre natürlich eine Lösung, aber ist das
> denn auch so ohne weiteres möglich? bzw. wie genau?

Du musst hier

static void lcd_out( uint8_t data )
{
    data &= 0xF0;                       // obere 4 Bit maskieren

// --------------------------------- <<<<<<<<<
 
    LCD_PORT &= ~(0xF0>>(4-LCD_DB));    // Maske löschen
    LCD_PORT |= (data>>(4-LCD_DB));     // Bits setzen
    lcd_enable();
}

eingreifen (das ist eine Möglichkeit).
Die Bits müssen die Plätze tauschen

    +---+---+---+---+---+---+---+---+
    |   |   |   |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+
      |   |   |   |
      |   |   |   |
      |   |   |   /
      |   |   /  /
       \   \ /  /
        \   \  /
         \ / \
          \ / \
         | \  |
         |/ \ |
         /   \|
        /|    \
       / |    |\
      |  |    | \
      |  |    |  |
    +---+---+---+---+---+---+---+---+
    |   |   |   |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+

Bit 7 kommt nach Bit 4
Bit 6 kommt nach Bit 5
Bit 5 kommt nach Bit 6
Bit 4 kommt nach Bit 7

Das 'spiegelt' die Bits genau so, dass durch die nochmalige Spiegelung 
in der Hardware wieder alles richtig rauskommt.

> Hmm, sonst wäre mein weiterer Ansatz die Bitmasken in der LCD
> Headerdatei zu ändern, sodass es wieder passen dürfte.

Das ist Quatsch. Und zwar richtig großer Quatsch.
Mach es richtig!

[spess53 (Gast)]

Hi

>Den Inhalt von data spiegeln wäre natürlich eine Lösung, aber ist das
>denn auch so ohne weiteres möglich? bzw. wie genau?

so:

Beitrag "Re: LCD Datenleitungen invertieren"

MfG spess

[Karl H. (kbuchegg)]

spess53 schrieb:
> Hi
>
>>Den Inhalt von data spiegeln wäre natürlich eine Lösung, aber ist das
>>denn auch so ohne weiteres möglich? bzw. wie genau?
>
> so:
>
> Beitrag "Re: LCD Datenleitungen invertieren"

Die spiegelt allerdings 8 Bit und ist somit hier nicht anwendbar.

[Karl H. (kbuchegg)]

eine Möglichkeit wäre zb

static void lcd_out( uint8_t data )
{
    uint8_t outData = 0;

    if( data & (1<<7) )   outData |= (1<<4);
    if( data & (1<<6) )   outData |= (1<<5);
    if( data & (1<<5) )   outData |= (1<<6);
    if( data & (1<<4) )   outData |= (1<<7);

    LCD_PORT &= ~(0xF0>>(4-LCD_DB));    // Maske löschen
    LCD_PORT |= (outData>>(4-LCD_DB));     // Bits setzen
    lcd_enable();
}

eine andere Möglichkeit wäre, die eigentliche Ausgabe

    LCD_PORT |= (data>>(4-LCD_DB));     // Bits setzen

in 4 Einzelbitoperationen aufzudröseln und sich inklusive der 
gewünschten Verschiebung durch LCD_DB zu überlegen, wo welches der 4 
interssierenden Bits wieder auftauchen muss.

Es gibt sicher auch eine clevere Methode wie man mit Bitoperationen die 
4 Bits spiegeln kann (wie es im 8 Bit Beispiel gemacht wurde), nur weiß 
ich die nicht auswendig und bin jetzt auch zu faul, das auszutüfteln.

[Rufus Τ. F. (rufus)]

Eine Konstantentabelle mit 16 Einträgen wäre auch eine Lösung.

uint8_t NibbleTabelle[] = { 0xF0, 0xE0, 0xD0, 0xC0, 0xB0 ... etc. bis 
0x10, 0x00}

Beim Zugriff wird das High-Nibble des auszugebenden Datenworts als Index 
verwendet, so daß aus

LCD_PORT = Wert;

ein

LCD_PORT = NibbleTabelle[(Wert >> 4) & 0xF];

werden kann.

Allerdings ist der Shift-Operator eine recht "teuere" Rechenoperation; 
der Compiler könnte allerdings erkennen, daß hier auf das High-Nibble 
zugegriffen wird und swap verwenden, dann ist das ganze sogar recht 
flott.

Auf diese Art und Weise ließen sich auch einzelne vertauschte 
Datenleitungen korrigieren.

[gru (Gast)]

Danke Karl Heinz!
Das genügt mir fürs erste völlig.

[Peter D. (peda)]

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=102296

[c-hater (Gast)]

Karl Heinz schrieb:

> Die spiegelt allerdings 8 Bit und ist somit hier nicht anwendbar.

Natürlich ist die (mit einer klitzekleinen Anpassung) hier anwendbar. 
Die letzte der drei Zeilen einfach durch ein "n = n & 0xf;" ersetzen. 
Das spart sogar noch ein paar Takte. Jedem, der versteht, was da 
passiert, ist das sofort klar.

Es bleibt allerdings die unbestreitbare Tatsache, daß es trotzdem recht 
teuer ist und ohne wirkliche Not nicht getan werden sollte, da gebe ich 
dir absolut Recht. EIN falsch angelöteter Stecker ist sicher kein 
hinreichender Grund. 1000 oder vielleicht auch nur 100 allerdings 
schon...