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.

Nella prima parte abbiamo visto come comunicare con il sensore di temperatura MCP9803 utilizzando il bus I2C per leggere il valore di temperatura contenuto nel Temperature Register.
Proveremmo ora a fare qualcosa di più interessante variando alcuni parametri del sensore. Il circuito elettrico è sempre quello impiegato nella prima parte dell’articolo.

Il register pointer permette di selezionare 4 registri differenti a seconda di come vengono impostati i bit P0 e P1.

Per cambiare la risoluzione del convertitore dobbiamo accedere al registro di configurazione. Come mostra la tabella della figura precedente bisogna impostare il bit P1 a 0 ed il bit P0 a 1.

La figura seguente Riporto in figura il registro Configuration register  come illustrato nel datasheet:

Come è possibile osservare questo registro permette di eseguire diverse operazioni. Quella che a noi ci interessa è relativa alla sezione Resolution (Bit5 e Bit6). Quando il sensore di temperatura viene alimentato i bit di questo registro sono impostati tutti a 0 (Power-up default).

Le operazioni che dobbiamo eseguire per impostare la risoluzione del convertitore a 12bit sono le seguenti:

1. Selezionare il sensore tramite l’indirizzo
2. Selezionare il registro di configurazione
3. Impostare i bit5 e il bit6 a 1
4. Selezionare il registro della temperatura
5. Leggere dal registro della temperatura

Queste sono le illustrazioni presenti nel datasheet:

Il master invia un comando di Start, invia un byte contenente l’indirizzo del sensore (7bit) e il flag di lettura/scrittura, nel nostro esempio 1001000 (0x90 in esadecimale). Il sensore risponde con un acknowledges (ACK), il master invia il secondo un byte che sarà scritto sul Pointer Register. Questo valore è 00000001 (0x01 in esadecimale) che seleziona il Configuration Register. Il sensore risponde con un acknowledges. Il master invia un terzo byte 01100000 (0x60 in esadecimale) che sarà scritto nel configuration register. Il sensore risponde con un acknowledges. Il master termina la comunicazione con un comando di Stop.

Ora possiamo eseguire la procedura di lettura come abbiamo visto nella prima parte:

Riassumiamo la procedura:

• Il master invia un comando di Start
• Il master invia un byte contenente l’indirizzo dello slave e il flag di lettura/scrittura impostato su lettura (1).
• Il sensore risponde con un acknowledges.
• Il master legge il primo byte dallo slave e  invia un acknowledges.
• Il master legge il secondo Byte e invia un not acknowledges(NAK) per indicare allo slave la fine della lettura.
• Il master invia il comando di stop.

Utilizzando la tabella di esempio possiamo apprendere come i dati verranno scritti nel Temperature Register:

Prendiamo per esempio la colonna 12bit ed una temperatura ambiente di 25.4375°C, il valore binario presente nel Temperature Register è 000110010111. Il primo byte letto dal pic è 00011001 mentre il secondo byte letto è 01110000.
Il primo byte letto dal pic è quello più significativo mentre il secondo è quello meno significativo. Per ottenere il valore della temperatura ambiente, campionata dal sensore, dobbiamo prendere il valore binario del secondo byte e unirlo al valore binario del primo byte in questo modo

00011001 + 0111 => 000110010111

il valore ottenuto è 000110010111 che convertito in decimale diviene 407. La temperatura viene calcolata utilizzando la formula seguente:

n nel nostro caso vale -4 perché la risoluzione del convertitore è settata a 12bit, di conseguenza la nostra formula per calcolare la temperatura diventa:

407 * 2^-4 => 407 * 0.0625 => 25.4375°C

Il codice di esempio seguente è compilato e caricato sul pic16f876, sono presenti numerosi commenti che illustrano il funzionamento del programma:

unsigned short Primo_Byte = 0;
unsigned short Secondo_Byte = 0;

void main()
{
//inizializzo la porta UART
//a 9600bps
UART1_Init(9600);
//Inizializzo la porta I2C
//con una velocità di 400Khz
I2C1_Init(400000);

//Attendo 100 millisecondi
Delay_ms(100);

//procedura per variare la risoluzione
//del convertitore digitale
//invio uno Start sul bus I2C
I2C1_Start();
//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x90); //10010000
//Seleziono il registro di configurazione
I2C1_Wr(0x01); //00000001
//scrivo sul Configuration Register il valore 96
//per impostare 12bit di risoluzione
I2C1_Wr(0x60);
//termino la comunicazione
I2C1_Stop();

//invio uno Start sul bus I2C
I2C1_Start();
//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x90); //10010000
//scrivo sul Register point il valore 0
//per accedere al Temperature Register
I2C1_Wr(0x00);

//ciclo infinito per leggere
//continuamente la temperatura
while (1)
{
//invio uno Start sul bus I2C
I2C1_Start();

//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x91); //10010001
//leggo il primo Byte ed invio un acknowledge
Primo_Byte = I2C1_Rd(1);
//leggo il primo Byte ed invio un NOT acknowledge
Secondo_Byte = I2C1_Rd(0);
//Invio uno stop sul bus I2C
I2C1_Stop();

//Invio sulla seriale i dati letti dal sensore
UART1_Write(Primo_Byte);
UART1_Write(Secondo_Byte);

//attendo 2 secondi tra una lettura e la
//sucessiva
Delay_ms(2000);

}
}

Quello che adesso rimane da fare è il software lato pc che acquisisce i dati dalla seriale. Ho utilizzato Visual C# per creare un’applicazione windows form.
Anche in questo caso il codice seguente è ricco di commenti che permettono di capire meglio il programma:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Collections;
using System.IO.Ports;

namespace SensoreTemperaturaMCP9803
{
public partial class frmMain : Form
{
//variabili per la lettura dalla seriale
Double temperaturaRX = 0;
Int16 Temperatura = 0;
Byte[] bytesRicevuti = new Byte[2];

//creo un delegate per accedere dal thread secondario a quello principale
public delegate void AggiornaTXT(string _str);

/// <summary>
/// questa funzione permette di accedere alla textbox da un thread secondario
/// </summary>
/// <param name="str">Testo da inserire nella textbox</param>
public void FormTxtUpdate(string str)
{
if (this.txtTemperatura.InvokeRequired)
{
AggiornaTXT updaterdelegate = new AggiornaTXT(FormTxtUpdate);
this.Invoke(updaterdelegate, new object[] { str });
}
else
{
txtTemperatura.Text = str;
}
}

/// <summary>
/// Questa funzione converte un valore binario in un valore a 16 bit
/// </summary>
/// <param name="ValoreBinario">Valore in bit</param>
/// <param name="Start">Indice di partenza del BitArray</param>
/// <param name="NumBit">Numero di bit da convertire</param>
/// <returns></returns>
private Int16 ConverToDecimal(BitArray ValoreBinario, Int32 Start, Int32 NumBit)
{
Int32 Ciclo = 0;
Int16 Valore = 0;

for (Ciclo = 0; Ciclo < NumBit; Ciclo++)
{
if (ValoreBinario[Ciclo + Start])
Valore |= (Int16)(1 << Ciclo);
}

return (Valore);
}

public frmMain()
{
InitializeComponent();
}

/// <summary>
/// Questo evento viene generato ala ricezione di un byte sulla seriale
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RS232_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
//questa funzione viene eseguita in un thread secondario

//quando sono disponibili almeno 2 byte inizia
//l'elaborazione
if (RS232.BytesToRead >= 2)
{
//leggi 2 byte e memorizzali nell'array bytesRicevuti
RS232.Read(bytesRicevuti, 0, 2);

//inverto l'array
Array.Reverse(bytesRicevuti);
//converto l'array di 2 byte in un array di bit
BitArray ba = new BitArray(bytesRicevuti);

//ottengo il valore della temperatura utilizzando solo i bit validi
//versione con risoluzione a 9bit
//Temperatura = ConverToDecimal(ba, 7, 8);
//calcolo il valore della temperatura
//se il valore del convertiore è a 9 bit devo moltiplicare per 0.5
//temperaturaRX = Temperatura * 0.5;

//ottengo il valore della temperatura utilizzando solo i bit validi
//versione con risoluzione a 12bit
Temperatura = ConverToDecimal(ba, 4, 12);
//calcolo il valore della temperatura
//se il valore del convertiore è a 12 bit devo moltiplicare per 0.0625
temperaturaRX = Temperatura * 0.0625;

//rappresento il valore della temperatura nella textbox
FormTxtUpdate(Convert.ToString(temperaturaRX) + " °C");
}
}

private void frmMain_Load(object sender, EventArgs e)
{
//apro la seriale per iniziare a leggere i dati
RS232.Open();
}

private void frmMain_FormClosed(object sender, FormClosedEventArgs e)
{
//alla chiusura del form chiudo la comunicazione seriale
RS232.Close();
}

private void btnChiudi_Click(object sender, EventArgs e)
{
//chiudi
Close();
}
}
}

Le operazioni che esegue il programma sono riassunte in questo modo:

• La porta seriale viene aperta per poter acquisire i dati
• Un gestore di evento viene scatenato quando sulla seriale arrivano dei dati
• Il gestore di evento leggere due byte alla volta.
• Il gestore di evento elabora i due byte in modo da ottenere il valore decimale del dato della temperatura
• Il valore della temperatura è visualizzato su un controllo textbox

Adesso potete divertirvi con il codice per creare un datalogger della temperatura e magari creare un sistema con più sensori di temperatura.

Come sempre suggerimenti e critiche sono sempre ben accette.

Buon divertimento!

The post Accedere ai registri dell’MCP9803 (2° parte) appeared first on Esperimenti con logiche programmabili.