lookup verständnis

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

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.

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

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 ;-)

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)

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!

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

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

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!

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

avr schrieb:
>

1

> unsigned char umkehr(unsigned char n){

2

> n=((n>>1)&0x55)|((n<<1)&0xaa);

3

> n=((n>>2)&0x33)|((n<<2)&0xcc);

4

> return (n>>4)|(n<<4);

5

> }

6

>

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

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

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.

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 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 :-)

Quellcode:

1

unsigned char UmkehrTab[256];

2

3

unsigned char umkehr1(unsigned char n)

4

{

5

  n = ( ( n >> 1 ) & 0x55 ) | ( ( n << 1 ) & 0xaa );

6

  n = ( ( n >> 2 ) & 0x33 ) | ( ( n << 2 ) & 0xcc );

7

  return ( n >> 4 ) | ( n << 4 );

8

}

9

10

unsigned char umkehr2(unsigned char n)

11

{

12

  n = UmkehrTab[n];

13

  return n;

14

}

15

int main()

16

{

17

  unsigned char b = umkehr1(0x55);

18

  printf("%u", b);

19

  b = umkehr2(0x55);

20

  printf("%u", b);

21

  return 0;

22

}

Kommandozeile:

1

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

2

3

make all 

4

Building file: ../Main.c

5

Invoking: AVR Compiler

6

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"

7

../Main.c: In function 'main':

8

../Main.c:53: warning: implicit declaration of function 'printf'

9

../Main.c:53: warning: incompatible implicit declaration of built-in function 'printf'

10

Finished building: ../Main.c

11

12

Building target: Test.elf

13

Invoking: AVR C Linker

14

avr-gcc -Wl,-Map,Test.map -mmcu=atmega16 -o"Test.elf"  ./Main.o   

15

Finished building target: Test.elf

16

17

Invoking: AVR Create Extended Listing

18

avr-objdump -h -S Test.elf  >"Test.lss"

19

Finished building: Test.lss

20

21

Create Flash image (ihex format)

22

avr-objcopy -R .eeprom -O ihex Test.elf  "Test.hex"

23

Finished building: Test.hex

24

25

Create eeprom image (ihex format)

26

avr-objcopy -j .eeprom --no-change-warnings --change-section-lma .eeprom=0 -O ihex Test.elf  "Test.eep"

27

Finished building: Test.eep

28

29

Invoking: Print Size

30

avr-size --format=avr --mcu=atmega16 Test.elf

31

AVR Memory Usage

32

----------------

33

Device: atmega16

34

35

Program:    1722 bytes (10.5% Full)

36

(.text + .data + .bootloader)

37

38

Data:        266 bytes (26.0% Full)

39

(.data + .bss + .noinit)

Ergebnis:

1

00000092 <umkehr1>:

2

  92:  98 2f         mov  r25, r24

3

  94:  99 0f         add  r25, r25

4

  96:  9a 7a         andi  r25, 0xAA  ; 170

5

  98:  86 95         lsr  r24

6

  9a:  85 75         andi  r24, 0x55  ; 85

7

  9c:  98 2b         or  r25, r24

8

  9e:  89 2f         mov  r24, r25

9

  a0:  88 0f         add  r24, r24

10

  a2:  88 0f         add  r24, r24

11

  a4:  8c 7c         andi  r24, 0xCC  ; 204

12

  a6:  96 95         lsr  r25

13

  a8:  96 95         lsr  r25

14

  aa:  93 73         andi  r25, 0x33  ; 51

15

  ac:  89 2b         or  r24, r25

16

  ae:  98 2f         mov  r25, r24

17

  b0:  92 95         swap  r25

18

  b2:  9f 70         andi  r25, 0x0F  ; 15

19

  b4:  82 95         swap  r24

20

  b6:  80 7f         andi  r24, 0xF0  ; 240

21

  b8:  89 2b         or  r24, r25

22

  ba:  08 95         ret

23

24

000000bc <umkehr2>:

25

  bc:  e4 e6         ldi  r30, 0x64  ; 100

26

  be:  f0 e0         ldi  r31, 0x00  ; 0

27

  c0:  e8 0f         add  r30, r24

28

  c2:  f1 1d         adc  r31, r1

29

  c4:  80 81         ld  r24, Z

30

  c6:  08 95         ret

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