Python3 composizione word bit a bit

[SuperStep]

Salve, sto implementando un software che utilizza un protocollo di comunicazione per cui ad un certo punto devo spedire dei byte trattando singolarmente alcuni bit, dal momento che non ho mai lavorato cosi' a basso livello con il python3 chiedo aiuto a voi.

Il frame e' cosi' composto:

Codice: Seleziona tutto

+-------------------------------+
| 4 bit | 20 bit | 4 bit | 4bit |
+-------------------------------+

adesso, supponendo di voler aggungere tutti 0, ma facendolo parte per parte, come mi approccio?

- Grazie

[DoctorStrange]

Componi i bit come ti servono, poi li shifti a destra o sinistra, e poi coj una maschera di and componi pezzo dopo pezzo la variabile.

[Claudio_F]

trattando singolarmente alcuni bit

Codice: Seleziona tutto

n |= 1 << b                 setta bit b di n (b da 0 a 31)
n ^= 1 << b                 inverte bit b di n
n &= 0xFFFFFFFF ^ (1 << b)  resetta bit b di n (con n lungo 32 bit)

[SuperStep]

trattando singolarmente alcuni bit

Codice: Seleziona tutto

n |= 1 << b                 setta bit b di n (b da 0 a 31)
n ^= 1 << b                 inverte bit b di n
n &= 0xFFFFFFFF ^ (1 << b)  resetta bit b di n (con n lungo 32 bit)

ok, e se invece di trattare un bit alla volta, vorrei trattarli a gruppi di 4 o 20 (come nella separazione sopra)

per esempio, se nel primo quartetto, volessi inserire il valore 10 (1010), ma senza settare i due valori alti a mano, e soprattutto, utilizzando il formato bytes di python3 (utilizzo bytesarray per conservare ogni frammento dello stack)
come posso fare?

- Grazie

[Claudio_F]

Se ho capito bene vuoi usare un bytearray di 4 byte in questo modo:

Codice: Seleziona tutto

     +-----------+-----------+-----------+-----------+
ba = | 0000 0000 | 0000 0000 | 0000 0000 | 0000 0000 |
     +-----------+-----------+-----------+-----------+
       ^  ^ ^                          ^   ^  ^ ^  ^
       |__| |__________________________|   |__| |__|
        4                20                 4    4

In tal caso si può scrivere il nibble alto del primo byte con il seguente codice (dove val è compreso tra 0 e 15):

Codice: Seleziona tutto

ba[0] = (ba[0] & 0x0F) | (val << 4)

Se invece val fosse un valore a 20 bit (0..1048575) da scrivere nel campo virtuale da 20 bit:

Codice: Seleziona tutto

ba[0] = (ba[0] & 0xF0) | (val >> 16)
ba[1] = (val >> 8) & 0xFF
ba[2] = val & 0xFF

La scrittura nei nibble alto e basso del quarto byte:

Codice: Seleziona tutto

ba[3] = (ba[3] & 0x0F) | (val << 4)
ba[3] = (ba[3] & 0xF0) | val

La riestrazione dei quattro valori:

Codice: Seleziona tutto

ba[0] >> 4
((ba[0] & 0x0F) << 16) | (ba[1] << 8) | ba[2]
ba[3] >> 4
ba[3] & 0x0F

Praticamente, a parte la mancanza del punto e virgola finale, è codice C