Bitmanipulation in C# Programm (Visual Studio)

OP #4416791
Lesenswert?

Hallo, ich habe das Problem in einem C# Programm, dass ich einzelne Bits 
nicht löschen kann. Er merkert, dass der Konstantenwert "-4" nicht in 
"byte" konvertiert werden kann. Problem wird hier sein, dass er mit 
32Bit arbeiten will. Das möchte ich aber nicht ;) Die Variable habe ich 
als Byte (uint8_t).
1
 
2
       byte cmd; // global
3
        private void b_on_Click(object sender, EventArgs e)
4
        {
5
            cmd &= ~(0x03); // Loesche die ersten beiden Bits
6
            cmd |= (0x02);  // Setze das zweite Bit
7
        }
8

9
        private void b_pir_Click(object sender, EventArgs e)
10
        {
11
            cmd &= ~(0x03); // Loesche die ersten beiden Bits
12
            cmd |= (0x03);  // Setze die ersten beiden Bits
13
        }
14

15
        private void b_off_Click(object sender, EventArgs e)
16
        {
17
            cmd &= ~(0x03); // Loesche die ersten beiden Bits
18
            cmd |= (0x01);  // Setze das erste Bit
19
        }

Kann man das ganze irgendwie casten auf 8Bit?
#4416840
Lesenswert?

Stefan S. schrieb:
> Aber die anderen 24 Bit
> sind absolut über

Es sind sogar 30.

Stefan S. schrieb:
> cmd &= ~(0x03);

Du benutzt 2 Bit. Selbst bei einem Attiny13 würdest du dir keine 
Gedanken über die übrigbleibenden 6 Bit machen.

Also lass es bei 32 Bit. Das tut dem Gigabyte-Monster nicht weh. Wenn 
die Variablen aus Performance-Gründen( Stichwort Address Alignment) 
nicht ohnehin grundsätzlich in 32 oder sogar 64 Bit gespeichert werden.
Gast #4416845
Lesenswert?

Stefan S. schrieb:
> byte cmd; // global
>         private void b_on_Click(object sender, EventArgs e)
>         {
>             cmd &= ~(0x03); // Loesche die ersten beiden Bits
>             cmd |= (0x02);  // Setze das zweite Bit
>         }
>
>         private void b_pir_Click(object sender, EventArgs e)
>         {
>             cmd &= ~(0x03); // Loesche die ersten beiden Bits
>             cmd |= (0x03);  // Setze die ersten beiden Bits
>         }
>
>         private void b_off_Click(object sender, EventArgs e)
>         {
>             cmd &= ~(0x03); // Loesche die ersten beiden Bits
>             cmd |= (0x01);  // Setze das erste Bit
>         }

wenn mich meine erinnerung nicht täuscht, kann man das auch casten:
1
private void b_on_Click(object sender, EventArgs e)
2
         {
3
             cmd &= (byte) ~(0x03); // Loesche die ersten beiden Bits
4
             cmd |= (byte) (0x02);  // Setze das zweite Bit
5
         }
OP #4416849
Lesenswert?

Hallo derElf,

nein casten kann man die unäre (~) Anweisung nicht. Bei dem | Operand 
wäre es hingegen möglich.

Hallo vorbild,
nicht ganz richtig mit den 30 Bits. Aber das konntest du auch nicht 
durch die Glaskugel erkennen ;) Ich nutze ein Byte für diverse 
Einstellungen. Also nicht nur für die 2 Bits.

Das ganze wird dann über die Serielle Schnittstelle an einen Tiny841 
gesendet, der daraus entsprechend WS2812B/APA102C ansteuert.

           dataToSend = String.Format("{0:x02},{1:x02},{2:x02},{3:x02}", 
(byte)cmd, red, green, blue);

Habe cmd hier mal sicherheitshalter auf Byte gecastet. Am Attinty soll 
nur ein String ankommen in Form von ff,ff,ff,ff\n
Gast #4416950
Lesenswert?

Also soweit mir bekannt ist das Ergebniss von bitwise and / or in c# 
immer ein int (Int32 - 4 byte) du kannst also im Prinzip schon genauso 
bits löschen und setzen wie in c musst nur auf das casten in den 
richtigen Ziel-Datentyp achten z.B.:
in c :cmd &= (byte) ~(0x03);
in c# : cmd = (byte)(cmd & ~0x03); natürlich nur wenn cmd als byte 
deklariert wurde.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren