Il quiz per ratto

Di la verità... l'hai fatto apposta per farmi fare una figuraccia :stuck_out_tongue:
allora, non ho mai o quasi mai usato quegli operatori logici, la dico così anche se non sono sicuro e voglio approfondire.

uint8_t reg = 0;
uint8_t bitValue = 1;
uint8_t nBit = 4;
reg ^= (-bitValue ^ reg) & (1 << nbit)

Fa un operazione And tra : (-bitValue ^ reg) & (1 << nbit)
Però quel : ^=
non so cosa sia, è una nand ? Sono completamente allo scuro di come funziona questa cosa..

@lesto, non ti preoccupare rispondi tutto tanto in campo sono uno dei più ignoranti :blush:
@Flz orami il titolo della tesina è depositato in segreteria quindi non corro rischi di alcuna sorta XD

Mah no !
ecco :
reg ^= (-bitValue ^ reg) & (1 << nbit)

reg ^ -> mi fà la XOR al risultato prima di assegnarselo
(-bitValue ^ reg) -> qui fà un altra XOR tra le due variabili
& -> AND
(1 << nbit) -> prende i bit più significativi di nbit e li aggiunge ad 1

E' corretto così ?
Edit :
questa cosa non l'ho mai studiata, credo non la conoscano nemmeno i prof a scuola :roll_eyes:
ad ogni modo mi sto già documentando anche se proseguirò dopo lo studio ..

Studia il pascoli e company anzi che riposare nel forum :slight_smile:

svevo te lo chiedono sempre attento :%

MauroTec:
Qualè il valore do reg dopo la bitwise.

42 :grin:

mi lascia perplesso il "-bitValue", bitValue è un usingned, qiondi non capisco se comunque viene cambiata la sue rappresentazone in complemento a 2 (quindi cambiando completamente il valore), o se viene castato a int e poi reso in complemento a 2, quindi invertendo semplicemente il segno come ci si aspetta.

Ma non avete proprio niente da fare? :stuck_out_tongue: :slight_smile:

sono al lavoro, quindi tra una compilazione e l'altra, per distrarmi, do un'occhiata al forum. Giusto per staccare un pò :grin:

Ricompili il sorgente di Linux? Dai scherzo

Ciao

magari! sto a fare questi programmi:

ps. ricompilare un kernel, ma anche farsi una LFS (Linux From Scratch) non è così difficile, bisogna avere il tempo di starci dietro (un mesetto a tempo perso).

flz47655:
Ma non avete proprio niente da fare? :stuck_out_tongue: :slight_smile:

quandi aspetti che si faccia l'orario per scendere non c'è di meglio che caricare dei condensatori con una batteria e usarli per accendere dei led xD

Se avessi saputo come lavora quella bitwise lo avrei scritto senza fare quiz. Io ho provato a fare il calcolo manuale ma il risultato è diverso da quello ottenuto compilando il codice.

mi lascia perplesso il "-bitValue", bitValue è un usingned, qiondi non capisco se comunque viene cambiata la sue rappresentazone in complemento a 2 (quindi cambiando completamente il valore), o se viene castato a int e poi reso in complemento a 2, quindi invertendo semplicemente il segno come ci si aspetta.

Scusa ho fatto un'errore nel scrivere il codice, la versione originale la trovi qui Bit Twiddling Hacks

io ne ho fatto una macro:

#define __bit_set_to(nbit, bitValue, toData) *toData ^= (-bitValue ^ *toData) & (1 << nbit)

Occhio che la macro prende un puntatore per toData, togliere * davanti toData nel caso di una variabile semplice.

Di la verità... l'hai fatto apposta per farmi fare una figuraccia smiley-razz
allora, non ho mai o quasi mai usato quegli operatori logici, la dico così anche se non sono sicuro e voglio approfondire.

Giuro di no, io pensavo che visto la tesi imminente sapevi spiegare come lavora quel codice.

PaoloP:

MauroTec:
Qualè il valore do reg dopo la bitwise.

42 :grin:

Risposta alla domanda fondamentale sulla vita, l'universo e tutto quanto - Wikipedia

A me risulta 32 nel codice e se al posto di bitValue=1 lo metto a zero ritorna ad essere zero.

In pratica a me serviva ottimizzare codice, e volevo risparmiare una if per impostare o pulire un bit, normalmente dobbiamo fare:
PORTA = 0
PORTA |= 1<<5
PORTA ora vale 32

Se volgiamo pulire il bit 5 impostato prima dobbiamo cambiare operatore ed invertire il risultato di 1<<5:
PORTA &= ~(1<<5)

Invece con quel codice è sempre lo stesso sia per impostare un bit che per pulirlo.

Ciao.

In questi casi bisogna fare così: si spezzetta l'istruzione il più possibile e poi si fa debug passo passo con il simulatore di AVR Studio

Ciao

Mi sto studiando la sintassi :smiley:
Recupero Recupero 8)

MauroTec:
In pratica a me serviva ottimizzare codice, e volevo risparmiare una if per impostare o pulire un bit, normalmente dobbiamo fare:
PORTA = 0
PORTA |= 1<<5
PORTA ora vale 32

Se volgiamo pulire il bit 5 impostato prima dobbiamo cambiare operatore ed invertire il risultato di 1<<5:
PORTA &= ~(1<<5)

Invece con quel codice è sempre lo stesso sia per impostare un bit che per pulirlo.

Una cosa del genere potrebbe andare?

#define set_pin_a(bit, value) PORTA = (PORTA & ~(1<<bit)) | value<<bit

ho fatto delle prove e parrebbe funzionare :slight_smile:

bhe quello che fà è

  1. (PORTA & ~(1<<bit)): spegne il bit
  2. | value<<bit: riaccende il bit se necessario

cmq

In the end, benchmarking is the best way to determine whether one method is really faster than another, so consider the techniques below as possibilities to test on your target architecture.

quindi mi aspetto di vedere il bamchmark per chi è più veloce :slight_smile:

lesto:
bhe quello che fà è

  1. (PORTA & ~(1<<bit)): spegne il bit
  2. | value<<bit: riaccende il bit se necessario

lo so, me la sono scritta per un progetto :wink:

Cmq questi usi di metodi raw sono interessantissimi, siamo quasi a livello di assembly, veramente :wink:

@dancol90
Io quella li la capisco, quella che ho postato no.
Probabilmente non riesco a risolverla manualmente perchè quel "-" mi manda in confusione.
La velocità di esecuzione dovrebbe essere la stessa con avr-gcc ma sulle architetture moderne usate nei pc, gcc usa codice asm che non capisco, %exp, movimento in memoria con mov e un solo operatore xor.
Per avr-gcc non ho osservato il corrispondente codice asm generato dal compilatore, lo farò in seguito dopo che riposo un pò, poi posto l'asm così vediamo di capirci qualcosa.

Ciao.

Credo che quel "-" sia proprio il complemento a due...usando la formula del tuo #define, cioè

toData ^= (-bitValue ^ toData) & (1 << nbit)

e ponendo per esempio

toData   = B01010101
nbit     = 4

Ottengo, usando bitValue = 0 (quindi voglio settare a 0 il quarto bit della variabile) :

(-00000000 ^ 01010101) & 00010000 = (00000000 ^ 01010101) & 00010000 = 01010101 & 00010000 = 00010000 => toData = toData ^ 00010000 = 01010101 ^ 00010000 = 01000101

Riapplico la formula sul nuovo valore di toData, usando questa volta bitValue = 1 (dovrei riottenere il valore originale)

(-00000001 ^ 01000101) & 00010000 = (11111111 ^ 01000101) & 00010000 = 10111010 & 00010000 = 00010000 => toData = 01000101 ^ 00010000 = 01010101

Nemmeno io riesco ad afferrare la logica che c'è dietro però, è mezz'ora che cerco di capire come funziona :smiley: