Logica AtmeL

[TardoFreak]

Uhm ...
belva87 mi pare che il tuo sia più un problema derivante dall' uso e manipolazione di bit più che dalla "logica" del compilatore o delle librerie.

Conosci il C ma non l' hai utilizzato sui micro. Questo vuol dire che non hai dimestichezza con i bit in generale perché vengono manipolati di rado su programmi che girano su PC.
Con i PC usai le printf, le scanf, i files etc. Con i micro queste funzioni, non dico che non si usino, ma non sono molto comuni, almeno quanto lo sono le operazioni sui bit.

Forse dovresti lavorare su quello.

Penso.

[belva87]

Questo è quello che ottengo facendo il build di entrambi i codici postati in precedenza:

Codice: Seleziona tutto

Target "Build" in file "C:\Program Files\Atmel\AVR Studio 5.0\Vs\Avr.common.targets" from project "C:\Users\Luca\Documents\AVRStudio\prime prove\prime prove\prime prove.avrgccproj" (entry point):
Done building target "Build" in project "prime prove.avrgccproj".
Done building project "prime prove.avrgccproj".

Build succeeded.
========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========


Non ho riportato tutto per semplicità ma si capisce come non ci sono errori o warning...

Utilizzo AVR Studio 5 e l'iter che ho seguito per fare questo primordiale test è stato:
Apro AVR5, creo un nuovo progetto di tipo C eseguibile, scrivo il codice e salvo il progetto, lo compilo premendo F7, con Flip carico il file .HEX creato dal compilatore e come ultima cosa lo carico nel micro.
Tutti e due i programmi penso partano quando resetto il micro, ma solo il primo accende il led.

Personalmente il C lo conosco ma non per i micro, è esatto... però non comprendo il significato degli operatori negli esempi che hai fatto ai post precedenti, e sopratutto perché per mettere a uno un pin di una porta devo fare << (lo shift) in realtà non ho capito tutto il ragionamento che c'è dietro...
Credo sia questo il mio problema, ma sto studiando per un esame davvero brutto (ma bello al contempo) e non ho molto tempo, devo ammettere però che ho cercato sul sito AtmeL e non ho trovato nulla a riguardo che mi guidi in maniera un po' "didattica" e passo passo su questo aspetto.
Capisco il tuo ragionamento in merito a scrivere le funzioni, e sono d'accordo anzi quel poco che ho fatto in assembler con il PIC a scuola lo avevamo fatto così (con l'istruzione CALL che chiamava la "label" voluta); però penso che devo prima comprendere bene questo (anche se poi magari non lo userò in questo modo) ma significa che ho compreso ciò che sto facendo e ciò che sta alla base.

[rusty]

Mi sembra molto strano che non dia nessuno errore il build dei sorgenti indicati, sei sicuro che stia compilando i sorgenti scritti e non, magari, un sorgente diverso ma associato al progetto? Stai attento a cosa sta compilando quando clicchi "build..." perché mi è capitato di fare un nuovo progetto, scrivere un sorgente ma quell'infame (colpa mia che non associavo il nuovo file al progetto corrente) compilava un altro file, sempre contenuto in directory interne, non il mio appena scritto

[simo85]

però non comprendo il significato degli operatori negli esempi che hai fatto ai post precedenti, e sopratutto perché per mettere a uno un pin di una porta devo fare << (lo shift) in realtà non ho capito tutto il ragionamento che c'è dietro...

È sempre C. Ed è una maniera semplice (dipende poi dal tuo punto di vista) di settare i bit.

Prendi questo codice per esempio, per capire meglio:

Codice: Seleziona tutto

#include <stdio.h>

int main(void)
{
   unsigned char x = 0x00;

   printf("0x%x\n", x);

   x = (1 << 7);
   
   printf("0x%x\n", x);
   return 0;
}


Puoi anche usare la OR, per esempio:

Codice: Seleziona tutto

#include <stdio.h>

int main(void)
{
   unsigned int x = 0x00000000;

   printf("0x%x\n", x);

   x = 0x000000ff | 0xff000000;
   
   printf("0x%x\n", x);
   return 0;
}

È molto comodo da usare con i registri belli tosti, per esempio quelli da 32bit.

EDIT: aggiungo un tutorial che ti può aiutare altrettanto.
http://www.cprogramming.com/tutorial/bi ... ators.html

[belva87]

Ho letto il link, grazie per avermelo passato.
Però o sono stupido, o non ho le basi o non so proprio perché... ma non riesco a capire!
perché per assegnare un valore ad un bit devo far eseguire l'istruzione di shift??
Cioè, non riesco a capire come funziona quello shift... per me shiftare a destra per esempio un numero in binario vuol dire dividerlo per 2, shiftarlo a sinistra moltiplicarlo per due... ma non riesco a collegare le due cose con il setting di un bit a livello logico alto.
Personalmente mi sto sforzando ma... una riflessione mi salta in mente... fare come fa microchip è sbagliato concettualmente oppure non comodo o che altro?
Oppure è proprio per questo che adesso non riesco ad entrare in questo nuovo modo?
Boh... sono un po' spiazzato sinceramente, ma non voglio abbandonare.
Grazie a tutti comunque.

[TardoFreak]

Shiftare a sinistra significa anche moltiplicare per due ma l' operazione di shift di un bit semplicemente lo sposta.
Dimentica la moltiplicazione e ragiona così: ho una long word (32 bit) e devo mettere a 1 il bit 27.

Soluzione a)
A manina mi faccio il mio bel disegnino, ci metto un 1 nel bit 27, codifico in esadecimale e mi viene fuori 0x08000000.

Soluzione b)
Scrivo (1<<27)

[belva87]

Ok, perciò se ho capito la logica con il semplice numero, se volessi mettere a 1 il bit numero 6 di un byte posso scrivere:
In binario: 0b00100000
In esadecimale: 0h20
oppure con l'ultimo modo:
(1 << 6) che se non ho capito male mette a 1 il bit numero 6 del byte a cui sono interessato, giusto?

Se ho capito bene, allora la logica di ragionamento è del tipo

REGISTRO DI INTERESSE = (1 << BIT DI INTERESSE)

Cioè sposta il valore logico 1 dentro la posizione del bit di interesse... giusto?
Facendo un esempio più preciso scrivere: PORTA = (1 << PINA0); fa scorrere 1 fino alla posizione del bit PINA0, facente parte del registro a 8 bit che si chiama PORTA.

Ditemi se sto prendendo cantonate per favore...

[simo85]

Attenzione. 0x40 è (1 << 6) ma non 0010 0000.

Quel valore in binario lo ottieni con (1 << 5).

Devi sempre tenere in conto anche il LSB, il bit #0.

[xyz]

(1 << 6) che se non ho capito male mette a 1 il bit numero 6 del byte a cui sono interessato, giusto?

E' un numero con il bit 6 a uno e tutti gli altri a 0 e come dice [user]gohan[/user] hai anche sbagliato la sua rappresentazione esadecimale.

REGISTRO DI INTERESSE = (1 << BIT DI INTERESSE)
Cioè sposta il valore logico 1 dentro la posizione del bit di interesse... giusto?

No, non hai ancora capito, in quel caso se il registro è a 8 bit, scrivi tutti gli 8 bit non intervieni solo sul bit che vuoi impostare.

Devi usare l'operatore OR (è la base delle operazioni sui bit):

REGISTRO |= (1 << BIT DI INTERESSE)

equivale a:

REGISTRO = REGISTRO | (1 << BIT DI INTERESSE)

Facendo un esempio più preciso scrivere: PORTA = (1 << PINA0); fa scorrere 1 fino alla posizione del bit PINA0, facente parte del registro a 8 bit che si chiama PORTA.

Non fai scorrere nulla è una semplice assegnazione.

Ditemi se sto prendendo cantonate per favore...

Non sai manipolare le operazioni booleane tra i bit.

Facciamo un esempio concreto.

Il compilatore GCC è in grado di capire quando utilizzare le istruzioni assembler per impostare un unico bit, molto veloci, oppure utilizzare un registro intermedio per calcolare il valore da scrivere nel registro.

Codice in C senza uso di nessuna macro o funzione:

Codice: Seleziona tutto

#define __AVR_ATmega8__

#include <avr/io.h>

void main()
{
   PORTB |= (1 << PIN4);
   PORTB |= (1 << PIN6) | (1 << PIN3);
   
   PORTD &= ~(1 << PIN2);
   PORTD &= ~((1 << PIN7) | (1 << PIN6) | _BV(PIN5)  | _BV(PIN6));

}


Compiliamo il sorgente con il GCC per AVR ma fermiamo la compilazione alla sola generazione del codice assembler:

Codice: Seleziona tutto

$> avr-gcc -O2 -S source.c

il codice assembler generato con l'aggiunta nei commenti le righe in C:

Codice: Seleziona tutto

// PORTB |= (1 << PIN4);

        sbi 0x18,4

// PORTB |= (1 << PIN6) | (1 << PIN3);

        in r24,0x18
        ori r24,lo8(72)
        out 0x18,r24

// PORTD &= ~(1 << PIN2);

        cbi 0x12,2
       
// PORTD &= ~((1 << PIN7) | (1 << PIN6) | _BV(PIN5)  | _BV(PIN6));
   
   
        in r24,0x12
        andi r24,lo8(31)
        out 0x12,r24

Il compilatore sceglie ogni volta l'istruzione migliore visto che esiste l'istruzione per assegnare o cancellare un bit di un registro con una sola istruzione, altrimenti se i bit sono più di uno esegue l'operazione classica con OR per impostare i bit o AND per cancellare i bit.

[belva87]

No, non hai ancora capito, in quel caso se il registro è a 8 bit, scrivi tutti gli 8 bit non intervieni solo sul bit che vuoi impostare.

Non saprei allora, non riesco proprio a comprenderlo... questa cosa che dici e ho riportato sopra... a meno di qualcosa che non so e non vedo, non mi torna... ho montato un altro led sulla breadboard collegato ad un altro pin di PORTA... e il led è spento...

Sinceramente, mi sto confondendo... e i vostri esempi non li capisco, perché non sono a livello avanzato come voi e non ho le conoscenze per comprenderli penso, grazie lo stesso comunque.

Chiedo se sapete di un documento che parta dalla base con spiegazioni chiare anche per un neofita come me in questo mondo. Grazie, Luca.