Atmega128/LCD unter C

int Value = (Value << 1) | (Value >> (16 -1));

Du setzt eine Rotation eines 16 Bits Wertes aus einem Links und
Rechtsshift zusammen. Im obigen Bsp. würde also ein 16 Bit Wert um 1
Bit nach links oder eben um 15 Bit nach rechts rotiert.

Gruß Hagen

Hallo!

Danke erst mal!

Mein Programm:

void LCDbefehl (unsigned char befehl)
      {
       unsigned char a1;
       a1 = befehl;
       a1 = _crol_(a1,4);           //in intrins.h, char um 4 bits
                                    //rolieren -> High und Low-Nibbel
                                    //vertauschen
       a1 = a1 & 0x0F) | 0x10;      //4 Bits maskieren
       LCD_PORT = a1;
       LCD_PORT = a1 & 0x00;
       a1 = befehl;
       a1 = (a1 & 0x0F) | 0x10;
       LCD_PORT = a1;
       LCD_PORT = a1 & 0x00;
       warte100u (10);
      }

Wi kann ich denn nun die oben genannte Zeile hier einbringen??

int Value = (Value << 1) | (Value >> (16 -1));

Jetzt schon vielen Dank!

Carsten

Besser gar nicht...
Du brauchst hier nicht hi- und lownibble vertauschen, da du hinterher
das highnibble wegmaskierst.
Also schreib doch oben gleich:

a1 = befehl>>4;

Hallo!

Sorry, aber nochmal zu meiner Problematik...

Schauen wir auf den Befehl den ich nicht einsetzten kann:

a1 = _crol_(a1,3);

Nimmt man einen Wert an:

a = 0xA5;

b = _crol_(a,3); /* b ist jetzt 0x2D */

Das würde bedeuten:

aus:
1010 0101
wird:
0010 1101
---------------------------------------

Bei dem Befehl:

a1 = befehl>>4;
ist das nicht so.

Der Operator ">>" bedeutet: "Rechtsschieben 1 Bit, links Null
auffüllen.

Das ist nicht das gleiche.
Kann mir jemand sagen wie ich diese crol Zeile ersetzten kann?

Grüße

Carsten

Hallo Leute!

Ich schon wieder!

Ist es richtig, dass ich mit dem Befehl:

a1 = b1 >> 4;

genau ein Bit um vier Stellen nach rechts schiebe und an die ehemalige
Position ne Null schreibe?
Also ich schiebe nicht 4 Bit um 4 stellen nach rechts, oder?

Danke für die Geduld!

Gruß

Carsten

Doch

0x1100 >> 1 == 0x0110
0x1100 >> 2 == 0x0011
0x1100 >> 3 == 0x0001
0x1100 >> 4 == 0x0000

0x0011 << 1 == 0x0110
0x0011 << 2 == 0x1100
usw,

somit

(0x1100 << 1) | (0x1100 >> (4 -1)) == (0x1000 | 0x0001) == 0x1001 ==
ROL(0x1100, 1)

Wenn man mit 4 Bit Wordbreite rechnet.

Gruß hagen

sorry 0x ist natürlich nicht richtig da es eine hexadezimale Zahl
bezeichnet. Im obigen Beispiel sind natürlich binäre Zahlen gemeint und
die würden dann zB. so aussehen 1100b, 0011b usw.

Gruß Hagen

Hallo Hagen!

Danke für deine Auskunft.

Das würde dann bedeuten, dass man bei 8 Bit folgendes rausbekommt:

1111 0000b >> 4 == 0000 1111b

oder

0101 0110b >> 4 == 0000 0101b

Stimmt das so, hab ich es endlich verstanden?

Gruß

Carsten

Korrekt,

mathematisch bedeutet

x << y == x * (2**y) -> x * (2 hoch y)

und

x >> y == x / (2**y) -> x / (2 hoch y)

In deinem Bespiel ist

11110000b >> 4 == 0xF0 >> 4 == 0xF0 / (2**4) == 240 / 16 == 15 == 0000
1111b
01010110b >> 4 == 0x56 >> 4 == 0x56 / (2**4) ==  86 / 16 ==  5 == 0000
0101b

Gruß Hagen