View source for Domotica Arduino Integrazioni dispositivi generici

=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).
[[File:Arduino_Pulsanti_PullDown_e_Up_01.jpg|none|801x281px]]
'''Pulsanti in ''pull down'''''<br />
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'''
[[File:Arduino_Pulsante_PullDown_01.jpg|none|401x348px]]
'''Pulsanti in ''pull Up'''''<br />
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.
[[File:Pulsante_PullUp_02.jpg|none|500x317px]]

==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 "<code>INPUT_PULLUP</code>", 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 <span style="text-decoration: underline;">un solo pin analogico su cui impostare '''n pulsanti'''</span>, 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. <br />
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.<br />
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.
[[File:Serie_di_pulsanti_su_pin_analogico_02.jpg|none|372x551px]]
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==
<syntaxhighlight lang="csharp">
#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");
  }
}
</syntaxhighlight>
Dalla doc Arduino [https://docs.arduino.cc/language-reference/en/functions/analog-io/analogRead/ 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 <code>delay()</code> perché costosi in termini di risorse, al loro posto si usa <code>millis()</code>.
<syntaxhighlight lang="csharp">
#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
    }
  }
}
</syntaxhighlight>

=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 [https://wiki.aino.it/index.php?title=Elettronica_Appunti#LED LED])<br />Hanno due terminali, <span style="color: #ff0000;">'''+''' ''anodo''</span>, <span style="color: #000080;">'''-''' ''catodo''</span>. Il ''catodo'' è la gamba <span style="text-decoration: underline;">più corta</span> e sotto la 'cupola' termina come una specie di mazza da golf.

{| class="wikitable"
|-
!|Colore
!|Tensione (volt);
!|Resistenza consigliata (*)<br />
 ''Alimentazione=5V - Corrente <span style="color: #008000;">12mA</span>''
!|
Resistenza per corrente a <span style="color: #99cc00;">6mA</span>

Arduino <span style="color: #ff00ff;">Uno R4</span>

|-
||<span style="color: #ff0000;">'''Rosso'''</span>
||'''1,8 V'''.
||266Ω  ~'''270Ω'''
||533Ω ''' ~560Ω'''
|-
||<span style="color: #ffcc00;">'''Giallo'''</span>
||'''1,9 V'''.
||~'''260Ω'''
||'''Ω'''
|-
||<span style="color: #339966;">'''Verde'''</span>
||'''2,0 V'''.
||'''250Ω'''
||500Ω '''<strong>~470Ω'''</strong>
|-
||<span style="color: #0000ff;">'''Blu'''</span>
||'''3,5 V'''.
||'''125Ω'''
||250Ω '''<strong>~220Ω'''</strong>
|-
||<span style="color: #808080;">'''Bianco'''</span>
||'''3,0 V'''.
||~'''170Ω'''
||'''Ω'''
|-
||'''''Infrarosso'''''
||'''1,3 V'''.
||~'''310Ω'''
||'''Ω'''
|}
'''(*)''' '''TEORIA''' Si applicano il '''''[https://it.wikipedia.org/wiki/Leggi_di_Kirchhoff Secondo teorema di Kirchhoff]''''' ((o ''Legge delle Maglie'')) e la '''''Legge di Ohm'''''. <span style="color: #ff0000;">'''ATTENZIONE'''</span> Tra una versione di Arduino ed un altra <span style="text-decoration: underline;">la corrente può cambiare!</span><br />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 <span style="color: #008000;">'''Verde'''</span>, nel ns caso (ipotesi: tensione <span style="color: #008000;">'''5V'''</span> e corrente <span style="color: #008000;">'''12mA'''</span> ovvero 0.012A):

<code><span style="color: #800080;">'''V'''<sub>''Arduino''</sub> - '''V'''<sub>''resistenza''</sub> - '''V'''<sub>''led'' </sub>= 0</span></code><br />Applicando la Ohm per cui: <code><span style="color: #800080;">V=R*i</span></code><br />
<code><span style="color: #800080;">5'''V''' - '''V'''<sub>''led'' </sub>= '''V'''<sub>''resistenza''</sub></span></code>    ovvero    <code><span style="color: #800080;">5'''V'''-2'''V''' = '''V'''<sub>''resistenza''</sub></span></code>    ovvero    <code><span style="color: #800080;">5'''V'''-2'''V''' = R * i </span></code>  ovvero    <code><span style="color: #800080;">3'''V''' = R * 12'''mA''' </span></code>  ovvero    <code><span style="color: #800080;">'''R '''= 3'''V''' / 0,012'''A''' = 250'''Ω'''</span></code>

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.
[[File:Led_alternati_01.jpg|none|381x600px]]

==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''".[[File:LED_RGB_01.jpeg|none|400x321px]]La regolazione della '''luminosità''' dei 3 led si fa usando la funzionalità, <code>analogWrite()</code>, 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 <span style="color: #ff0000;">rosso</span>, R. Calcoli: (5V - 1.8V) * 0.006A = 3.2V * 0.006A = ''533Ω''
* '''470'''Ω per il led <span style="color: #339966;">verde</span>, G. Calcoli: (5V - 2V) * 0.006A = 3V * 0.006A = ''500Ω''
* '''220'''Ω per il led <span style="color: #0000ff;">blu</span>, B. Calcoli: (5V - 3.5V) * 0.006A = 1.5V * 0.006A = ''250Ω''

[[File:Led_RGB_02.jpg|none|369x550px]]
==Sketch==
<syntaxhighlight lang="csharp">
#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);
}
</syntaxhighlight>

<div id="gtx-trans" style="position: absolute; left: 808px; top: 190.219px;"><div class="gtx-trans-icon"></div>
</div>

==LED RGB con potenziometro==
Con la versione seguente si regola la '''luminosità''' usando dei potenziometri\trimmer
[[File:Led_RGB_con_potenziometro_Prj_00.jpg|none|540x650px]]
==Sketch==
<syntaxhighlight lang="csharp">
#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);
}
</syntaxhighlight>
[[File:Led_RGB_con_potenziometro_prj01.jpeg|none|600]]

=Display=
I displositivi generici son stati spostati al link interno: [[Domotica Arduino Integr disp generici Display | 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.<br />
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 [https://fritzing.org/ Fritzing]:
[[File:Relay_con_Arduino_01_progetto.jpg|none|500x695px]]
Saldatore, millefori e tanta pazienza ed esce fuori questo:
[[File:Relay_progetto_01_fronte.jpeg|none|450x278px]]
L'orrendo retro:
[[File:Relay_progetto_01_retro.jpeg|none|451x276px]]
E ad 1.5€ si trova comodamente questo ma senz'anima:
[[File:Relay_gia_pronto_01.jpeg|none|300x200px]]
<syntaxhighlight lang="csharp">
</syntaxhighlight>

=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 [https://www.youtube.com/watch?v=pDeTyFnBG2M qui]<br />[[File:Servomotore_SG90-Pin-Definition_01.jpg|left|351x232px]][[File:Servomotore_schema_01.jpg|right|300x174px]]

















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''' ([https://it.wikipedia.org/wiki/Chilogrammetro 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.<br />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.<br />
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.
[[File:Servo_Pulse_Control_02.jpg|none|500x337px]]
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°).<br />
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.<br />
'''Integrazione con Arduino'''<br />
Come si vedrà dallo sketch l'uso di librerie specifiche evita la programmazione complessa nella taratura degli impulsi e frequenza.<br />
[[File:Servo_Arduino_01.jpg|none|400x475px]]
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.<br />
NOTARE che dopo la definizione dell'angolo che dovrà assumere l'asta del servomotore si usa un <code>delay(20)</code> è un ritardo introdotto per dare il tempo al servomotore di acquisire la posizione inviatagli.
<syntaxhighlight lang="csharp">
#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
    }
}
</syntaxhighlight>

=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.<br />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 a''ggiungere 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 <span style="text-decoration: underline;">sincronizzazione del segnale di clock</span>.<br />
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'''.

<div stype="width:100%">
<div style="width: 50%; float: left;">
[[File:74HC164_o_74LS164_caratteristiche_01.png|left|400x226px]]
</div>
<div style="width: 50%; float: right;">
[[File:74HC164_o_74LS164_caratteristiche_02_schema.jpg|right|199x155px]]
</div>
<div style="width: 100%;">
Codice:
<syntaxhighlight lang="csharp">
</syntaxhighlight>
</div>
</div>

==Altro==
===Traduttori BCD===
Abbiamo già visto come integrare il circuito integrato SN7447 (o SN74LS47) usato come driver di pilotaggio per display a sette segmenti.<br />
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:<br />
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: [https://wiki.aino.it/index.php?title=Domotica_Arduino_Integr_disp_generici_Display#Adattatore_I2C Adattatore I2C ese con Display]

=(Mappa e Link)=
----
[[Domotica Device Arduino Integrazioni tipiche | Integrazioni tipiche]] | [[Domotica Device Arduino Indx | Arduino indice]] | [[Domotica Device Arduino | Arduino]] | [[Domotica Device Arduino Progetti | Arduino Progetti]] | [[Arduino C++]]
----
[[Cpp Info fondamentali | C++ Info fondamentali]] | [[Dizionario:Termini elettronica | Dizionario Elettronica]] | [[Dizionario]]
----
'''Parole chiave''':