Introduzione
Tutti noi abbiamo usato un potenziometro almeno una volta nella vita: è la classica manopolina del volume della nostra radio! Magari non ci accorgiamo però quando invece abbiamo a che fare con un potenziometro digitale. Quando sulla radio, per variare il volume della musica, non usiamo una manopola ma dei pulsanti + o -, è probabile che stiano comandando un potenziometro digitale che altro non è che un potenziometro comandato elettronicamente invece che tramite una manopola.
Come funziona un potenziometro classico?
Un potenziometro è un dispositivo a 3 terminali usato come resistore variabile. E’ dotato di un contatto rotante comandato dalla manopola e viene usato come partitore di tensione.
Il suo simbolo elettrico è quello di una classica resistenza ma con il contatto intermedio comandato dalla manopola:
Come funziona un partitore di tensione?
Un partitore di tensione è un semplice circuito in cui la tensione in uscita è una frazione della tensione in ingresso. Si possono usare due resistori fissi oppure un potenziometro.
Vediamone lo schema e la formula:
Il potenziometro è indicato con la lettera P mentre R1 e R2 sono le due sezioni della resistenza totale che variano a seconda della posizione del cursore (che è comandato dalla manopola).
Come puoi osservare la tensione Vo di uscita è una frazione di quella di ingresso Vi. La Vo varia tra due estremi:
- Vo = 0 quando R2 = 0 (la manopola è ruotata tutta verso il terminale collegato al polo negativo della batteria)
- Vo = Vi quando R1 = 0 (la manopola è ruotata tutta verso il terminale collegato al polo positivo della batteria)
I potenziometri digitali
Questi esempi si basano su potenziometri meccanici ma esistono in commercio anche dei tipi di potenziometri che sono completamente elettronici e regolabili tramite un opportuno segnale in ingresso. Sono i cosiddetti potenziometri digitali.
Oggi vogliamo testarne uno comandandolo tramite Arduino, in particolare il modello MCP41010, che è un singolo potenziometro. Il suo valore massimo è di 10 kΩ mentre il valore minimo è di circa 100 Ω.
Vediamo ora il pinout di questo componente:
Il nome del dispositivo dipende dal massimo valore di resistenza del singolo potenziometro digitale e dal numero di potenziometri presenti al suo interno. Per esempio:
- MCP41010: singolo potenziometro, 10 kΩ
- MCP41050: singolo potenziometro, 50 kΩ
- MCP41100: singolo potenziometro, 100 kΩ
- MCP42010: due potenziometri indipendenti, 10 kΩ
- MCP42050: due potenziometri indipendenti, 50 kΩ
- MCP42100: due potenziometri indipendenti, 100 kΩ
Per pilotare il nostro potenziometro digitale useremo un Arduino UNO e la sua porta SPI.
Osservando il datasheet del potenziometro digitale si può vedere come, per comandare questo chip, sia necessario mandargli prima un “command byte” (per dire al chip cosa deve fare) e poi un “data byte” (per dire al chip quale valore di resistenza settare, da 0 a 255).
Per esempio, per settare una resistenza di 10 kΩ, dobbiamo mandare un data byte pari a 11111111 (corrispondente a 255), per settare una resistenza di 5 kΩ dobbiamo mandare un data byte pari a 10000000 (corrispondente a 128) e così via.
Perché il comando venga eseguito, per prima cosa il terminale CS deve essere messo a 0 (valore LOW) poi bisogna mandare il command byte seguito dal data byte (per un totale di 16 bit). Infine bisogna riportare il terminale CS al valore 1 (valore HIGH). Solo allora il comando verrà eseguito (dal datasheet:”Executing any command is accomplished by setting CS low and then clocking-in a command byte followed by a data byte into the 16-bit shift register. The command is executed when CS is raised.”)
Di che componenti abbiamo bisogno?
La lista dei componenti non è particolarmente lunga:
- una breadboard per connettere l’Arduino UNO agli altri componenti’
- alcuni fili DuPont (maschio – maschio, maschio – femmina, femmina – femmina)
- un potenziometro digitale MCP41010
- un resistore da 220Ω
- un LED rosso
- e, ovviamente, una scheda Arduino UNO !
Vediamo ora lo schema di montaggio
Lo scopo del nostro esperimento è quello di variare ciclicamente la luminosità del LED comandandola con Arduino UNO tramite il potenziometro digitale MCP41010.
Connettiamo ora il nostro circuito di test come mostrato nella figura sottostante:
e carichiamo lo sketch nel nostro Arduino UNO scaricabile da qui:
Analizziamo il codice
Inizialmente impostiamo i pin della alla porta SPI relativi ai segnali CS, CLK e MOSI. Poi impostiamo il command byte e il valore iniziale di luminosità del LED:
int CS_signal = 2; // Chip Select signal onsul pin 2 of Arduino
int CLK_signal = 4; // Clock signal on pin 4 of Arduino
int MOSI_signal = 5; // MOSI signal on pin 5 of Arduino
byte cmd_byte2 = B00010001 ; // Command byte
int initial_value = 100; // Setting up the initial value
Definiamo poi la funzione initialize che manda il command byte e il valore iniziale al potenziometro digitale tramite la porta SPI (praticamente lo inizializza):
void initialize() { // send the command byte of value 100 (initial value)
spi_out(CS_signal, cmd_byte2, initial_value);
}
Definiamo poi due funzioni (spi_out e spi_transfer) che servono a mandare i comandi e i valori al potenziometro digitale (sempre tramite la porta SPI):
void spi_out(int CS, byte cmd_byte, byte data_byte){ // we need this function to send command byte and data byte to the chip
digitalWrite (CS, LOW); // to start the transmission, the chip select must be low
spi_transfer(cmd_byte); // invio il COMMAND BYTE
delay(2);
spi_transfer(data_byte); // invio il DATA BYTE
delay(2);
digitalWrite(CS, HIGH); // to stop the transmission, the chip select must be high
}
void spi_transfer(byte working) {
for(int i = 1; i <= 8; i++) { // Set up a loop of 8 iterations (8 bits in a byte)
if (working > 127) {
digitalWrite (MOSI_signal,HIGH) ; // If the MSB is a 1 then set MOSI high
} else {
digitalWrite (MOSI_signal, LOW) ; } // If the MSB is a 0 then set MOSI low
digitalWrite (CLK_signal,HIGH) ; // Pulse the CLK_signal high
working = working << 1 ; // Bit-shift the working byte
digitalWrite(CLK_signal,LOW) ; // Pulse the CLK_signal low
}
}
Nella funzione setup impostiamo i pin digitali, definiti precedentemente, come OUTPUT, inizializziamo il potenziometro digitale e la porta seriale:
pinMode (CS_signal, OUTPUT);
pinMode (CLK_signal, OUTPUT);
pinMode (MOSI_signal, OUTPUT);
initialize();
Serial.begin(9600); // setting the serial speed
Serial.println("ready!");
Nella funzione loop sono presenti due “cicli for”: il primo aumenta gradualmente la resistenza in serie al LED, il secondo diminuisce gradualmente la resistenza in serie al LED.
for (int i = 0; i < 255; i++) {
spi_out(CS_signal, cmd_byte2, i);
Serial.println(i); delay(10);
}
for (int i = 255; i > 0; --i) {
spi_out(CS_signal, cmd_byte2, i);
Serial.println(i);
delay(10);
}
Il risultato è che il LED si accende e si spegne in maniera graduale (come può essere osservato dal video qui sotto):
Considerazioni finali
Come puoi vedere, il circuito presentato è molto semplice ma è sufficiente a mostrare l’utilità di questi dispositivi. Ovviamente avremmo potuto pilotare il LED, variandone sempre ciclicamente la luminosità, tramite un segnale PWM ma non era questo lo scopo del nostro tutorial. Un possibile impiego di tale potenziometro è in accoppiamento con un amplificatore operazionale, col quale possiamo realizzare amplificatori di segnale o filtri attivi comandati elttronicamente (e non tramite manopola).
Risorse esterne
Per ulteriori informazioni vedi anche:
https://nicksen782.blogspot.it/2010/06/digital-potentiometers-mcp42010.html
Newsletter
Se vuoi essere aggiornato sui nuovi articoli, iscriviti alla newsletter. Prima dell’iscrizione alla newsletter leggi la pagina Privacy Policy (UE)
Se ti vuoi disiscrivere dalla newsletter clicca sul link che troverai nella mail della newsletter.