il mio impianto si compone di 3 tracer 3210
3 pannelli da 38v 300w
1 sensore acs da 30A PER OGNI uscita di regolatore
1 sensore da 200A per la batteria
1 sensore da 200A PER uscita regolatori (somma totale uscita regolatori)
visualizzazione su blynk

volt batteria servizi
volt batteria motore
tensione dei pannelli
tensione volt arduino
2 display da 20x4
2 comandi da blynk uscite arduino
3 visualizzazioni on/off ingressi arduino

arduino mega con scheda lan

il tutto montato sul mio camperino

lo schecht non e di mia produzione ma solo frutto di copia e incolla da qualche amico o internet

il mio problema e che ho gli zero degli amperometri come le misure sono ballerini

//



/*
v15 amp bs
v14 volt bs
v13 solamp
v12 solvolt
v11 solamp2
v10 solvolt2
v9 solamp3
v8 bmvolt

v3 ,v4, v5,v6   blynk

 

TENSIONE_BS = A0;
TENSIONE_SOL = A1;
 TENSIONE_SOL2 = A2;
 TENSIONE_SOL3 = A3;
 TENSIONE_BM = A4;


pinMode(A5,INPUT);
pinMode(A6,INPUT);
pinMode(A7,INPUT);
pinMode(A8,INPUT);

AMP_BS = A15;
AMP_SOL = A14;
AMP_SOL2 = A13;
AMP_SOL3 = A12;

AMP_SOLTOT =A11;   

*/

#include <Blynk.h>



//    COMANDO    https://youtu.be/bWvOlyGAD-g

//   parte del codice  e opera di BOB

// comando uscite blynk https://youtu.be/WcFDtBe8pY4

//  https://www.youtube.com/watch?v=bWvOlyGAD-g&feature=youtu.be
//   https://youtu.be/bWvOlyGAD-g
//  https://youtu.be/YRomluFylXQ

#define BLYNK_PRINT Serial


#include <SPI.h>
#include <Ethernet.h>
#include <BlynkSimpleEthernet.h>

#include <LiquidCrystal_I2C.h>



int analogPin = 10;    
                  
float val = 0.00;         
float val2 = 0.00;


//    char auth[] = "7e29b7ec1c3625db655";  //camper mega 2 

 char auth[] = "edb29d32af5a9c7";

#define W5100_CS  10
#define SDCARD_CS 4


//blynk DISPLAY

#define bsamp  V15  // amper  BS
#define bsvolt  V14  // volt  BS

#define solamp  V13  // 
#define solvolt  V12  // 

#define solamp2  V11  // 
#define solvolt2  V10  // 

#define solamp3  V9  // 
#define solvolt3  V8  // 


#define bmvolt  V7  // 
#define solamptot  V16 // 


//  blynk



// Set the LCD address to 0x27 for a 16 chars and 2 line display



LiquidCrystal_I2C lcd(0x27, 20, 4);
LiquidCrystal_I2C lcd2(0x23, 20, 4);






//const int  TENSIONE_BS = A14;


const int  AMP_BS = A15;           



const int  AMP_SOL = A14;
const int  AMP_SOL2 = A13;
const int  AMP_SOL3 = A12;
const int  AMP_SOLTOT = A11;


//const int  TENSIONE_BS = adc0;
const int  TENSIONE_BS = A0;
const int  TENSIONE_SOL = A1;
const int  TENSIONE_SOL2 = A2;
const int  TENSIONE_SOL3 = A3;
const int  TENSIONE_BM = A4;




double tensioneBS = 0; // valore dove leggerò tensione BS

double tensioneSOL = 0; // valore dove leggerò tensione BS
double tensioneSOL2 = 0; // valore dove leggerò tensione BS
double tensioneSOL3 = 0; // valore dove leggerò tensione BS
double tensioneBM = 0; // valore dove leggerò tensione BM

//CORRENTE
double correnteBS = 0; // valore dove leggerò corrente BS

double correnteSOL = 0; // valore dove leggerò corrente BS

double correnteSOL2 = 0; // valore dove leggerò corrente BS
double correnteSOL3 = 0; // valore dove leggerò corrente BS

double correnteSOLTOT = 0; // valore dove leggerò corrente BS


// CORRENTE


const double R1 = 10000.0;
const double R2 = 1265.0; // EFFETTUARE TARATURA
// se hai multimetro di precisione, puoi cambiare il secondo valore, io lo spostai di 7 (SETTE) ohm

const double partitoreTensione = (R1 + R2) / R2;


const double R3 = 10000.0;
const double R4 = 1265.0; // EFFETTUARE TARATURA
// se hai multimetro di precisione, puoi cambiare il secondo valore, io lo spostai di 7 (SETTE) ohm

const double partitoreTensionesol = (R3 + R4) / R4;

const double R5 = 10000.0;
const double R6 = 1265.0; // EFFETTUARE TARATURA
// se hai multimetro di precisione, puoi cambiare il secondo valore, io lo spostai di 7 (SETTE) ohm

const double partitoreTensionesol2 = (R5 + R6) / R6;


const double R7 = 10000.0;
const double R8 = 1265.0; // EFFETTUARE TARATURA
// se hai multimetro di precisione, puoi cambiare il secondo valore, io lo spostai di 7 (SETTE) ohm

const double partitoreTensionesol3 = (R7 + R8) / R8;


const double R9 = 10000.0;
const double R10 = 1265.0; // EFFETTUARE TARATURA
// se hai multimetro di precisione, puoi cambiare il secondo valore, io lo spostai di 7 (SETTE) ohm

const double partitoreTensionebm = (R9 + R10) / R10;

BlynkTimer timer;



void setup() {
Serial.begin(9600);   
//comando blynk

pinMode(A5,INPUT);
pinMode(A6,INPUT);
pinMode(A7,INPUT);
pinMode(A8,INPUT);


timer.setInterval(300L, leggibt);


  

pinMode(SDCARD_CS, OUTPUT);
  digitalWrite(SDCARD_CS, HIGH); // Deselect the SD card

  Blynk.begin(auth);

  

  lcd.begin();        //inizializzazione lcd 16x2
lcd2.begin();        //inizializzazione lcd 16x2



//TENSIONE
  pinMode (TENSIONE_BS, INPUT);
pinMode (TENSIONE_SOL, INPUT);
pinMode (TENSIONE_SOL2, INPUT);
pinMode (TENSIONE_SOL3, INPUT);
pinMode (TENSIONE_BM, INPUT);




//TEBNSIONE

  
  pinMode (AMP_BS, INPUT); //necessario per essere sicuro che siano pronti a leggere valori
 pinMode (AMP_SOL, INPUT); //necessario per essere sicuro che siano pronti a leggere valori
pinMode (AMP_SOL2, INPUT); //necessario per essere sicuro che siano pronti a leggere valori
pinMode (AMP_SOL3, INPUT); //necessario per essere sicuro che siano pronti a leggere valori
pinMode (AMP_SOLTOT, INPUT); 

}







  

void loop() {
val = analogRead(analogPin); //leggo il valore sul pin3
val2 = (val*5)/1023;  //lo trasformo in valore di tensione




 Serial.println(val2,4);   




Blynk.run();
timer.run();


  //  AMPEROMETRO
  double letturaTensioneInVolt;

  letturaTensioneInVolt = 5.0 / 1024 * analogRead(AMP_BS);


 double letturaTensioneInVoltsol;

  letturaTensioneInVoltsol = 5.0 / 1024 * analogRead(AMP_SOL);


 double letturaTensioneInVoltsol2;

  letturaTensioneInVoltsol2 = 5.0 / 1024 * analogRead(AMP_SOL2);

double letturaTensioneInVoltsol3;

  letturaTensioneInVoltsol3 = 5.0 / 1024 * analogRead(AMP_SOL3);



double letturaTensioneInVoltsoltot;

  letturaTensioneInVoltsoltot = 5.0 / 1024 * analogRead(AMP_SOLTOT);


  

  
  //Serial.print(analogRead(AMP_BS) );
  //Serial.print( "  " );
  //Serial.println(letturaTensioneInVolt, 2);

  //(tra parentesi, lascia perdere i float, usa i double -- se vuoi ti spiego perché, altrimenti fidati e basta :-)

  // a questo punto, applichiamo la conversione: per ACS 100 sono 20mV/A
  // quindi
  //correnteLetta = (2.5 - letturaTensioneInVolt ) * 1000 / 20;
  // moltiplico per 1000 per ottenere la lettura in millivolt, e divido per 20.
  // Dato che è 1000/20 è costante semplifico:

  double correnteLetta = (2.5000 - letturaTensioneInVolt ) * 50.0;   // bs amp
    double correnteLettasol = (2.5000 - letturaTensioneInVoltsol ) * 50.0;

double correnteLettasol2 = (2.5000 - letturaTensioneInVoltsol2 ) * 50.0;
double correnteLettasol3 = (2.5000 - letturaTensioneInVoltsol3 ) * 50.0;


double correnteLettasoltot = (2.5000  - letturaTensioneInVoltsoltot ) * 50.0;  
 
    

  //nota: scrivo 50.0 per abitudine, perché in alcune circostanze il compilatore potrebbbe fare divisione fra interi

  // adesso il problema è che quel 2.5 è lo zero dell'amperometro.
  // con adeguata precisione, potresti usare un piccolo correttivo
  // (ad esempio, da un mio schema reale leggo 2.4754)
  // nel tuo caso, ti direi di pensarci in futuro, quando avrai ADS1115 per leggere tensioni


  // altro punto: la media delle 5 letture significa che devi leggere 5 volte la corrente, soomarla e fare la media.
  //quindi
// VALORE LETTO 2,470 A -2.0A 
  double sommaTemporanea = correnteLetta;//A15   2.4599

  for (int i = 0; i < 1000; i++) { //ancora 4 letture, la prima l'ha fatta sopra
    correnteLetta = (2.4902 - letturaTensioneInVolt ) * -50.0;//2.4854 2.3054 
    letturaTensioneInVolt = 5.0 / 1024 * analogRead(AMP_BS);

    sommaTemporanea = sommaTemporanea + correnteLetta;
  }

  correnteBS = sommaTemporanea / 5.0;



double sommaTemporaneasol = correnteLettasol;//2.4879 a 1000

  for (int i = 0; i < 1500; i++) { //ancora 4 letture, la prima l'ha fatta sopra
    correnteLettasol = (2.4889 - letturaTensioneInVoltsol ) * -50.0;
    letturaTensioneInVoltsol = 5.0 / 1024 * analogRead(AMP_SOL);

    sommaTemporaneasol = sommaTemporaneasol + correnteLettasol;
  }

  correnteSOL = sommaTemporaneasol / 5.0;




double sommaTemporaneasol2 = correnteLettasol2;

  for (int i = 0; i < 1000; i++) { //ancora 4 letture, la prima l'ha fatta sopra
    correnteLettasol2 = (2.4982 - letturaTensioneInVoltsol2 ) * -50.0;//2.4854 
    letturaTensioneInVoltsol2 = 5.0 / 1024 * analogRead(AMP_SOL2);

    sommaTemporaneasol2 = sommaTemporaneasol2 + correnteLettasol2;
  }

  correnteSOL2 = sommaTemporaneasol2 / 5.0;




double sommaTemporaneasol3 = correnteLettasol3;

  for (int i = 0; i < 1000; i++) { //ancora 4 letture, la prima l'ha fatta sopra
    correnteLettasol3 = (2.4992 - letturaTensioneInVoltsol3 ) * -50.0;
    letturaTensioneInVoltsol3 = 5.0 / 1024 * analogRead(AMP_SOL3);

    sommaTemporaneasol3 = sommaTemporaneasol3 + correnteLettasol3;
  }

  correnteSOL3 = sommaTemporaneasol3 / 5.0;



double sommaTemporaneasoltot = correnteLettasoltot;//a11lettura 2487  2.4899  2.493

  for (int i = 0; i < 1000; i++) { //ancora 4 letture, la prima l'ha fatta sopra
    correnteLettasoltot = (2.4959 - letturaTensioneInVoltsoltot ) * -50.0;  //2.4854 2.4894 2.499
    letturaTensioneInVoltsoltot = 5.0 / 1024 * analogRead(AMP_SOLTOT);

    sommaTemporaneasoltot = sommaTemporaneasoltot + correnteLettasoltot;
  }

  correnteSOLTOT = sommaTemporaneasoltot / 5.0;




  



  // SECONDA PARTE

  // la lettura BS diventa
  // double tensioneCorretta = tensioneAlPartitore * partitoreTensione ;
  // quindi


  
  tensioneBS = (5.0 / 1024 * analogRead(TENSIONE_BS)) * partitoreTensione ;
 tensioneSOL = (5.0 / 1024 * analogRead(TENSIONE_SOL)) * partitoreTensionesol ;
tensioneSOL2 = (5.0 / 1024 * analogRead(TENSIONE_SOL2)) * partitoreTensionesol2 ;
tensioneSOL3 = (5.0 / 1024 * analogRead(TENSIONE_SOL3)) * partitoreTensionesol3 ;
tensioneBM = (5.0 / 1024 * analogRead(TENSIONE_BM)) * partitoreTensionebm ;


  // STAMPA LCD
  lcd.clear();                     //pulisci  lcd
  lcd.setCursor(0, 0);    //posiziona il cursore sulla prima linea del display
  lcd.print("V ");
  lcd.print (tensioneBS, 1);
  lcd.print("  BS A ");
  lcd.print(correnteBS, 1);
  


  lcd.setCursor(0, 1);    //posiziona il cursore sulla prima linea del display
  lcd.print("V ");
  lcd.print (tensioneSOL, 1);
  lcd.print("  SOL A  ");
  lcd.print(correnteSOL, 1);

   lcd.setCursor(0, 2);    //posiziona il cursore sulla prima linea del display
  lcd.print("V ");
  lcd.print (tensioneSOL2, 1);
  lcd.print("  SOL2 A ");
  lcd.print(correnteSOL2, 1);

  lcd.setCursor(0, 3);    //posiziona il cursore sulla prima linea del display
  lcd.print("V ");
  lcd.print (tensioneSOL3, 1);
  lcd.print("  SOL3 A ");
  lcd.print(correnteSOL3, 1);
//lcd.print(adc0, 1);
  
  


//  2 LCD 

lcd2.clear();                     //pulisci  lcd
  lcd2.setCursor(0, 0);    //posiziona il cursore sulla prima linea del display
  lcd2.print("V ");
  lcd2.print (tensioneBS, 1);
  lcd2.print(" A BS ");
  lcd2.print(correnteBS, 1);

                    //pulisci  lcd
  lcd2.setCursor(0, 1);    //posiziona il cursore sulla prima linea del display
 lcd2.print("V  BM ");
  lcd2.print (tensioneBM, 1);
  
  lcd2.setCursor(0, 2);    //posiziona il cursore sulla prima linea del display
 lcd2.print("A SOLTOT  "  );
  lcd2.print (correnteSOLTOT, 1);



  lcd2.setCursor(0, 3);    //posiziona il cursore sulla prima linea del display
 lcd2.print("VOLT arduino  "  );
  lcd2.print (val2,4);

  // ********************* DA BOB -- FINE INTERVENTO

  delay(200);
//delay(650);

Blynk.run();
timer.run();
}

//void leggidati()  




BLYNK_READ(bsamp)   //1 amp


{
  Blynk.virtualWrite(bsamp, correnteBS);
 
  
  }                  






      BLYNK_READ(bsvolt)   //1 amp


{
  Blynk.virtualWrite(bsvolt, tensioneBS);
 
  
  }             





  BLYNK_READ(solamp)   //1 amp


{
  Blynk.virtualWrite(solamp, correnteSOL);
 
  
  }                  


BLYNK_READ(solvolt)   //1 amp


{
  Blynk.virtualWrite(solvolt, tensioneSOL);
 
  
  }                  




//2


BLYNK_READ(solamp2)   //1 amp


{
  Blynk.virtualWrite(solamp2, correnteSOL2);
 
  
  }                  


BLYNK_READ(solvolt2)   //1 amp


{
  Blynk.virtualWrite(solvolt2, tensioneSOL2);
 
  
  }                  

BLYNK_READ(solamp3)   //1 amp


{
  Blynk.virtualWrite(solamp3, correnteSOL3);
 
  
  }                  

BLYNK_READ(solamptot)   //1 amp


{
  Blynk.virtualWrite(solamptot, correnteSOLTOT);
 
  
  }          



BLYNK_READ(solvolt3)   //1 amp


{
  Blynk.virtualWrite(solvolt3, tensioneSOL3);
 
  
  }                  

BLYNK_READ(bmvolt)   //1 amp


{
  Blynk.virtualWrite(bmvolt, tensioneBM);
 
  
  }  

void leggibt() 


{
if (digitalRead(A5)){
Blynk.virtualWrite(V5, 255);
 }  else { 
Blynk.virtualWrite(V5, 0);
 } 


if (digitalRead(A6)){
Blynk.virtualWrite(V6, 255);
 }  else { 
Blynk.virtualWrite(V6, 0);
 } 

if (digitalRead(A7)){
Blynk.virtualWrite(V4, 255);
 }  else { 
Blynk.virtualWrite(V4, 0);
 } 

if (digitalRead(A8)){
Blynk.virtualWrite(V3, 255);
 }  else { 
Blynk.virtualWrite(V3, 0);
 } 



  delay(10);
  } 

 

dico la mia cercando di aiutarti a risolvere il problema che lamenti:
- non è necessario dichiarare gli ingressi analogici nel setup();
- dove hai le variabili float/double ti conviene mettere sempre es: 123.0 oppure 0.0 (per alcune lo hai fatto per altre non lo hai fatto).

Potrebbe essere anche un problema hardware il fatto che siano ballerine le cifre tipo filtrare meglio la tensione di alimentazione con elettrolitici ecc. oppure gestirlo tramite software memorizzando la lettura e se la o le successive letture rientrano in un determinato range mantenere la lettura precedente, non so se sono stato chiaro.