ElectroYou

Ho una domanda da principiante:

Se nel codice in C per un ATMEGA (o un micro in genere) scrivo qualcosa come ~(1 << 2) , il compilatore farà l'operazione oppure viene lasciata a carico del micro?

E, nel secondo caso, conviene forse scrivere direttamente 0b11111011 ?

Ho la sensazione che siano solo seghe mentali, ma chiedere non guasta.

Sjuanez ha scritto:il compilatore farà l'operazione oppure viene lasciata a carico del micro?

Cosa intendi esattamente ?

Il compilatore genera un file binario che può essere tradotto dal micro.
Puoi comunque disassemblare il codice per vedere cosa fa. Dal file binario puoi sempre fare un objdump per vedere cosa c'è dentro (vedere le istruzioni Assembly e relativo operand code).

Beh, quelle cose ancora non so leggerle

In ogni modo intendevo il caso in cui, per comodità, si definisce un byte e poi se ne fa il contrario con NOT. Ad esempio nella costruzione delle maschere.

Il compilatore fa da traduttore.
I calcoli li fa il micro.

Quando esegui il firmware nell' ATmega, questo viene eseguito nel micro non nel computer dove lo hai compilato.

Interessante, grazie.

Il compilatore fa da traduttore.
I calcoli li fa il micro.

I calcoli sulle costanti non avrebbe senso che sia il micro ad eseguirli.

Non ho molta esperienza in proposito (nel senso che non sono andato così spesso a guardare l'assembly), ma per quel che ho visto purtroppo il risultato della compilazione dipende dal compilatore e dalle ottimizzazioni attivate.
Un compilatore "furbo" potrebbe ad esempio compilare

Codice: Seleziona tutto

a = b/(2/1);

(con a e b interi) come

Codice: Seleziona tutto

a = b>>1;

mentre un compilatore più "stupido" potrebbe eseguire pedissequamente tutti i conti.

E' evidente che l'assembly del compilatore "stupido" sarebbe molto meno efficiente, senza dare alcuna differenza nel risultato.

PS: non mi riferisco al caso dell'ATMEGA, che praticamente non ho mai usato, il discorso è generale.

Un attimo... Non se simo85 hai capito ciò che vuole sapere Sjuanez (credo di averlo intuito):
Scrivere direttamente il byte in linguaggio binario (0b11111011) è scomodo e risulta di difficile comprensione per qualcuno di esterno che vede il codice.
Quindi di solito si consiglia un approccio di operazioni sui byte come quello che riporta Sjuanez ~(1 << 2) ancora meglio se al posto dei numeri si usano i nomi dei bit delle porte digitali (ad esempio).
Ma, quello che penso si chieda lui è:
- nel primo caso il micro prende il byte scritto direttamente e ci fa quello che ci deve fare
- nel secondo caso si prende un byte, si "applica" uno scorrimento, e si inverte
Così, su due piedi, sembrerebbe che nel primo caso il micro esegua in una sola istruzione tutto, nel secondo caso che gliene servano 3... ma queste "3 istruzioni" vengono fatte dal micro ogni volta che si ha l'assegnazione in questione (rallentando il tutto) oppure il compilatore calcola il byte "costante" che si ottiene dopo questi 3 passaggi e scrive nella memoria del micro solo il risultato finale dell'espressione?
Per quello che so io (che è poco, quindi correggetemi se sbaglio) il calcolo lo fa il compilatore, quindi l'operazione non pesa sulla velocità del programma del micro.

simo85 ha scritto:Quando esegui il firmware nell' ATmega, questo viene eseguito nel micro non nel computer dove lo hai compilato.

Bè, quello è vero.

Però, ad esempio, se per "costante" Sjuanez intendesse una macro, questa verrebbe risolta dal compilatore, e quindi il NOT verrebbe sicuramente eseguito in compile-time.

Nel caso in cui per "costante" si intendesse una variabile dichiarata con il qualificatore const o in qualsiasi altro caso, purtroppo non so se l' operazione la si fa in compile-time o in run-time.

Purtroppo sono abbastanza ignorante su ciò che riguarda cosa avviene precisamente "dietro le quinte" nel periodo di tempo che va dalla fase di compilazione a quella dell' esecuzione vera e propria del codice.

PS: Sjuanez, puoi postare la riga di codice in questione per intero?

Nel caso in cui per "costante" si intendesse una variabile dichiarata con il qualificatore const o in qualsiasi altro caso, purtroppo non so se l' operazione la si fa in compile-time o in run-time.

Nel caso di const sono quasi certo che il calcolo venga eseguito dal micro.

Per l'altro caso, che sia una sostituzione (con #define) o siano dei numeri scritti direttamente la cosa non cambia, appunto perché la sostituzione della stringa nel codice C viene effettuata prima della compilazione.

Basta che Sjuanez dichiari una funzione nel preprocessore e faccia un disassembling del codice per vedere cosa fa.

Se poi riporta i risultati buon per tutti.