Tecnica
Centralina Aggiuntiva Economica
Scritto da claudio464646 - Pubblicato 15/07/2021 15:52
Tra i desideri di ogni motociclista , forse il più agognato è quello di riuscire ad dare un po' piu di sprint alla propria moto...

Ma come fare? Abbandonata l'idea di acquistare una moto più potente... le possibilità di adottare prodotti aftermarket è infinita.

Si parte dalla sostituzione dello scarico originale, con l'adozione di un filtro aria sportivo, all'aggiunta di centraline , sino ad arrivare alla rimappatura della centralina elettronica (ECU) originale.
Tutto vero, ma dopo tutte queste modifiche, alla prova dinamometrica, il guadagno di potenza effetivo non è proprio esaltante.
Ci si accorge, purtroppo tardi, che per spremere qualche cavallo in più, il prezzo pagato è molto salato.
Conclusione: non c'è alcuna possibilità senza aprire un mutuo presso la propria banca. O forse sì!

L'idea, non mia, è quella di utlizzare al meglio le risorse che la nostra moto ci mette a disposizione.
Come molti conoscono il cervello delle attuali moto è le centralina elettronica, quella scatola magica che nel bene e nel male controlla tutta le funzioni della moto.
Ebbene il problema da risolvere è proprio questo.
Le attuali disposizioni antinquinamento costringono i produttori a limitare elettronicamente la potenza effettiva che il motore potrebbe erogare.
In termini pratici il motore viene costretto a funzionare con un rapporto stechiometrico aria/benzina intorno al valore 14,7 (1 parte di di benzina e 14,7 parti di aria) mentre dal punto di vista strettamente tecnico tale valore dovrebbe essere di 13,5.
Quindi occorre individuare una soluzione per riportare tale valore stechiometrico nel range di miglior fuzionamento.

Senza volerci dilungare in approfondite considerazioni tecniche che potrete tranquillamente trovare in rete, possiamo sintetizzare il concetto tenendo presente che le centraline elettroniche, facendo uso di svariati sensori presenti sulla moto, altro non fanno che determinare la quantità di benzina esatta da immettere nei corpi farfallati attraverso gli iniettori tale da rispettare comunque le limitazioni imposte dal rapporto stechiometrico di 14,7.
La soluzione cercata sarà pertanto quella che farà in modo di far aumentare la quantità di benzina iniettata.

Concentreremo la nostra attenzione su due sensori in particolare; la sonda lambda ed il sensore di temperatura aria IAT.
Il primo interviene nei regimi stazionari del motore (al minimo, a gas costante) mentre il secondo durante i transitori (accelerazioni).
Proprio per le loro caratteristiche di comportamento si autoescludono (lo fa la centralina ECU) vicendevolmente.

Poichè la richiesta di potenza supplementare è apprezzabile durante le fasi di accelerazione del mezzo ho focalizzato la mia attenzione sul sensore IAT.
Dobbiamo ricordare, manuale di fisicatecnica alla mano, che la densità (quantità) dell'aria aumenta con il diminuire della temperatura, ad esempio una differenza negativa di temperatura di 10 gradi
comporta un aumento di densità del 3%.
Dopo queste considerazioni, abbiamo intuito che se riuscissimo ad ingannare la nostra ECU facendogli credere che la temperatura esterna dell'aria sia inferiore a quella reale, questa, ritenendo di avere a disposizione una maggiore quantità d'aria immessa nei cilindri, per mantenere il rapporto stechiometrico nei valori fissati dove necessariamente immettere una maggior quantità di benzina.
Quindi nella condizione reali ci troverremmo ad avere un maggior quantitativo di benzina in rapporto alla quantità d'aria aspirata e pertanto il nostro rapporto stechiometrico si avvicinerà al valore cercato di 13,5.

Dopo questa tediosa spiegazione vediamo nella pratica come raggiungere questo risultato.
Occorre sapere che il sensore IAT altro non è che un termistore ovvero un dispositivo che cambia la sua resistenza (OHM) elettrica in funzione della temperatura. Più bassa è la temperatura rilevata e maggiore sarà la sua resistenza elettrica interna.
Purtroppo tali termistori non seguono una legge lineare ma di tipo logaritmico, cioè al variare della temperatura, la diminuzione della loro resistenza elettrica non è costante.

Pertanto non potremmo semplicemente inserire in serie alla sonda IAT una semplice resistenza passiva poichè questa sara efficace solo ad una specifica temperatura.
Per ovviare a questo problema si rende indispesabile un potenziometro digitale che vari la sua resistenza in modo opportuno.
Tutte belle parole ma alla fine cosa dobbiamo fare?
Molto semplicemente occorrerà realizzare un semplice circuito elettronico (non spaventatevi trovere tutti i componenti già fatti) dotato din un microprocessore, un sensore di temperatura, un potenziometro digitale ed un alimentatore stabilizzato per veicoli.
Dimenticavo un piccolo contenitore di plastica per inserirli. (vi stupirete, sarà il componente più costoso)

Microprocessore = ARDUINO, ELEGOO o simili
Sensore temperatura = DHT22 AM2302 sensore di temperatura
Potenziometro digitale = X9C103S Potenziometro Digitale
Alimentatore = Convertitore DC da 5V, Convertitore Buck DC Impermeabile 8V-22V 12 V Step Down a 1V-15V 6V 9V

Con un po' di pazienza e con l'incredibile cifra di 50 Euro otterrete il seguente risultato (vedi foto)



Non pensate di aver trasformato la vostra moto in un bolide da gp ma otterrete:
  • una maggior prontezza di risposta all'acceleratore
  • una diminuzione delll'effetto ON-OFF all'apertura e chiusura dell'acceleratore
  • un'erogazione più corposa a tutti i regimi
  • qualora aveste montato uno scarico aperto o un filtro aria più permeabile recuperereste un po' lo smagrimento ai bassi regimi

Per quanto riguarda i consumi questi rimangono pressochè simili (ciò che incide è quanta manetta date....)

Note conclusive
Vi ricordo che tale modifica inficia l'omologazione del mezzo.
La modifica è completamente reversibile e cosa da non sottovalutare, il dispositivo è adattabile a qualsiasi moto (il programma è frree come il software necessario)

Qualora foste interessati non esitate a contattarmi, sarò ben lieto di fornivi sia gli schemi elettrici che il programma da caricare sul microprocessore.

Il progetto realizzato è stato aggiornato con qualche piccola modifica (Led visualizzazine temperatura, relè di inibizione e temporizzazione attivazione dispositivo dall'accensione del motore) ma la sostanza è quella precedentemente descritta.
 

Commenti degli Utenti (totali: 8)
Login/Crea Account



I commenti sono di proprietà dell'inserzionista. Noi non siamo responsabili per il loro contenuto.

Commenti NON Abilitati per gli utenti non registrati
Commento di: Muwenge il 15-07-2021 17:48
Complimenti per il progetto e la realizzazione. Up
Eventualmente bisognerebbe considerare anche il tipo di moto. Se poi c'e' la sonda lambda allora il funzionamento e' a circuito chiuso con un sistema retroazionato. Viceversa a pieno carico o a freddo si utilizza la mappa statica con le correzzioni dei sensori. Spippolando la mappa si riesce a variare l'arricchimento e l'anticipo al difuori della zona sonda. Penso che la modifica rende secondo il tipo di iniezione.
Commento di: claudio464646 il 15-07-2021 19:41
Grazie per l'apprezzamento.
Tuttavia, come indicato nell'articolo la centralina elettronica controlla la sonda lambda solo durante i regimi stazionari non durante le accelerazioni.
Ovviamente come hai correttamente sottolineato, la modifica del rapporto stechiometrico ingannando la sonda IAT non potrà essere maggire delle tabelle statiche della centralina ma operando in un range di temperatura fasullo, il rapporto stechiometrico si avvicinerà di molto al valore consono di 13,5.
La modifica non interviene sul modo di iniettare il carburante ma solo sui temoi di iniezione. La centralina inoltre correggerà automaticamente l'anticipo di accensione.
Poichè ogni moto ha una sonda IAT con caratteristiche diverse, occorrerà modificare la funzione scritta nel programma per addattare i valori di resistenza OHM.
Io ho lavorato con la sonda della Kawasaki POT 0110 e POT 0112 che equipaggiamo quasi completamente la gamma in produzione.
I dati relativi alle varie sonde possono essere reperiti nei manuali di officina.

Cordiali Saluti
Commento di: TommyTheBiker il 15-07-2021 23:50
Quando si parla di "centraline" non programmabili con le manopoline (non cito i prodotti specifici ma immagino tutti sappiano a quali mi riferisco), io dico sempre: <i>guarda che stai buttando 150€, dentro quello scatolotto c'è un potenziometro e una resistenza variabile che inganna l'IATP, con due soldi te la fai in casa ed è la stessa cosa.</i>

Tu hai fatto la versione migliorata, spendendo comunque molto meno del prodotto commerciale Smile

Ottimo lavoro! Up
Commento di: TheBoss01 il 16-07-2021 21:44
Ciao, una domanda. Poichè sei molto dentro l'argomento, immagino che sicuramente ricercando in rete tu sia incappato nella IAT di belinassu. Dato che comunque c'è un pò di lavoro da fare per realizzare l'oggeto e i costi più o meno si equivalgono, qual è il vantaggio di questa soluzione rispetto a quella ? (oltre ovviamente al gusto di realizzare e far funzionare una cosa da soli e alla riconfigurabilità)

Vedo una criticità, ma magari mi sbaglio. Ma l'arduino come è messo come resistenza alle vibrazioni ? Non vorrei che sul lungo periodo si rompesse...

In ogni caso, complimenti per il lavoro :)
Commento di: claudio464646 il 20-07-2021 22:42
Per quanto riguarda le vibrazioni non ho ancora un riscontro oggettivo. Tuttavia l'elettronica Arduino , secondo i forum, è molto affidabile. Unica interferenza potrebbe agire sui tempi di clock , ma dato che la precisione in termini temporali non è così necessaria, il ciclo di controllo e di 2 secondi, non vedo grossi problemi.
Comunque, sia per evitare vibrazioni che per isolare meglio i componenti, questi sono montati su un cuscinetto di gel siliconico.
Per quanto riguarda la Smart Iat di Belinassu, non posso esprimere un commento defininitivo visto che non ho avuto modo di verificarne la componentistica. Da quanto posso intendere è stata aggiunta una resistenza passiva in serie alla sonda ntc. Non so se è anche stata cambiate la sonda stessa con una con una curva logaritmica più dolce (fattore Beta) ma a mio modesto avviso, la modifica effettuata può agire in un range di temperatura limitato e con la scelta di valori di resistenza medi (OHM). Comunque non volendo assolutamente sminuire il lavoro fatto da Belinassu, per correttezza ideologica andrebbe provata sul campo.
La differenza sostanziale tra i due progetti consiste nel fatto che utilizzando un potenziometro digitale è possibile adeguare la resistenza all'effettiva temperatura e quindi correggere la curva logaritmica perfettamente in ogni condizione. Inoltre essendo programmabile tale variazione può essere modificata in ogni momento per accentuare o diminuire la temperatura da ingannare ed infine tale soluzione è compatibile con qualsisi tipo di moto.


Commento di: claudio464646 il 07-08-2021 09:07
Sensore Digitale DHT22


Gestione Led


Potenziometro foto non serve
Potenziometro Digitale da 10Kohm con X9C103S


Le connessioni A0 , 5 V e GND non vanno collegate (servono solo per vedere valori sulla seriale)

GND e A0 vanno collegate alla sonda IAT in serie.


E’ stato aggiunto anche un Relè che attiva sistema solo dopo tempo programmato.
Quando relè è spento bypasso ingresso GND – A0


Bottone Led Programmazione





Buzzer



Relè


ASSEMBLARE IL TUTTO … buon lavoro ……


Sketch


/*
Regolatore sonda NTC
*/



#include <EEPROM.h>

#include <DigiPotX9Cxxx.h>

#include <DHT.h>
#include <DHT_U.h>

#define dataPin 7 //pin sensore temperatura
#define DHTType DHT22

DHT dht = DHT(dataPin, DHTType);

//pin potenziometro
DigiPot pot(2,3,4);


int poscur = 0 ;

int countdelay = 0 ;

int attivadelay = 1 ;
int enddelaymin = 8 ; // max 8 minuti regolato da valore EEPROM

int mintemp = 0 ;

int totdelay = 5000 ; // delay ciclo loop

int errtemp = 0 ;

int itempset = 0 ;

//Connesso al Pin DS del 74HC595 integrato shift register
int dataPin1 = 8;

//Connesso al Pin ST_CP del 74HC595
int latchPin = 9;

//Connesso al Pin SH_CP del 74HC595
int clockPin = 10;


byte leds = 0;
byte ledstemp = 0;
byte ledstot = 0;


int tDelay = 250;
byte ledstempset = 0;
byte ledstotset = 0;


int RELE = 12;

int LED = 5; // LED collegato al pin digitale 5
int BUTTON = 6; // pin 6 di input dove è collegato il pulsante
int val = 0; // si userà val per conservare lo stato del pin di input

int stato = 0; // ricorda lo stato in cui si trova il led, "stato = 0" led spento
// "stato = 1" led acceso
int conta = 0;

int conta1 = 0;

int conta2 = 0;



int setattivo = 0;

int setled = -1;

int setledtot = -1;

byte storedled = 0;



void updateShiftRegister(){
digitalWrite(latchPin, LOW); // durante la trasmissione il latchPin deve essere collegato a
//massa e mantenuto a livello basso
shiftOut(dataPin1, clockPin, MSBFIRST, leds);
digitalWrite(latchPin, HIGH); //riporta il pin del latch al segnale alto in quanto non è
// più necessario attendere informazioni
}


void CicloLed(){

ResetLed();

for (int i = 0; i<8; i++){
Accendi1Led(i);
delay(50);
leds = 0;
}

for (int i = 6; i>0; i--){
Accendi1Led(i);
delay(50);
leds = 0;
}

ResetLed();

}

void ResetLed(){
leds = 0;
updateShiftRegister();
}

void Accendi1Led(int quale){
leds = 0;
updateShiftRegister();
bitSet(leds, quale);
updateShiftRegister();
}


void LedTemp(int Temp){

if( Temp < 5){
ResetLed();
Accendi1Led(0);
leds = 0;
}

if( Temp >= 5 && Temp < 10){
ResetLed();
Accendi1Led(1);
leds = 0;
}

if( Temp >= 10 && Temp < 15){
ResetLed();
Accendi1Led(2);
leds = 0;
}

if( Temp >= 15 && Temp < 20){
ResetLed();
Accendi1Led(3);
leds = 0;
}

if( Temp >= 20 && Temp < 25){
ResetLed();
Accendi1Led(4);
leds = 0;
}

if( Temp >= 25 && Temp < 30){
ResetLed();
Accendi1Led(5);
leds = 0;
}

if( Temp >= 30 && Temp < 35){
ResetLed();
Accendi1Led(6);
leds = 0;
}

if( Temp >= 35){
ResetLed();
Accendi1Led(7);
leds = 0;
}

}



void setup() {

pinMode(RELE, OUTPUT);
digitalWrite(RELE,LOW);

pinMode(LED, OUTPUT); // imposta il pin digitale come output
pinMode(BUTTON, INPUT); // imposta il pin digitale come input

setled=EEPROM.read(0);

for(int i=0; i <= setled; i++){
bitSet(storedled , i);
}

enddelaymin= setled + 1;

// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
// put your setup code here, to run once:
Serial.begin(9600);
dht.begin();

Serial.println("Setup");
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
countdelay = 0 ;
mintemp = 0 ;
totdelay = 5000 ;
errtemp = 0 ;

pinMode(dataPin1, OUTPUT);
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);

pot.reset();


for (int j = 0; j<5; j++){

CicloLed();
}

pot.set(0);


for (int j = 0; j<5; j++){

CicloLed();
}

pinMode(11,OUTPUT); //buzzer


Serial.println(analogRead(A0));

Serial.println("Fine Setup");
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW

digitalWrite(11,HIGH);
tone(11,3000);
delay(500);

digitalWrite(11,LOW);
noTone(11);
delay(500);

}





void loop() {




val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva

if(setattivo == 0){

if (val == HIGH) { // controlla che l'input sia HIGH (pulsante premuto)
conta = conta + 1 ;
if(conta == 2){

stato = 1 - stato;
//stato = 1 ;

conta = 0 ;

}

//digitalWrite(LED, HIGH); // accende il led
}
else {

leds = 0;
updateShiftRegister();


if (errtemp == 0){
LedTemp(itempset);
} else {
errtemp = 0;



}

}

}


if (stato == 1) {
digitalWrite(LED, HIGH); // accende il led
setattivo=1;



leds = storedled;
updateShiftRegister();

val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva

if (val == LOW) {
conta1 = conta1 + 1 ;
if(conta1 == 15){

stato = 1 - stato;
setattivo = 0;

if(setledtot > 0){

EEPROM.update(0, setledtot);
delay(50) ;
setled=EEPROM.read(0);
delay(50) ;

for(int i=0; i <= setled; i++){
bitSet(storedled , i);
}
enddelaymin= setled + 1;


setledtot = -1;

}


return;

}

}
else {

conta2 = conta2 + 1 ;
if(conta2 == 2){
for (int i=0; i < 2 ;i++){

digitalWrite(LED, LOW); // spegne il led
delay(100);
digitalWrite(LED, HIGH); // accende il led
delay(100);
}

conta2 = 0;
conta1 = 0;

setled = setled + 1;
if(setled == 8){
leds = 0;
storedled = 0;
updateShiftRegister();
setled = 0;
}

setledtot = setled;

bitSet(storedled , setled);
leds = storedled;
updateShiftRegister();


}
else {

}
}

}
else {


if (val == LOW) {

if (conta1 > 0){

for (int i=0; i < 5; i++){
digitalWrite(LED, LOW); //spegne il led
delay(100);
digitalWrite(LED, HIGH); // accende il led
delay(100);
}

digitalWrite(LED, LOW); //spegne il led

conta1 = 0;

setattivo = 0;
}


}
else {

}
}


if(setattivo == 1){
delay(1000);

return;
}


if(setattivo == 0){


if(attivadelay == 1){


digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(250); // wait for a second

leds = 0;
ledstemp = 0;
ledstot = 0;
updateShiftRegister();

for (int j = 0; j < enddelaymin; j++){

//mettere 29
for (int z = 0; z < 29; z++){

for (int i = j; i < 8; i++){

if(i - j == 0){

for (int t = j; t > 0; t--){

leds = ledstemp ;
updateShiftRegister();
delay(tDelay);
}

}

bitSet(ledstot , i);

leds = ledstemp + ledstot ;
updateShiftRegister();
delay(tDelay);

ledstot = 0;
}
}

bitSet(ledstemp, j);

}

leds = ledstemp;
updateShiftRegister();
delay(tDelay);

attivadelay=0 ;


for (int i=0; i < 3; i++){
digitalWrite(11,HIGH);
tone(11,3000);
delay(500);

digitalWrite(11,LOW);
noTone(11);
delay(250);
}
}


digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second


float h = dht.readHumidity();

float t = dht.readTemperature();

if (isnan(h) || isnan(t)) {
Serial.println("Impossibile leggere i dati del sensore DHT.");
Serial.println("Controllare il cablaggio.");

errtemp = 1;

digitalWrite(RELE,LOW);

if(errtemp == 1){

t = 0 ;
int itemp = t;
Serial.print(itemp);

itempset= itemp ;

leds=0;
updateShiftRegister();

byte err2 = 0;
for( int i = 0; i < 8; i++){

bitSet(err2, i);
}

pot.set(0);

for (int i=0; i < 10; i++){

leds = err2;
updateShiftRegister();

digitalWrite(11,HIGH);
tone(11,3000);
delay(500);

leds = 0;
updateShiftRegister();

digitalWrite(11,LOW);
noTone(11);
delay(250);
}


}

for (int i=0; i<3; i++) {

digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(250);
}

delay(1000);

for (int i=0; i<5; i++) {

digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(250);
}

delay(totdelay);
return;
}

Serial.print("Humidity: ");
Serial.print(h);
//Stampa la temperatura
Serial.print(" %, Temp: ");
Serial.print(t);
Serial.print(" Celsius ");

//Stampa una nuova linea
Serial.println();

int itemp = t;
Serial.print(itemp);

itempset= itemp ;


//Stampa una nuova linea
Serial.println();


if(itemp <= mintemp){
Serial.println("Rggiunta temperatura minima");
delay(totdelay);
return;
}


float espo = -0.196 * ((itemp / 5.00) + 3.00);

Serial.print(espo);

//Stampa una nuova linea
Serial.println();

//I valori 5422.9 e -0.196 fanno riferimento alla sonda ntc della Z650 ma vanno bene per tutta la gamma Kawasaki
// Sonda Kawasaki POT 0110 e POT 0112
// con tali valori simulo una temperatura esterna di – 10 C°
int res = 5422.9 * exp( -0.196 * ((itemp / 5.00) + 3.00));

Serial.print(res);

//Stampa una nuova linea
Serial.println();


int modres = res % 100 ;

Serial.print(modres);

//Stampa una nuova linea
Serial.println();

int intres = (res - modres) / 100 ;

Serial.print(intres);

//Stampa una nuova linea
Serial.println();

int aggres = 0 ;

if(modres > 50){
aggres = 1 ;
}

Serial.print(aggres);

//Stampa una nuova linea
Serial.println();

int poscurtemp = intres + aggres ;

if(poscurtemp != poscur){

LedTemp(itemp);

poscur = poscurtemp ;
Serial.println("aggiorno valori") ;

Serial.println(poscur);

pot.set(poscur);
delay(500);
Serial.println(pot.get());
delay(10);
Serial.println(analogRead(A0));
delay(10);
Serial.println("fine aggiorno valori") ;

if(digitalRead(RELE) == LOW){
digitalWrite(RELE,HIGH);

}

}
else{
Serial.println("non faccio nulla") ;
delay(500);
Serial.println(pot.get());
delay(10);
Serial.println(analogRead(A0));
delay(10);
Serial.println("fine non faccio nulla") ;

if(digitalRead(RELE) == LOW){
digitalWrite(RELE,HIGH);

}

}


for (int i=0; i<3; i++) {

digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(250); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(250);
}

delay(totdelay);


}


}



NOTA

Per programmare tempo prima attivazione (accensione relè,, premo bottone sino a che led programmazione non si accende, poi premendo ulteriormente (premo e rilascio bottone) aumento minuti arrivati a 8 contatore riparte da 1)


Commento di: Allrossx il 08-09-2021 12:33
Ciao, ti ringrazio per aver condiviso il tuo lavoro. Non riesco a capire, però, concettualmente di quanto viene abbassata la temperatura percepita.
Secondo me sarebbe interessante scrivere accanto alla lista dei componenti, anche il loro rispettivo prezzo
Commento di: claudio464646 il 08-09-2021 13:10
La temperetura reale viene ridotta di 10 Gradi C° . Modificabdo curva logaritmica puoi incrementare tale riduzione. In poche parole aumenti resistenza potenziometro digitale.

Link utili
https://www.amazon.it/Elegoo-ATmega328P-ATMEGA16U2-Compatibile-Microcontrollore/dp/B01MRJR8UF/ref=asc_df_B01MRJR8UF/?tag=googshopit-21&linkCode=df0&hvadid=85509549383&hvpos=&hvnetw=g&hvrand=12654540013849236680&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=1008466&hvtargid=pla-349310030384&psc=1

https://www.amazon.it/gp/aw/d/B08S376RHL/ref=sspa_mw_detail_6?ie=UTF8&psc=1&pd_rd_i=B08S376RHLp13NParams <https://www.amazon.it/gp/aw/d/B08S376RHL/ref=sspa_mw_detail_6?ie=UTF8&psc=1&pd_rd_i=B08S376RHLp13NParams>

https://www.amazon.it/ARCELI-KY-019-Channel-Module-arduino/dp/B07BVXT1ZK/ref=sr_1_5?__mk_it_IT=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=13AC31ALPJP7W&dchild=1&keywords=rele+arduino&qid=1624607271&sprefix=rele%27%2Cdiy%2C195&sr=8-5

https://www.amazon.it/ARCELI-X9C103S-Potenziometro-Digitale-Arduino/dp/B07RHMMLPK/ref=sr_1_2?__mk_it_IT=ÅMÅŽÕÑ&crid=1NBDAZPGJHTBG&dchild=1&keywords=arduino+potenziometro+digitale&qid=1629181541&sprefix=arduino+potenziometro%2Caps%2C170&sr=8-2

https://www.amazon.it/dp/B078SVZB1X/ref=syn_sd_onsite_desktop_173?psc=1&uh_it=01e99fb8afecec8d570b20c326f686e8_CT&spLa=ZW5jcnlwdGVkUXVhbGlmaWVyPUExVFJBUzQwMTE1MVlPJmVuY3J5cHRlZElkPUEwNTc3NDY3MjJXQTA0NlRKV1NFJmVuY3J5cHRlZEFkSWQ9QTA0NDM3NTMyOEZKVjRJSDhZMVZBJndpZGdldE5hbWU9c2Rfb25zaXRlX2Rlc2t0b3AmYWN0aW9uPWNsaWNrUmVkaXJlY3QmZG9Ob3RMb2dDbGljaz10cnVl

https://www.amazon.it/dp/B06XSFF7MG/ref=sspa_dk_detail_1?psc=1&pd_rd_i=B06XSFF7MG&pd_rd_w=UERtr&pf_rd_p=5a37baa9-c5e8-4b8a-b2de-e8ac6761d9d5&pd_rd_wg=nYJq5&pf_rd_r=7Q2XJFVBRZERV4BKER2M&pd_rd_r=a0d53261-d820-4023-a491-d240ac3ad4bf&spLa=ZW5jcnlwdGVkUXVhbGlmaWVyPUEyNE5LWDVMWDk2T01SJmVuY3J5cHRlZElkPUEwMDQzOTEyMlBVTzNHNlY5WFpLViZlbmNyeXB0ZWRBZElkPUEwODcxNzExTzQ5VTFENVdYVFBYJndpZGdldE5hbWU9c3BfZGV0YWlsJmFjdGlvbj1jbGlja1JlZGlyZWN0JmRvTm90TG9nQ2xpY2s9dHJ1ZQ==