next topic »

[on:]

Salve a tutti ragazzi.

Grazie all'utilizzo dei registri ed all'istruzione PORT riesco a cambiare contemporaneamente lo stato di più pin di output.

Quello che mi chiedo adesso è se c'è la possibilità di fare la stessa cosa con gli input.
Posso cioè leggere nello stesso istante lo stato di più pin di Input?

Grazie per i vostri suggerimenti?

[Reply #1 on:]

Impostando il pin come ingresso, leggendo il registro PINx vedi lo stato dei pin, dopo puoi selezionare quello o quelli che ti servono con semplici operazioni suoi bit

Qui trovi maggiori info:
http://www.arduino.cc/en/Reference/PortManipulation

[Reply #2 on:]

Grazie mille è proprio quello che mi serviva.
In particolare ho una batteria di sensori IR di cui ho parlato in un altro post.
Devo verificare che la loro uscita abbia una transazione L -> H -> L.
Pensavo di farlo mettendo i valori del registro PINx in 3 vettori e verificare bit per bit se si ha il comportamento desiderato.
Scusa la digressione, volevo renderti partecipe e magari sapere che ne pensi :=)

[Reply #3 on:]

La verifica dei bit di una variabile o registro che sia la puoi fare con le bitwise, o anche senza usando lo switch case

0000 0001     Sono 8 bit è vale 1 in decimale
byte myport = 1 // o byte myport = 0x1 equivale a 0000  0001 in binario

if(myport == 1) valuta la condizione come vera

Se invece hai proprio la necessità di accedere ai singoli bit, puoi usare le struct C con i bitfield, si tratta di una struttura dati grande almeno
8 bit composta da 8 campi ognuno grande 1 bit. Es se la struttura si chiama porta pui accedere ad ogni bit così:

porta.b0
porta.b1
porta.b2
ecc.

Ciao.
 

[Reply #4 on:]

Molto interessante!!!
Grazie Mauro.

[Reply #5 on:]

Anche questo fa la stessa cosa

  byte Val=PINA;
  byte bit_0 = bitRead(Val, 0);  //resituisce 0 o 1
  byte bit_1 = bitRead(Val, 1);  //resituisce 0 o 1
  byte bit_2 = bitRead(Val, 2);  //resituisce 0 o 1
  ...
  ...

dove PINA non è la moglie di Fantozzi , ma il byte restituito che raccoglie lo status degli 8 pin
ad esempio nella 2560 i bit appartengono a questi pin
    // PA 7 ** 29 ** D29
    // PA 6 ** 28 ** D28
    // PA 5 ** 27 ** D27
    // PA 4 ** 26 ** D26
    // PA 3 ** 25 ** D25
    // PA 2 ** 24 ** D24
    // PA 1 ** 23 ** D23
    // PA 0 ** 22 ** D22

dovrei fare un test di efficienza tra questa funzione e quella di Mauro... oramai siamo in ballo

ciao

[Reply #6 on:]

Anche questo fa la stessa cosa

  byte Val=PINA;
  byte bit_0 = bitRead(Val, 0);  //resituisce 0 o 1
  byte bit_1 = bitRead(Val, 1);  //resituisce 0 o 1
  byte bit_2 = bitRead(Val, 2);  //resituisce 0 o 1
  ...
  ...

dove PINA non è la moglie di Fantozzi , ma il byte restituito che raccoglie lo status degli 8 pin
ad esempio nella 2560 i bit appartengono a questi pin
    // PA 7 ** 29 ** D29
    // PA 6 ** 28 ** D28
    // PA 5 ** 27 ** D27
    // PA 4 ** 26 ** D26
    // PA 3 ** 25 ** D25
    // PA 2 ** 24 ** D24
    // PA 1 ** 23 ** D23
    // PA 0 ** 22 ** D22

dovrei fare un test di efficienza tra questa funzione e quella di Mauro... oramai siamo in ballo

ciao

Lo scritto altre volte, la velocità è importante solo dopo avere sviluppato il programma per fornire le funzionalità richieste, se dopo ci si accorge
che dobbiamo fare di meglio, si può rinunciare alla chiarezza del codice in favore della pura velocità.

In campo professionale, si fa pressione sui sviluppatori software al fine di fornire le funzionalità richieste con l'hardware specificato. In altre parole devi usare
questo hardware è scrivere un software con queste funzionalità e non si accettano ma.

In campo obbistico invece si passa ad un microcontroller con maggiore velocità, tuttavia Arduino non ha un numero illimitato di board quindi alla fine se hai la MEGA quella ti devi fare bastare e se non  è sufficientemente reattiva devi cercare di ottimizzare.

Comunque le macro che hai postato le preferisco alle strutture bitfield, quelle macro non fanno altro che usare le bitwise per estrarre il valore di un solo bit. Però c'è un però se devi valutare l'uno dopo l'altro il contenuto di 10 variabili bit per bit e facile che ti ritrovi con tante variabili di tipo byte che contengono un solo bit, in tal caso le strutture bitfield sono da preferire, ma sono più complicate perchè devi assegnare un valore ad una struttura devi lavorare con i puntatori e il cast.


PS: io non mi metto a fare test, ma mi piace seguire chi li fa, quindi apri un post che lo seguo.

Ciao.

[Reply #7 on:]

Scusa Mauro, ho provato a usare le tue linee, ma non  ne comprendo la sintassi, non ti riferisci all'ide uficiale di arduino vero?
Come fai a far funzionare queste istruzioni?

Code:

porta.b0
porta.b1
porta.b2
ecc.

ciao

[Reply #8 on:]

Scusa tu. Io non ho fornito codice usabile direttamente, ho solo menzionato le strutture bitfield, spiegando che sono strutture dati del C nel quale per ogni campo è possibile specificare la dimensione. La dimensione minima rimane quella di 8 bit per ogni struttura la quale può contenere 8 campi da un bit.

Qui http://arduino.cc/forum/index.php?PHPSESSID=878ecf68d42cf6632c3ba4dca5ac64c9&topic=83097.0 ho postato qualcosa in merito ai bitfield.

Occhio che sembra che voglia fare il professore, ma non è così, invece quando scopro qualcosa la posto, magari qualcuno solleva una obbiezione ridimensionando la mia convinzione oppure no magari mi da conferma e in un sol colpo ottengo più risultati che mi stanno a cuore.

Ritornando all'esempio fatto prima, dove porta è una istanza di struttura composta da 8 bitfield da un bit ciascuno ognuno lo chiamo bn dove n è un numero da 0 a 7.

A proposito, da tempo non uso le bitfield e non mi ricordo il modo più efficiente per riempire porta con il contenuto di una variabile o registro che sia. Trattandosi entrambe di una porzione di memoria grande un byte dovrei poter castare porta verso il tipo char, ma dovrei anche poter fare il contrario cioè più o meno così:

Code:

struct gpio_t {
    unsigned char b0:1;
    unsigned char b1:1;
    unsigned char b2:1;
    unsigned char b3:1;
    unsigned char b4:1;
    unsigned char b5:1;
    unsigned char b6:1;
    unsigned char b7:1;
};

char value = 0xfe;

gpio_t porta;

porta = (*)(gpio_t*)&value;

// non posso provare l'assegnazione, non ho compilatore, ma credo non funzioni. Il fatto è che non posso prendere l'indirizzo di una struct bitfield e vietato dal c.
// l'obbiettivo della riga precedente sarebbe di prendere l'indirizzo di "value" con & castarlo al tipo a puntatore di tipo gpio_t con (gpio_t*) e dereferenziarlo con (*)

link:
http://en.wikipedia.org/wiki/C_syntax
http://publib.boulder.ibm.com/infocenter/macxhelp/v6v81/index.jsp?topic=%2Fcom.ibm.vacpp6m.doc%2Flanguage%2Fref%2Fclrc03defbitf.htm

Il compilatore IAR ha le porte mappate quasi come una struttura bitfield, PORTA.1, PORTA.2 però potrebbero essere delle #define di questo tipo

#define PORTA.0 PORTA & 1
#define PORTA.1 PORTA & 2
#define PORTA.2 PORTA & 4

Se fosse così posso solo leggere lo stato del bit ma non posso fare assegnazione tipo:
PORTA.0 = 1;
PORTA.1 = 0;

Ciao.