Il sensore TSL2591 permette di misurare l’intensità luminosa di un ambiente. Ha una buona capacità di campionamento ed in particolare permette con un solo sensore di rilevare sia lo spettro IR sia quello visibile. Il range di misurazione va da 188 Lux sino ad arrivare ad 88000 Lux (unità di misura Lux).
Nella figura seguente potete osservare il diagramma del circuito:

La conversione dei due canali viene eseguita contemporaneamente. Al termine del ciclo di conversione i dati vengono memorizzati nei relativi registri (CH0 Data e CH1 Data). Dopo la memorizzazione dei dati viene automaticamente eseguita la misurazione successiva.

Per questo tutorial ho acquistato questo articolo.

Il TSL2591 possiede anche due livelli di soglia programmabili (Upper Limit e Lower Limit) che generano un interrupt se il valore della misurazione dell’intensità di luce eccede questi limiti, una funzionalità importante per ottimizzare il campionamento in base alle condizioni di luminosità dell’ambiente.

Il collegamento del sensore con un microcontrollore avviene utilizzando il bus I2C, l’indirizzo del dispositivo nel bus è 0x29 e non può essere modificato via software, come accade con analoghi dispositivi.

L’interazione microcontrollore sensore avviene scrivendo e leggendo i registri del dispositivo.

Nonostante esista una libreria che semplifica l’interfacciamento, credo che sia interessante capire come accedere ai registri del TSL2591 utilizzando le semplici istruzioni della libreria Wire (bus i2C), questo per ottimizzare il codice in termini di dimensione e di prestazioni.

Sul datasheet sono presenti tutte le informazioni relative al TSL2591, tramite questo ‘manuale’ possiamo capire quali registri dobbiamo leggere e scrivere. La tabella seguente elenca tutti i registri del TSL2591, il loro indirizzo e le informazioni sulla loro funzione:

Il primo registro che dobbiamo conoscere e il COMMAND, più che un registro è il primo dato che inviamo al TSL2591 suil bus I2C, che permette successivamente di accedere ad un registro specifico (indirizzi da 0x00 a 0x17), nel dettaglio il COMMAND è così composto:

Il bit 7 deve essere impostato alto per poter rendere valido il commando. I bit 6 e 5 servono per definire l’uso dei bit da 0 a 4. Se i bit 6 e 5 vengono settati rispettivamente uno basso e uno alto, intendiamo accedere ad un indirizzo, se invece i bit 6 e 5 vengono impostati rispettivamente uno alto e uno basso, intendiamo specificare una funzione (maggiori dettagli sul datasheet del TSL2591).

Passiamo subito passare alla pratica per capire come funziona questo meccanismo. Andremmo a leggere il registro 0x12 che contiene l’identificativo del dispositivo, settato di default al valore 0x50.

Formiamo, usando la notazione binaria, il valore che deve avere il COMMAND. Il bit 7, abbiamo detto, deve essere messo a 1, i bit 6 e 5 devono essere 0 e 1 (poichè intendiamo scrivere nei bit da 0 a 4 un indirizzo e non abilitare una funzione) e i bit da 0 a 4 conterranno il valore del registro che voglio leggere o scrivere, in questo caso 0x12:

Se questo è corretto dal registro 0x12 dovremmo leggere il valore 0x50:

//inserisco la libreria I2C
#include <Wire.h>

void setup()
{
  //Attivo la seriale
  Serial.begin(9600);
  
  //inizializzo la porta I2C
  Wire.begin();

  //inizio la trasmissione specificando
  //l'indirizzo del TSL2591
  Wire.beginTransmission(0x29);
  //invio sul bus il valore del registro COMMAND
  Wire.write(0b10110010);
  //termino la trasmissione
  Wire.endTransmission();
  //richiedo al dispositivo il valore del registro
  //precedentemente selezionato
  Wire.requestFrom(0x29, 1);
  //leggo il valore del registro
  byte c = Wire.read();
  //invio al serial monitor il dato letto
  Serial.print("0b"); Serial.print(c ,BIN); Serial.print(" 0x"); Serial.print(c ,HEX);
}

void loop() {
  delay(50);

}

Aprendo il Serial Monitor otterremo il valore aspettato:

Questo è il meccanismo che permette di accedere ai registri del TLS2591. Ora andremo a recuperare i valori dei registri interessati alla memorizzazione dei canali ADC CH0 e CH1, relativi alla spettro visibile e alla spettro IR.
Prima di eseguire la lettura dai registri 0x14, 0x15, 0x16 e 0x17 (Che contengono appunto il valore della conversione ADC) è necessario configurare alcuni registri del dispositivo come l’ENABLE (0x00) e il CONFIG (0x01).

Il registro ENABLE (0X00) è così composto:

Permette di ‘accendere’ il dispositivo e di avviare l’ALS Data Register per memorizzare i dati provenienti dagli ADC. I bit 4, 6 e 7 servono per settare le funzioni di interrupt e power down. Per il momento non useremo questi bit.
Quindi i bit 0 e 1 vengono impostati a 1 mentre gli altri bit impostati a 0.
Il registro ENABLE avrà questo valore: 0b00000011.

Un altro registro da configurare, prima di eseguire la lettura dai registri 0x14-0x17 e il CONTROL (0x01):

Questo registro ci permette di selezionare tramite i bit 4 e 5 il guadagno dell’integratore dei due canali. Il valore del AGAIN permette di variare la sensibilità del sensore in base alle condizioni di luce, se andiamo a misurare ambienti molto luminosi useremmo un basso guadagno, viceversa in ambienti bui ne potremmo aumenteremmo il guadagno.
Stesso discorso vale per il tempo di acquisizione, integration time ATIM, per ambienti luminosi potremmo impostare un basso tempo di integrazione (100 ms) mentre per ambienti poco luminosi un alto valore di integrazione (600ms).
Il bit 7 va impostato a zero, altrimenti otterremo il reset del dispositivo.
Impostiamo SRESET a uno (bit 7), AGAIN a 01 (medium Gain Mode) e ATIME a 100ms. Il registro avrà quindi questo valore 0b00010000.

Ora non ci resta che leggere i 4 byte dei registri 0x14-0x17, per recuperare i dati relativi alla conversione dello spettro visibile e IR:

//carico libreria i2c
#include <Wire.h>

void setup() {
  //init seriale
  Serial.begin(9600);

  //inizializzo la porta I2C della Arduino
  Wire.begin();
  delay(100);
 
  Wire.beginTransmission(0x29);
  Wire.write(0b10110010);//10110010
  Wire.endTransmission();
  Wire.requestFrom(0x29, 1);
  byte c = Wire.read();
  Serial.print("0b"); Serial.print(c ,BIN); Serial.print(" 0x"); Serial.print(c ,HEX);
 
  //attiva il tsl2195
  Wire.beginTransmission(0x29);
  //attiva seleziono il registro 0x00 (enable)
  Wire.write(0b10100000);
  //attiva
  Wire.write(0b00000011);
  Wire.endTransmission();
 
  //configuro il sensore gain e timing
  Wire.beginTransmission(0x29);
  //seleziono il registro 0x01 (Control)
  Wire.write(0b10100001);
  //imposto reset a 0 gain a 01 e timing a 000
  Wire.write(0b00010000);
  Wire.endTransmission();

  Wire.beginTransmission(0x29);
  //seleziono il registro 0x14
  Wire.write(0b10110100);
  Wire.endTransmission();

}

void loop() {

  //attendo almeno 100ms tra una lettura e l'altra
  delay(500);

  //leggo i dati dal registro 0x14 0x15 0x16 e 0x17
  Wire.requestFrom(0x29, 4);
  byte ByteLowVIS = Wire.read();
  byte ByteHighVIS = Wire.read();
  byte ByteLowIR = Wire.read();
  byte ByteHighIR = Wire.read();

  int valore = 0;

  //unisco i due byte del registro
  //0x14 con il registro 0x15
  valore = ByteHighVIS;
  valore <<= 8;
  valore |= ByteLowVIS;
  //invio il dato al serial monitor
  //luce visibile (CH0)
  Serial.print("LUCE VISIBILE ");
  Serial.println(valore);

  valore = 0;

  //unisco i due byte del registro
  //0x16 con il registro 0x17
  valore = ByteHighIR;
  valore <<= 8;
  valore |= ByteLowIR;
  //invio il dato al serial monitor
  //luce IR (CH1)
  Serial.print("LUCE IR ");
  Serial.println(valore);
}

Caricando il codice otterremo  l’acquisizione dei dati:

I risultati ottenuti sono valori grezzi che vengono recuperati direttamente dai registri di conversione. Tramite questi dati possiamo calcolare il valore della luminosità espresso in Lux oppure considerarli come semplici variazioni numeriche.

The post Come usare il sensore di luminosità TSL2591 appeared first on Esperimenti con logiche programmabili.

Il limite di memoria di una scheda Arduino può essere superato utilizzando delle memorie esterne che permettono di aggiungere capacità di memorizzazione per tutte quelle applicazioni che richiedono la registrazione di dati. Possiamo scegliere tantissimi tipi di memorie a seconda del tipo di interfaccia (I2C, SPI, parallela…) e dalla loro capacità.

Per questo tutorial ho scelto una comunissima EEPROM Seriale prodotta da Microchip, la 24LC256. Questa memoria può essere collegata alle schede Arduino tramite bus I2C e offre 256 Kbits di memoria (32KB). La pin function della memoria è rappresentata in figura:

i pin A0, A1, A2 permettono di specificare l’indirizzo del dispositivo sul bus I2C, i pin Vcc e Vss sono rispettivamente l’alimentazione (5Vdc) e la massa (Gnd), il pin WP (Write Protect) abilita (se collegato a Gnd) o disabilita (se collegato a Vcc) la scrittura della EEPROM, i pin SCL e SDA sono relativi al collegamento I2C.

secondo il datasheet del produttore possiamo riassumere alcune caratteristiche fondamentali:

Per questo tutorial ho utilizzato una Arduino Leonardo. La figura seguente mostra i collegamenti del circuito.

Nello schema possiamo osservare che i pin A0, A1, A2 sono connessi a massa. Questi pin permettono di personalizzare l’indirizzo del dispositivo all’interno del bus I2C. Nel data sheet verifichiamo come viene formato il control byte address:

i 4 bit più significativi sono preimpostati (Control Code) mentre i bit A0, A1 e A2 sono personalizzabili da noi. Il bit meno significativo R/W, serve per selezionare una operazione di scrittura o una operazione di lettura.
Avendo a massa i pin A0, A1 e A2 i campi Chip Select Bits sono a zero. L’indirizzo del dispositivo è quindi il seguente:

in esadecimale otteniamo il valore:

0x50

Per poter eseguire operazioni di scrittura e lettura della memoria EEPROM del 24LC256, è necessario inviare, oltre al Control Byte (che specifica l’indirizzo del dispositivo nel busI2C), altri due byte che indicano l’indirizzo della locazione di memoria EEPROM del 24LC256 che vogliamo scrivere o leggere:

il dispositivo 24LC256 possiede 256Kbit di memoria, quindi le locazioni di memoria che possiamo scrivere e leggere sono 32000 byte (256000 / 8).
Avendo a disposizione 2 byte per selezionare l’indirizzo (Address High Byte e Address Low Byte) possiamo utilizzare una variabile int (formata appunto da 2 Byte) che impiegheremmo per specificare il valore dell’indirizzo della locazione di memoria (da 0 a 31999).

La libreria Wire non permette comunque di passare un valore intero perciò potremmo semplicemente effettuare una operazione bitwise per dividere la variabile intera in due byte. Fortunatamente esistono già delle funzioni che semplificano questa operazione, highByte e lowByte.

Il codice di esempio seguente permette di scrivere tutti i  32000 byte della mem0rie a di eseguire una lettura degli stessi:

#include <Wire.h>

int indirizzo = 0;
int data = 0;
int ciclo = 0;
void setup()
{
  //init seriale
  Serial.begin(9600);
  //per la Arduino Leonardo devo
  //attendere l'inizializzazione del modulo
  while (!Serial)
  {
    ;
  }

  //attendo ulteriori 5 secondi
  //prima di inviare un dato sulla seriale
  delay(5000);
  //invio un messaggio al serial monitor
  Serial.println("Start");
  //inizializzo la porta I2C della Arduino
  Wire.begin();
}

void loop()
{
  //avviso dell'inizio della
  //scrittura dei dati sulla seriale
  Serial.println("Inizio Scrittura");
  //init variabile
  indirizzo = 0;
  //eseguo ciclicamente la scrittura di
  //tutte e 32000 locazioni di memoria
  for (ciclo = 0; ciclo & lt; 32000; ciclo++)
  {
    //invio il control byte specificando
    //una richiesta di scrittura
    Wire.beginTransmission(0x50);
    //invio due byte contenenti l'indirizzo della
    //locazione di memoria che voglio scrivere un byte
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));
    //scrivo un byte nella locazione di memoria
    //precedentemente selezionata
    Wire.write(byte(data));
    //fine trasmissione
    Wire.endTransmission();
    //incrementa il valore di data
    data++;
    //quando la variabile data arriva a 255
    //resetto il suo valore a zero
    if (data == 255)
      data = 0;

    //incrementa il valore dell'indirizzo
    indirizzo++;
    //attendi 5ms per poter terminare le operazioni di
    //scrittura sulla memoria
    delay(5);
  }

  //avvisami quando la scrittura di 32000 byte
  //è terminata
  Serial.println("Fine Scrittura");
  //attendi 1/2 secondo
  delay(500);
  //avvisami dell'inizio della lettura
  Serial.println("Inizio lettura");

  //init variabile
  indirizzo = 0;
  for (ciclo = 0; ciclo & lt; 32000; ciclo++)
  {
    //invio il control byte specificando
    //una richiesta di scrittura
    Wire.beginTransmission(0x50);
    //invio due byte per selezionare la locazione
    //di memoria da leggere
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));
    Wire.endTransmission();
    //incremento la variabile indirizzo
    indirizzo++;
    //richiedo un byte al 24LC256
    Wire.requestFrom(0x50, 1);
    //attendo la disponibilità di dati sul bus i2c

    while (Wire.available())
    {
      Serial.print(ciclo);
      Serial.print(": ");
      //leggo dal bus il dato relativo alla
      //locazione di memoria precedentemente specificata
      byte c = Wire.read();
      //invio il dato al serial monitor
      Serial.println(c);
    }
  }
  delay(1000);
}

la scrittura di 32000 byte richiederà qualche minuto poiché il codice impiega circa 5ms per scrivere un byte (32000 * 0.005 => 160 secondi). La lettura invece risulta più fluida ed è anche influenzata dalla velocità della seriale, che per questo esempio è impostata a 9600bps.

The post 24LC256 utilizzare una memoria seriale su bus I2C appeared first on Esperimenti con logiche programmabili.

Una caratteristica che reputo molto interessante è la possibilità di espandere Arduino tramite l’uso di shield. La maggior parte di queste schede aggiuntive sono però progettate per compiere una funzione specifica, non programmabile.
Esistono alcuni metodi che permettono di comunicare con altri dispositivi utilizzando come canale di trasmissione dati i protocolli seriali (I2C, SPI o RS232). Questo rende possibile demandare ad una scheda slave funzioni di elaborazione gravose, che non vogliamo far eseguire alla scheda master. Ho realizzato questo piccolo tutorial usando il bus I2C per creare uno scambio dati tra un Arduino ed un chip ATmega328 standalone.

Il bus I2C, basandosi su due fili, non permette la comunicazione contemporanea tra Master e Slave. Lo scambio dati deve essere gestito dal Master tramite gli indirizzi (univoci) degli slave. Il flusso può essere sintetizzato in questo modo

1. Il Master invia sul bus un bit di start
2. Il Master invia sul bus l’indirizzo dello slave con cui vuole comunicare
3. Il Master decide se scrivere o leggere dal dispositivo
4. Lo Slave legge o scrive in base alla richiesta del Master

La libreria Wire dispone di tutte le funzioni necessarie alla realizzazione Master-Slave tra due schede Arduino. Lo schema del circuito che ho realizzato è visibile nella figura seguente.

Come detto precedentemente lo schema si basa su Arduino Uno impiegato come Master e con un ATmega328 impiegato come slave.

Il codice permette di inviare un dato numerico allo slave, che provvederà ad incrementarlo per poi rispedirlo al Master.

[c]
//MASTER
#include <Wire.h>

byte x = 0;
byte num = 0;

void setup()
{
//inizializzo la libreria Wire come Master
Wire.begin();

//init seiale
Serial.begin(9600);
//avviso che il programma è avviato
Serial.println("START");

}

void loop()
{
//invio sul bus I2C un byte al device
//che ha come indirizzo il valore 0x04
//start trasmissione
Wire.beginTransmission(0x04);
//invio un byte
Wire.write(x);
//fine trasmissione
Wire.endTransmission();

delayMicroseconds(500);

//richiedo un byte allo slave che ha indirizzo 0x04
Wire.requestFrom(0x04, 1);

//attendo la disponibilità di dati sul bus i2c
while(Wire.available())
{
//quando è presente un dato avvia
//la lettura
num = Wire.read();
}

//incrementa il valore del byte
x++;

//verifico che il byte letto dallo slave sia stato
//incrementato
if(num != x)
Serial.println("ERRORE");

delay(5);

}

[/c]

Il codice seguente è relativo allo Slave

[c]
//SLAVE
#include <Wire.h>

byte x = 0;

void setup()
{
//inizializzo la libreria
//imposto l’indirizzo dello slave
Wire.begin(0x04);

//eventi per la ricezione del dato
//e per la richiesta del dato
Wire.onReceive(receiveEvent);
Wire.onRequest(requestEvent);
}

void loop()
{
//esegui qualcosa
delay(1000);
}

void receiveEvent(int data)
{
//questo evento viene generato quando sul bus
//è presente un dato da leggere

//eseguo la lettura
x = Wire.read();

//elaboro il dato letto
x++;
}

void requestEvent()
{
//questo evento viene generato quando il master
//richiede ad uno specifico slave
//una richiesta di dati

//spedisco il dato al Master
Wire.write(x);

}

[/c]

I commenti presenti nel codice permettono di capire ciò che avviene tra i due dispositivi.

Di seguito uno screenshot dei dati scambiati sul bus

Di seguito invece la trasmissione del Master

The post Comunicazione tra Arduino tramite I2C appeared first on Esperimenti con logiche programmabili.

Continuiamo gli articoli sul bus I2C, utilizzando sempre il nostro amato sensore di temperatura MCP9803. Questa volta ho utilizzato il Netduino per ‘colloquiare’ con il sensore per fare un po di ‘pratica’ con le varie classi esposte dal .Net micro framework che permettono di utilizzare il bus I2C.

Devo dire che con MikroC ho un controllo maggiore (giustamente) sulla comunicazione con il sensore. L’esperienza con Netduino invece mi ha lasciato un po perplesso, forse è una mia impressione ma avrei preferito un codice più snello, forse più a basso livello.

Lo schema elettrico che ho creato per questa esperienza è il seguente:

Anche in questo caso i pin A0 A1 A2 servono per personalizzare l’indirizzo del sensore. Il pin1(SDA) del sensore è collegato al pin4(SDA) del Netduino. Il pin2(SCLK) del sensore è collegato al pin5(SCL) del Netduino.
Il circuito invia i dati al pc utilizzando la porta seriale. Lo schema per la comunicazione seriale è quello utilizzato negli esperimenti precedenti.

Il codice seguente riassume tutte le fasi necessarie per leggere il valore della temperatura dal Temperature Register del sensore MCP9803.

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

using System.IO.Ports;
using System.Text;

namespace NetduinoApplication1
{
public class Program
{
public static void Main()
{
Byte[] tx = new Byte[1];
Byte[] rx = new Byte[2];

SerialPort UART1 = new SerialPort("COM1", 9600, Parity.None,
8, StopBits.One);
//apro la porta seriale
UART1.Open();

//Configurazione contenente l'indirizzo del sensore e la frequenza
//di del bus i2c
I2CDevice.Configuration cnf = new I2CDevice.Configuration(0x48, 400);

//Creo un oggetto per eseguire le richieste di lettura e scrittura
I2CDevice sensore = new I2CDevice(cnf);

//creo un oggetto I2CReadTransaction che viene associato al buffere rx
I2CDevice.I2CReadTransaction[] rd = new I2CDevice.I2CReadTransaction[]
{I2CDevice.CreateReadTransaction(rx)};

//creo un oggetto I2CWriteTransaction che viene associato al buffere tx
I2CDevice.I2CWriteTransaction[] wr = new I2CDevice.I2CWriteTransaction[]
 {I2CDevice.CreateWriteTransaction(tx)};

//Ciclo infinito
while (true)
{
//eseguo una richiesta di lettura
sensore.Execute(rd, 100);
//invio i dati sulla seriale
UART1.Write(rx, 0, rx.Length);
//attendo 2 secondi
Thread.Sleep(2000);
}

UART1.Close();
}
}
}

L’esempio è molto sintetico e tutto il codice ruota attorno alla classe I2CDevice.

Per utilizzare il modulo I2C del Netduino dobbiamo prima creare un oggetto di configurazione tramite la classe I2CDevice.Configuration. I parametri da passare al costruttore sono due, uno riguarda l’indirizzo del sensore (ottenuto con i 4 bit fissi preimpostati dalla casa costruttrice e i tre scelti dall’utente, A0 A1 A2, che nel nostro caso sono 1001 + 000 = 1001000 = 0x48 in esadecimale) e l’altro la frequenza di clock del segnale SCL (che stabilisce la velocità di comunicazione) impostato a 400Khz.
Ora creo un oggetto I2CDevice necessario per eseguire le richieste di lettura e scrittura sul bus I2C. Il costruttore richiede come parametro l’oggetto I2CDevice.Configuration (nel nostro caso l’oggetto cnf creato precedentemente).

Per leggere e scrivere dal bus I2C dobbiamo creare due oggetti I2CTransaction, il primo associa al comando di lettura il buffer dove verranno contenuti i byte letti dal sensore, il secondo associa al comando di scrittura il buffer dove sono contenuti i dati da inviare al sensore.

Netduino esegue ciclicamente (ciclo while) il metodo Execute relativo all’oggetto sensore. I parametri da passare al metodo sono l’oggetto I2CTransaction (che può essere quello di lettura o scrittura) e il tempo di timeout della richiesta.

Nell0 specifico il comando sensore.Execute(rd, 100); esegue una lettura sul bus I2C, l’oggetto rd permette di scrivere i dati letti dal sensore nel buffer rx.

Infine Netduino invia sulla seriale i byte relativi al registro di temperatura del sensore MCP9803.

Il .net micro framework rende semplice l’uso del bus I2C occupandosi di impostare il bit per la lettura/scrittura e per la gestione degli acknowledgee.
In pratica ci dobbiamo solo occupare di specificare l’indirizzo del sensore e la grandezza dei buffer di lettura e scrittura.

Come sempre suggerimenti e critiche sono sempre graditi.

The post Netduino e bus I2C, collegamento al sensore MCP9803 appeared first on Esperimenti con logiche programmabili.