Pulsanti

Con Arduino posson esser usati in INPUT per determinare dei comportamenti specifici sui circuiti creati. Basta usare dei pin sui qualis i determinerà se è stato premuto o meno un pulsante in base alla corrente che rileveranno, per i pin digitali si capterà se la tensione è alta (5V = HIGH) o bassa (0V = LOW, a massa).

Pulsanti in pull down
Per cui il PIN 8 riceverà lo stato HIGH solo quando il pulsante sarà premuto altrimenti sarà collegato a massa tramite una resistenza da 10K Ohm

Pulsanti in pull Up
E' il funzionamento opposto a quello del pull down per cui in questo caso il PIN 8 riceverà sempre corrente attraverso la resistenza, chiamata resistenza di pull up, (quindi sarà in stato HIGH), la pressione del pulsante chiuderà il circuito togliendo corrente al PIN 8.

Pull up senza resistore

Esiste una speciale impostazione di Arduino che consente l'aggiunta di un pulsante senza la necessità di aggiungere una resistenza nel controllo dello stato 0V. Basta configurare un PIN come pin destinato all'ingresso e con la costante "INPUT_PULLUP", sarà lo stesso microcontrollore a collegare una resistenza interna al pin. Semplicemente il pulsante sarà collegato al PIN e ad un pin di ground di Arduino.

Pulsante su linea analogica

Possiamo usare un solo pin analogico su cui impostare n pulsanti, su ogniuno di questi c'è una opportuna resistenza, la lettura di questo pin analogico ci dirà quale pulsante è stato premuto. Tutto questo circuito pulsanti e resistenze è un partitore di tensione. Per mantenere stabile l'ingresso analogico, è necessario collegare il partitore a massa con una resistenza R5 di 1 MΩ. R5 è abastanza grande da non interferire col partitore.
E' una tecnica per cui dei resistori in serie si attivano alla pressione di bottoni ed il valore della resistenza finale indica quale bottone è stato premuto.
Per questo esempio si usano:

3 pulsanti: BT1, BT2, BT3;
4 resistori da 4.7 KΩ;
1 resistore da 1 MΩ, R5.

I pulsanti si nominano da sinistra verso destra, il primo a sx è BT1 che se premuto restituirà una tensione maggiore.

Il partitore dividerà la tensione in 3 livelli: 1.25V, 2.25V, 3.75V. Premendo BT1 il pin A0 leggerà 3.75V, premendo BT2 2.5V e con BT3 avremo 1.25V.

Sketch

#include <Arduino.h>
 
const int m_soglia = 10; // Soglia per prevenire rumore nella tensione rilevata
 
void setup() {
  Serial.begin(115200);
  while (!Serial) { }
}
 
void loop() {
  // Si legge l'ingresso analogico A0
  int valoreAnalogico = analogRead(A0); //da 0 a5V corrispomndenti a 0-1023
 
  //Se il valore è compreso tra due livelli si può riconoscere quale dei 3 pulsanti è stato premuto
  if ((valoreAnalogico > 255 - m_soglia) && (valoreAnalogico < 255 + m_soglia)) {
    Serial.println("Premuto pulsante BT3");
  } else if ((valoreAnalogico > 509 - m_soglia) && (valoreAnalogico < 509 + m_soglia)) {
    Serial.println("Premuto pulsante BT2");
  } else if ((valoreAnalogico > 765 - m_soglia) && (valoreAnalogico < 765 + m_soglia)) {
    Serial.println("Premuto pulsante BT1");
  } else {
    Serial.println("Nessun pulsante premuto");
  }
}

Dalla doc Arduino qui c'è un esempio per calcolare il voltaggio corrispondente al valore restituito da analogRead()</code>

Debouncing

Guardando lo sketch nel paragrafo dedicato al pulsante di Pull Up si noterà che si sono registrate più pressioni del pulsante di quelle attese, ebbene questo fenomeno si chiama debouncing ovvero "rimbalzo". Sostanzialmente si verificano dei falsi contatti, il fenomeno si elimina introducendo delle pause dopo la rilevazione della pressione del pulsante. Nel seguente NON si usano i delay() perché costosi in termini di risorse, al loro posto si usa millis().

#define BUTTON = 8;
 
unsigned long t = 0;
const unsigned long debounce_delay = 200; //Millisecondi
 
void setup() {
  Serial.begin(9600);
  while (!Serial) {} //Utile da Arduino Uno R4 in sù
  pinMode(BUTTON, INPUT);
}
 
void loop() {
  int tasto = digitalRead(BUTTON);
  if (tasto) {
    if (millis() - t) > debounce_delay  {
       //Si suppone che i rimbalzi siano finiti
 
      Serial.println("Pemuto pulsante");
      t = millis(); //Si fotografa il momento
    }
  }
}

LED

Ogni LED che collegheremo ad Arduino deve essere accompagnato da una resistenza adatta alla sua tensione di alimentazione ed alla corrente (questa è comunque una regola generale), la tensione è di 5V (o 3.3V su alcuni modelli) e la corrente solitamente è 10 o 15 mA. (link interno sui LED)
Hanno due terminali, + anodo, - catodo. Il catodo è la gamba più corta e sotto la 'cupola' termina come una specie di mazza da golf.

Colore	Tensione (volt);	Resistenza consigliata () Alimentazione=5V - Corrente 12mA*	Resistenza per corrente a 6mA Arduino Uno R4
Rosso	1,8 V.	266Ω ~270Ω	533Ω ~560Ω
Giallo	1,9 V.	~260Ω	Ω
Verde	2,0 V.	250Ω	500Ω ~470Ω
Blu	3,5 V.	125Ω	250Ω ~220Ω
Bianco	3,0 V.	~170Ω	Ω
Infrarosso	1,3 V.	~310Ω	Ω

(*) TEORIA Si applicano il Secondo teorema di Kirchhoff ((o Legge delle Maglie)) e la Legge di Ohm. ATTENZIONE Tra una versione di Arduino ed un altra la corrente può cambiare!
Per Kirchhoff, in ogni percorso chiuso (maglia), la somma algebrica di tutte le tensioni (forze elettromotrici e cadute di tensione) è zero, perché l'energia si conserva tornando al punto di partenza. Pertanto se usassimo un LED Verde, nel ns caso (ipotesi: tensione 5V e corrente 12mA ovvero 0.012A):

V_Arduino - V_resistenza - V_led= 0
Applicando la Ohm per cui: V=R*i
5V - V_led= V_resistenza ovvero 5V-2V = V_resistenza ovvero 5V-2V = R * i ovvero 3V = R * 12mA ovvero R = 3V / 0,012A = 250Ω

E' intuibile che i LED possono essere collegati a due pin qualsiasi di Arduiono (usando comunque la resistenza) per l'accensione l'importante è che questi due pin abbiano stato opposto (uno in stato HIGH e l'altro LOW). Quando il PIN 11 è in stato alto il LED verde si accende ed il Rosso rimane spendo e viceversa quando il PIN 11 si spegne.

LED RGB

Sono LEd che possono generare TUTTI i colori variando la luminosità dei colori base, infatti, essi contengono 3 led: rosso, verde, blu (RGB). Hanno 4 piedini, quello più lungo in genere è il catodo (-) chiamato anche "comune".

La regolazione della luminosità dei 3 led si fa usando la funzionalità, analogWrite(), del pin PWM di Arduino (quelli con la ~), supponiamo di usare i pin 9, 10 e 11. Il collegamento NON sarà diretto ma poiché i led lavorano con tensioni diverse (vedi tabella precedente) richiedono resistenze diverse, supponendo di sperimentare con Arduino Uno R4 le resistenze saranno da:

560Ω per il led rosso, R. Calcoli: (5V - 1.8V) * 0.006A = 3.2V * 0.006A = 533Ω
470Ω per il led verde, G. Calcoli: (5V - 2V) * 0.006A = 3V * 0.006A = 500Ω
220Ω per il led blu, B. Calcoli: (5V - 3.5V) * 0.006A = 1.5V * 0.006A = 250Ω

Sketch

#include <Arduino.h>
 
int m_loopMax = 1000;
 
void setup() {  
  Serial.begin(9600);
  int i = 0;
  while (!Serial)  {
    i++;
    if (i > m_loopMax) {
      break;
    }
    delay(10);
  }
  Serial.println("Test Led RGB");
  //--
  randomSeed(analogRead(A0));
}
 
void loop() {
  // Si generano 3 numeri casuali tra 0 e 255
  int red = random(0, 256);
  int green = random(0, 256);
  int blue = random(0, 256);
  // Si imposta la luminosità del led RGB usando la funzionalità dei pin PWM
  analogWrite(9, red);
  analogWrite(10, green);
  analogWrite(11, blue);
 
  delay(400);
}

LED RGB con potenziometro

Con la versione seguente si regola la luminosità usando dei potenziometri\trimmer

Sketch

#include <Arduino.h>
 
int m_loopMax = 1000;
int m_red = 0;
int m_green = 0;
int m_blue = 0;
 
void setup() {  
  Serial.begin(9600);
  int i = 0;
  while (!Serial)  {
    i++;
    if (i > m_loopMax) {
      break;
    }
    delay(10);
  }
  Serial.println("Test Led RGB");
  //--
  randomSeed(analogRead(A0));
  // Si generano 3 numeri casuali tra 0 e 255
  m_red = random(0, 256);
  m_green = random(0, 256);
  m_blue = random(0, 256);
}
 
void loop() {
  //Si leggono i valori di 3 potenziometri per regolare la luminosità dei tre colori
  m_red = analogRead(A0) / 4;    // Si divide per 4 perché il valore letto è tra 0 e 1023
  m_green = analogRead(A1) / 4;
  m_blue = analogRead(A2) / 4;
 
  Serial1.print("R:");
  Serial1.print(m_red); 
  Serial1.print(" G:");
  Serial1.print(m_green);
  Serial1.print(" B:");
  Serial1.println(m_blue);
 
  // Si imposta la luminosità del led RGB usando la funzionalità dei pin PWM
  analogWrite(9,  m_red);
  analogWrite(10, m_green);
  analogWrite(11, m_blue);
}

Display

I displositivi generici son stati spostati al link interno: Integrazioni Display

Relay

Ad esempio se si vogliono attivare delle luci o dei motori con Arduino o altro dispositivo in grado di generare un "impulso" di corrente da 5V (ma anche da altre tensioni), serve collegarlo ad un relè che con tale impulso farà chiudere un circuito aziondo quel che si vuole.
In poche parole un relè è un interruttore magnetico che viene sollecitato da un impulso di corrente, in questa semplice formula fintanto che c'è flusso l'interruttore magnetico e conseguentemente il circuito, posson rimanere chiusi (o aperti a seconda di come si sceglie di farlo funzionare).

Il relè ha due circuiti totalmente indipendenti, uno di controllo ad es. a corrente continua (DC) che è per azionare il magnete interruttore ed un altro ad es. a corrente alternata (AC), che serve per attivare un carico.
può funzionare con diverso voltaggio ma il problema è che per funzionare ha bisogno di tanta corrente, es. 84 mA. In corrente continua la corrente necessaria si fornice per tramite di un transistor.
Il tranistor ha la funzione a sua volta di interruttore, si userà un transistor BJT bipolare NPN a saturazione.
- Una vantaggio del transistor è quella di fornire sufficientemente corrente al relè.
- E' composto da tre piedini: base, emettitore e collettore. La base riceve il comando mediante della corrente a pochi milliampere (es. 13mA) così si satura (si "riempie") e consentirà il passaggio di cariche negative dall'emettitore al collettore. Quando si "chiude" il circuito tra emettitore e collettore, il flusso che si crea sarà utile per azionare il relè (eccitando la sua bobbina interna che chiude o apre il circuito secondario di lavoro).
al relè si aggiunge un diodo per evitare che, dopo aver azionato il relè, della corrente dalla bobbina vada in circolo per far danni ai componenti che lo circondano.
per avere una indicazione visiva di quando il relè si attiverà si può aggiungere un led verde che consuma 2V, visto che la tensione di alimentazione è da 5V, la corrente sarà di 13mA gli applicheremo una resistenza di 380Ohm (5V = 380Ohm*0.013A)

Il progetto è il seguente implementato con Fritzing:

Saldatore, millefori e tanta pazienza ed esce fuori questo:

L'orrendo retro:

E ad 1.5€ si trova comodamente questo ma senz'anima:

Servomotore

Un servomotore (anche chiamato "RC Servo") è un piccolo dispositivo elettronico per azionare parti meccaniche con precisione. La rotazione non è completa ma arriva ad un massimo di 180-270° a seconda del modello. I servomotori raggiungono una posizione impostata e la mantengono. Video di Paolo Aliverti qui

Componenti di un servomotore:

motore in corrente continua;
potenziometro, usato per rilevare la posizione del motore;
gruppo di ingranaggi per aumentare la "potenza meccanica" del dispositivo demoltiplicando i giri del motore e collegare potenziometro al motore;
piccolo circuito di pilotaggio che riceve il segnale di pilotaggio, aziona il motore e rileva la posizione mediante il potenziometro.

Dal servomotore fuoriescono tre fili:

rosso per l'alimentazione, in funzione del motore possono esser sufficienti 5V ed è collegabile direttamente da Arduino altrimenti si collegherà ad opportuna alimentazione esterna;
nero per la massa GND, si può collegare direttamente su quella disponibile su Arduino.
giallo/marrone/arancione/bianco per l'ingresso del segnale di pilotaggio. Va benissimo un pin PWM digitale di Arduno.

La forza è misurata come "coppia" ed è espressa in kgm (chilogrammetri). Per capire il concetto di chilogrammetro: ad es. un servo con coppia di 2 kgm è in grado di sollevare 2 kg collegato ad un asta lunga 1 m collegata al suo perno. Se riducessimo la lunghezza dell'asta della metà raddopieremmo il peso sollevabile quindi da 2 a 4 kg.
Il segnale di pilotaggio è digitale quindi possiamo collegare direttamente il servomotore ad Arduino, si usano i pin PWM ed il motivo è legato alla natura del segnale richeisto in cui si devono rispettare dei tempi precisi per inviare l'angolo di apertura che dovrà assumere l'asta sul motore.
Per i servomotori occorre inviare ogni 20 ms un impulso positivo di ampiezza variabile che va da un minimo di 1 ms ad un massimo di 2 ms.

Variando l’ampiezza dell’impulso si possono ottenere tutti i valori di posizione che variano da 0° fino al massimo supportato dal servo. (nell’esempio 180°).
Qui, 1ms è chiamato “impulso minimo”, 2ms è chiamato “impulso massimo”, il periodo di 20ms è chiamato “frequenza di ripetizione” (50 HZ qui). Servomotori di marche diverse possono avere segnali PWM di controllo diversi.
Integrazione con Arduino
Come si vedrà dallo sketch l'uso di librerie specifiche evita la programmazione complessa nella taratura degli impulsi e frequenza.

Arduino IDE include già la libreria speciale per il pilotaggio dei servomotori, per le nuove schede potrebbe non essere disponibile e va installata, cercare ed usare la libreria "Servo" by Michael Margolis.
NOTARE che dopo la definizione dell'angolo che dovrà assumere l'asta del servomotore si usa un delay(20) è un ritardo introdotto per dare il tempo al servomotore di acquisire la posizione inviatagli.

#include <Arduino.h>
#include <Servo.h>
 
Servo rcServo;
 
void setup() {
  Serial.begin(9600);
 
  while (!Serial) {} 
  // Si configura il servo indicando il pin da usare
  rcServo.attach(9);
}
 
void loop() {
  // Movimento del servo da 0 a 180 gradi gradualmente
   for (int i = 0; i <= 180; i++) {
     rcServo.write(i);              // Imposta l'angolo del servo
     Serial.print("Angolo: ");
     Serial.println(i);         // Stampa l'angolo corrente sul monitor seriale
     delay(20);                 // Attende 20ms per permettere al servo di raggiungere la posizione
   }
 
    // Movimento del servo da 180 a 0 gradi gradualmente
    for (int i = 180; i >= 0; i--) {
      rcServo.write(i);              // Imposta l'angolo del servo
      Serial.print("Angolo: ");
      Serial.println(i);         // Stampa l'angolo corrente sul monitor seriale      
      delay(20);                 // Attende 20ms per permettere al servo di raggiungere la posizione
    }
}

Circuiti integrati digitali

Registri a scorrimento

Shift Register. In questo ambito la loro utilità è nell'aumentare il numero di ingressi\uscite di Arduino o ad esempio per realizzare degli effetti visivi con i LED.
Si classificano a seconda del tipo di ingresso e di uscita che posson essere seriali o paralleli.

Una linea seriale è formata da un solo filo su cui trasmettere dati come sequenze di bit a tempo di clock;
Una linea parallela usa più fili su cui si tramettono più bit contemporaneamente, sono più veloci delle linee seriali ma impegnano più fili per funzionare.

Nomenclatura in base alla tipologia di conversione in input e output:

SISO: Serial Input -> Serial Output;
SIPO: Serial Input -> Parallel Output; per moltiplicare gli output.
PISO: Parallel Input -> Serial Output; per ridurre l'uscita ad una singola linea.
PIPO: Parallel Input -> Parallel Output.

In sintesi, per aggiungere 8 uscite si useranno i chip SIPO mentre per aggiungere ingressi si useranno i PISO. L'organizzazione del flusso dati su seriale è effettuata grazie alla sincronizzazione del segnale di clock.
Ad es., i registri SIPO di un chip vanno collegati a tre pin digitali di Arduino:

clock: segnale di temporizzazione per inviare una sequenza di bit al registro;
dati: pin da cui invieremo i bit al registro;
abilitazione: attiva le uscite del registro.

Per impostare le uscite, caricheremo lo stato desiderato con "otto copi" sul clock e presentando i dati sul pin dei dati; al termine del caricamento attiveremo i dati caricati agendo sul pin di attivazione del registro.

74HC164

Il chip 74HC164 (o 74LS164) è un shift register di tipo SIPO per cui con solo tre linee possiamo controllare otto segnali in uscita. Un ingresso è per il clock, uno è il reset ed uno è l'ingresso dati.

Codice:

Altro

Traduttori BCD

Abbiamo già visto come integrare il circuito integrato SN7447 (o SN74LS47) usato come driver di pilotaggio per display a sette segmenti.
Funzionalità chiave e caratteristiche:

BCD Input: Accepts 4-bit BCD data (e.g., 0011 for '3') on pins A, B, C, D.
7-Segment Output: Provides individual outputs (a, b, c, d, e, f, g) to control segments on a display.
Lamp Test (LT): A dedicated pin to test all segments simultaneously.
Blanking/Ripple Blanking: Includes pins (RB, BI/RBO) for suppressing leading zeros and blanking the display.
Open-Collector Outputs: Can drive common-anode 7-segment displays and handle higher voltages (up to 15V) for brighter LEDs.
Power: Operates on a 5V power supply (TTL logic family).

In parole povere:
It's the "translator" chip that takes digital numbers from a computer or microcontroller (in BCD format) and turns them into the specific "on/off" patterns required to draw that number on a 7-segment LED display.

Adattatori

Per I2C

Link interno: Adattatore I2C ese con Display

(Mappa e Link)

Integrazioni tipiche | Arduino indice | Arduino | Arduino Progetti | Arduino C++

C++ Info fondamentali | Dizionario Elettronica | Dizionario

Parole chiave:

Navigation

Help

Tools

WIDGETS

Widgets

Recent changes

Wanted articles

Who is online?

Article tools

Domotica Arduino Integrazioni dispositivi generici

From Aino Wiki

Contents

Pulsanti

Pull up senza resistore

Pulsante su linea analogica

Sketch

Debouncing

LED

LED RGB

Sketch

LED RGB con potenziometro

Sketch

Display

Relay

Servomotore

Circuiti integrati digitali

Registri a scorrimento

74HC164

Altro

Traduttori BCD

Adattatori

Per I2C

(Mappa e Link)