lookup verständnis

[Dennis G. (hans_angemeldet)]

Guten Abend,
Ich hab ein LCD welches vom Umfang her mit seinen Datenleitungen einfach 
nicht anderst angeschlossen werden kann als gespiegelt.
Da ich die Routinen und den Rest schon fertig habe, muss ich ja aber das 
Byte, also die 8 Bits immer Spiegeln, und das vor jeder Datenübertragun!

Ich hab da mal was von LookUp-Tables gelesen, da ich den ATmega2561 auf 
meiner Platine habe geht es mir auch nicht um den Speicherverbrauch, 
also denke ich wird das das Sinnvollste (wenn auch nicht die schönste) 
Methode sein meine 8 Bits immer zu spiegeln.

Leider habe ich da ein kleines Verständnisproblem bei der Ausführung 
meines Plans. Wie muss ich das Table und meine Funktion schreiben, dass 
ich nacher ein gespiegeltes Byte hab?

Hoffe es ist alles verständlich und ihr könnt mir helfen!

Dennis

[spess53 (Gast)]

Hi

Programmiersprache?

MfG Spess

[avr (Gast)]

Einfach eine Tabelle mit 256 Einträgen erstellen.

unsigned char umkehrzeichen[256]={255,254,253...
                                   2,1,0};


Ausgabe = umkehrzeichen[datenbyte];

Kann auch im Programmspeicher abgelegt werden.


Oder umrechnen:

unsigned char umkehr(unsigned char n){
n=((n>>1)&0x55)|((n<<1)&0xaa);
n=((n>>2)&0x33)|((n<<2)&0xcc);
return (n>>4)|(n<<4);
}


Ausgabe = umkehr(datenbyte);

avr

[Peter D. (peda)]

Ein LCD ist nichts zeitkritisches.
Im Gegenteil, wenn man zu schnell ausgibt, wirds unleserlich.

Daher kann man die Pins völlig wahlfrei zuordnen und braucht auch nicht 
alle 8 Bits und muß auch nicht das Busy-Bit lesen.

Hier ein einfacher Code:

http://www.mikrocontroller.net/attachment/30300/lcd_drv.zip


Peter

[Knut B. (Firma: TravelRec.) (travelrec)]

In ASM kann man ein Byte bitweise wunderbar spiegeln, indem man Register 
A 8x per 'lsl' ins Carry schiebt und per 'ror' in Register B rotiert.

[Dennis G. (hans_angemeldet)]

Also ich will es in C programmieren, da ich da schon einige Erfahrungen 
gesammelt hab.
Kann ich dann wenn ich die Tabelle schreiben die Zahlen einfach so in 
dezimaler Form eintragen? weil ich hab das ma lirgendwo gesehn, dass man 
das in Binärer Form macht. weil ich will eigentlich auch einen Binären 
Wert an meine Funktionen für das Display übergeben, der dann vor der 
Übergabe gespiegelt werden soll.

Was peda meinte ist mir jetzt nicht ganz klar...
Ich kann die doch nicht wahllos zuordnen, das wäre ja voll der Aufwand!
Ich hab die jetzt einfachnur gespiegelt angeschlossen, d.h.:

AVR PC7  -->  DB0 LCD
AVR PC6  -->  DB1 LCD
.
.
.
usw...

Also ich brauch die dann nur einmal spiegeln bevor ich die verwende.
Wenn ich dann eine Binäre Zahl an die Tabelle übergebe bzw die Funktion 
und in der Tabelle Dezimale Zahlen stehen funktioniert das dann? Wäre 
natürlich vieeel einfacher!

Besten Dank schonmal Dennis

[avr (Gast)]

Klar kannst du die Werte Bitweise schreiben. Aber das ist mehr
aufwandt und unnötig. Es ist nur eine andere Art der Darstellung.

http://www.mikrocontroller.net/articles/Zahlensysteme

Du hast 1 Byte => 8 Bit  Wertebereich 0 - 255 -> 256 Werte

-->> Tabelle mit 256 Einträgen.

avr

[Dennis G. (hans_angemeldet)]

Okay, dann mach ich das so, jo das war mir klar dass das nur ne andere 
Darstellung ist, aber ob der Kompiler da mitspielt...
Also dann mach ich jetzt gschwind mal die Tabelle und die Funktion dazu.
Die muss dann von 255 runtergezählt werden oder? also nicht 0,1,2..

Ich fang dann mal an ;-)

[Yago S. (yago)]

Sind die 8 Bits an einem Port? Dann kannst du diese mit einem & befehl 
invertieren, z.B. PORTC = (255&x) wobei x der Ursprungswert ist.
Wenn du immer einzelne Bits invertieren musst, da sich nicht alles an 
einem Port befindet, kannst du das auch mit einem Exor lösen y ^= x
Ich hoffe ich habe dein Problem richtig verstanden.

Sry das mitem & funktioniert nicht, du musst es abzählen (255-x)

[Dennis G. (hans_angemeldet)]

Das hab ich jetzt grad gar nicht verstanden!
Aaaalso Ich hab ein Dislay und das braucht 8 Datenleitungen, da ich ja 
nicht aus Dummhausen komm hab ich mir gedacht alle an einen Port zu 
hängen, nur halt gespiegelt (siehe oben!).
Die Funktionen für das ganze Display sind schon fertig! Nur wenn ich da 
jetzt das versuchen will, ist ja das Byte immer falsch rum angelegt kann 
man sagen! Also muss ich das zuerst Spiegeln, sodass der Port ein 
Gespiegelts Byte anlegt, aber auf dem Display das dann wieder stimmt!
Sagte ja es ging nicht anderst, hab schon einiges probiert.

Danke schonmal.

P.S.: Bin schon bei 127 in meiner Tabelle!

[spess53 (Gast)]

Hi

>Die muss dann von 255 runtergezählt werden oder? also nicht 0,1,2..

Nein. deine Tabelle muss so aussehen:

Tabelle[0]:  0b00000000
Tabelle[1]:  0b10000000
Tabelle[2]:  0b01000000
Tabelle[3]:  0b11000000
Tabelle[4]:  0b00100000
Tabelle[5]:  0b10100000
Tabelle[6]:  0b01100000
......
Tabelle[255]: 0b11111111

MfG Spess

[Knut B. (Firma: TravelRec.) (travelrec)]

256 Bytes Flash für eine Bytespiegelung?! Buääääh!

[Dennis G. (hans_angemeldet)]

Bitteschöön, so wie ich das jetzt verstanden hab, jeder der das Ding mal 
braucht darf sichs nehemn, aber das glaub ich nicht ganz dass die liste 
wie die von Spess aussehen muss!

Ich glaub ich probier das glich mal aus an meinem Testboard...

[Walter (Gast)]

ich fürchte Spess hat recht ...

[spess53 (Gast)]

Hi

Und was ist daran gespiegelt?

MfG Spess

[avr (Gast)]

Natürlich hat spess53 recht.
Die Umkehrtabelle war nur ein Beispiel wie die Tabelle
angelegt wird.
Ich dachte, er wird sowieso die Umkehrfunktion verwenden.

avr

[Dennis G. (hans_angemeldet)]

HEY NEIN das hat ne halbe Ewigkeit gedauert, aber warum hab ich das dann 
schonmal so gesehn?
Aber dann brauch ich doch mehr als NUR 256 Bytes oder?
Wie sieht dann die Umwandlung via´ Spess aus? Kann mir das nicht ganz 
vorstelen!

Hoff ich kann trozdem irgendwie das heute noch schaffen ;-)


EDIT: Hb mir grad das mal mit den Gedanken ein uC angeguckt, und 
festgestellt, dass mein "Spiegelwert" ja eigentlich immer genau die 
Dezimale Zahl ergibt, die ich noch addieren muss, um auf 255 zu kommen! 
-.-
MIST!
Komm aber auf die Funktion trozdem noch nicht wie Spess meint!

[Johann L. (gjlayde)]

Oh Mann, es steht doch oben schon alles vorgekaut und geschrieben. Du 
musst's nur noch abtippseln oder copy-pasten. ARGL

avr schrieb:
>

> unsigned char umkehr(unsigned char n){
> n=((n>>1)&0x55)|((n<<1)&0xaa);
> n=((n>>2)&0x33)|((n<<2)&0xcc);
> return (n>>4)|(n<<4);
> }
>

[spess53 (Gast)]

Hi

>Aber dann brauch ich doch mehr als NUR 256 Bytes oder?

Nein. Du brauchst 256Byte.

>Wie sieht dann die Umwandlung via´ Spess aus? Kann mir das nicht ganz
>vorstelen!

Ganz einfach

Bit7 enthält Bit0
Bit6 enthält Bit1
Bit5 enthält Bit2
Bit4 enthält Bit3
Bit3 enthält Bit4
Bit2 enthält Bit5
Bit1 enthält Bit6
Bit0 enthält Bit7

Z.B.:  aus 0b01101010 wird 0b01010110

MfG Spess

[spess53 (Gast)]

Hi

Oder mal als 'Pseudocode':

if a & 1<<0 then b |= 1<<7
if a & 1<<1 then b |= 1<<6
if a & 1<<2 then b |= 1<<5
if a & 1<<3 then b |= 1<<4
if a & 1<<4 then b |= 1<<3
if a & 1<<5 then b |= 1<<2
if a & 1<<6 then b |= 1<<1
if a & 1<<7 then b |= 1<<0

MfG Spess

[spess53 (Gast)]

Hi

Hab mal schnell die Werte errechnet.

MfG Spess

[Dennis G. (hans_angemeldet)]

Danke an euch!
Hab grad mal mein Testboard rausgesucht, und einen Testmode 
implementiert!
Jetzt funktioniert das ganze mit der Umwndlung!
Dann kann ich ja jetzt wieder an die "Normale" Arbeit zurückkommen! ;)

Danke für eure Bemühung Dennis

[Peter D. (peda)]

Dennis G. schrieb:
> Ich kann die doch nicht wahllos zuordnen, das wäre ja voll der Aufwand!

Dann hast Du Dir den Code nichtmal angesehen, der ist überhaupt nicht 
aufwendig.

Das wird ganz effizient in Bitbefehle compiliert.


Peter

[Simon K. (simon)]

Hehe, hier geht es mal wieder ein wenig drunter und drüber.

1.
Die Tabelle per Hand zu tippen ist Irrsinn! Dafür gibt es Excel, die 
Vervollständigen Funktion und Strg+C, Strg+V (Einfach in Excel die 
Zellen markieren und in die .c Datei einfügen. Aus leeren Zellen werden 
nur Tabs).
Alternativ ein kleines C Programm schreiben.

2.
Die Methode 255-x wie oben geschrieben ist natürlich auch Quatsch. Das 
invertiert zwar, aber nach Invertierung war ja nicht gefragt. 
Invertieren macht man außerdem eher mit der Tilde (A = ~B;). Das ist der 
"richtigere" Operator, da er binär ist.

3.
Das Zugreifen auf die Lookuptable dauert wahrscheinlich länger als der 
von "avr" vorgeschlagene Code. LUT lohnen sich eigentlich nur für 
komplexe Rechnungen die man dann halt im Voraus (in Excel wie gesagt zum 
Beispiel) ausführen lässt.

[Dennis G. (hans_angemeldet)]

Aha cool, dann muss ich glaub die nächste Zeit mal etwas mehr in Excel 
machen, ich nutze das Programm NUR für die erstellung vn Diagrammen, 
aber ich weiß dass das Programm VIEEEL mehr kann!

Gute Nacht
Dennis

[spess53 (Gast)]

Hi

>Alternativ ein kleines C Programm schreiben.

Geht z.B. mit Delphi genauso gut. Siehe oben. Mal übern Tellerrand 
schauen.

>Das Zugreifen auf die Lookuptable dauert wahrscheinlich länger als der
>von "avr" vorgeschlagene Code.

W.z.b.w. (Was zu bezweifeln wäre). Zumindest in Assembler. Welchen Code 
meinst du?

MfG Spess

[avr (Gast)]

LUT ist schneller, das schieben durch das
C-Bit von travelrec in Assembler wohl das beste.

Aber C versteht das Schieben nicht und daher sieht
meine umkehrfunktion in C eleganter aus als Scleifen.

avr

[spess53 (Gast)]

Hi

>das schieben durch das C-Bit von travelrec in Assembler wohl das beste.

Genauso 'schnell' geht es über das T-Flag.

MfG Spess

[Simon K. (simon)]

spess53 schrieb:
>>Das Zugreifen auf die Lookuptable dauert wahrscheinlich länger als der
>>von "avr" vorgeschlagene Code.
>
> W.z.b.w. (Was zu bezweifeln wäre). Zumindest in Assembler. Welchen Code
> meinst du?

Ok stimmt. Habe es ausprobiert. Viel schneller gehts aber auch nicht :-)

[Simon K. (simon)]

Quellcode:

unsigned char UmkehrTab[256];

unsigned char umkehr1(unsigned char n)
{
  n = ( ( n >> 1 ) & 0x55 ) | ( ( n << 1 ) & 0xaa );
  n = ( ( n >> 2 ) & 0x33 ) | ( ( n << 2 ) & 0xcc );
  return ( n >> 4 ) | ( n << 4 );
}

unsigned char umkehr2(unsigned char n)
{
  n = UmkehrTab[n];
  return n;
}
int main()
{
  unsigned char b = umkehr1(0x55);
  printf("%u", b);
  b = umkehr2(0x55);
  printf("%u", b);
  return 0;
}

Kommandozeile:

**** Build of configuration Release for project Test ****

make all 
Building file: ../Main.c
Invoking: AVR Compiler
avr-gcc -Wall -Os -fpack-struct -fshort-enums -funsigned-char -funsigned-bitfields -mmcu=atmega16 -DF_CPU=32000000UL -MMD -MP -MF"Main.d" -MT"Main.d" -c -o"Main.o" "../Main.c"
../Main.c: In function 'main':
../Main.c:53: warning: implicit declaration of function 'printf'
../Main.c:53: warning: incompatible implicit declaration of built-in function 'printf'
Finished building: ../Main.c
 
Building target: Test.elf
Invoking: AVR C Linker
avr-gcc -Wl,-Map,Test.map -mmcu=atmega16 -o"Test.elf"  ./Main.o   
Finished building target: Test.elf
 
Invoking: AVR Create Extended Listing
avr-objdump -h -S Test.elf  >"Test.lss"
Finished building: Test.lss
 
Create Flash image (ihex format)
avr-objcopy -R .eeprom -O ihex Test.elf  "Test.hex"
Finished building: Test.hex
 
Create eeprom image (ihex format)
avr-objcopy -j .eeprom --no-change-warnings --change-section-lma .eeprom=0 -O ihex Test.elf  "Test.eep"
Finished building: Test.eep
 
Invoking: Print Size
avr-size --format=avr --mcu=atmega16 Test.elf
AVR Memory Usage
----------------
Device: atmega16

Program:    1722 bytes (10.5% Full)
(.text + .data + .bootloader)

Data:        266 bytes (26.0% Full)
(.data + .bss + .noinit)

Ergebnis:

00000092 <umkehr1>:
  92:  98 2f         mov  r25, r24
  94:  99 0f         add  r25, r25
  96:  9a 7a         andi  r25, 0xAA  ; 170
  98:  86 95         lsr  r24
  9a:  85 75         andi  r24, 0x55  ; 85
  9c:  98 2b         or  r25, r24
  9e:  89 2f         mov  r24, r25
  a0:  88 0f         add  r24, r24
  a2:  88 0f         add  r24, r24
  a4:  8c 7c         andi  r24, 0xCC  ; 204
  a6:  96 95         lsr  r25
  a8:  96 95         lsr  r25
  aa:  93 73         andi  r25, 0x33  ; 51
  ac:  89 2b         or  r24, r25
  ae:  98 2f         mov  r25, r24
  b0:  92 95         swap  r25
  b2:  9f 70         andi  r25, 0x0F  ; 15
  b4:  82 95         swap  r24
  b6:  80 7f         andi  r24, 0xF0  ; 240
  b8:  89 2b         or  r24, r25
  ba:  08 95         ret

000000bc <umkehr2>:
  bc:  e4 e6         ldi  r30, 0x64  ; 100
  be:  f0 e0         ldi  r31, 0x00  ; 0
  c0:  e8 0f         add  r30, r24
  c2:  f1 1d         adc  r31, r1
  c4:  80 81         ld  r24, Z
  c6:  08 95         ret

[Andreas S. (andreas) (Admin)]

Das Thema wurde schon viele Male diskutiert, hätte man mit einer Suche 
auch einfach finden können:
http://www.mikrocontroller.net/search?query=%2Bbits+%2B(umkehren+OR+spiegeln)&f

[spess53 (Gast)]

Hi

Quellcode:.....


Mit Schieben und ein paar 'Ands' funktioniert das nicht.

MfG Spess