tempo fa avevo preso un Arduino che e rimasto nel cassetto per molto tempo xche non ne so niente
guardando qua e la, ho trovato una semplice guida per fare un amperometro da
LINK
una cosa semplice senza display e altro, giusto per non lasciarlo nel cassetto......pero ho notato che non va molto bene, il valore a vuoto e di 0.03-0.06A e cambia di continuo
ce qualche trucco o ho sbagliato io? 

Non hai sbagliato .
I sensori ACS712 (che adoro) hanno i loro limiti e bisogna conoscerli per farli lavorare correttamente.

Partiamo dallo zero.
Quando non scorre corrente nel sensore ,la tensione in uscita sarà uguale a metà dell'alimentazione.
Questo significa che se alimentato a 5V troverai sul Vout 2.5V .

Bé è giusto ,ma bisogna tenere in considerazione delle possibili differenze .
La soluzione più semplice è far misurare ad Arduino la tensione del sensore senza carico e sfruttare tale valore come zero del sensore .
Si chiama Offset  ;) .

Quindi misurando l'offset prima delle misurazione avrai l'indicazione a 0.

Per le oscillazioni invece dipendono da tanti fattori.

Esistono due metodi per ridurli e eliminarli ,uno hardware ed uno software.
L'hardware è un semplice filtro passa basso composto da una resistenza e un condensatore.
In molui casi risolve completamente le fastidiose oscillazioni .
Una R da 22K e un condensatore da 100nF dovrebbero essere sufficienti .

Il metodo software è far eseguire al Micro diverse letture e calcolarne la media.

Vabbe' questa è la teoria ...
Appena posso ti posto un codice di esempio

Un saluto
Elettro

grazie Elettro  ;) grosso modo ho capito, anche se non so dove mettere le mani
aspetto un codice di esempio e magari una piccola schema di come e dove viene messo il filtro passa basso

Di seguito lo schema del flitro passa basso hardware che serve ad eliminare le fastidiose oscillazioni.
Con questo filtro vengono eliminate tutte le variazioni con frequenza superiore a 70hz ,più che sufficienti per mantenere un'ottima risposta del sensore come monitor di correnti continue.
Calcola che di fabbrica con i filtri interni stiamo sui 7Khz ...che sono ottimi se dobbiamo usare il sensore come protezione Spike ,ma troppi per un semplice monitor.

Oltre a questo filtro il codice eseguirà diverse letture e ne farà la media ,in maniera tale che un eventuale picco venga addolcito sul display.

Attualmente mi trovo solo con il cellulare ,quindi tenterò di buttare due righe ...


ho fatto il filtro usando una R da 20 invece che 22...altro non avevo, la cosa e molto migliorata, ora rimane fisso su 0.03A usando questo codice

[code]void setup() {
  Serial.begin(9600);
}

void loop() {
float average = 0;
for(int i = 0; i < 1000; i++) {
     average = average + (.0264 * analogRead(A0) -13.51);//for the 5A mode, 
//   average = average + (.049 * analogRead(A0) -25);// for 20A mode
// average = average + (.742 * analogRead(A0) -37.8);// for 30A mode
   delay(1);
}
Serial.print("Current :");
Serial.print(average/1000);
Serial.println("A");
}



confrontando i valori con un altro amperometro l'errore e minimo pero aumenta parecchio se aumenta la corrente

L'errore è nel modo di eliminare l'offset .
Prima di tutto hai usato la linea dedicata al tuo acs712 ?
5 ...20  ...o 30A  ;)

Puoi rimuovere quel fastidioso 0.03 aumentando il valore da -13.51 a 13.54

Il codice non è male e calcola l'integrale della corrente anche se non elabora l'offset ,ma lo puoi tarare variando i valori sottratti

Noterai sempre delle differenze con altri strumenti perché ci sono diversi metodi per misurarla, anche se dovrebbero essere molto simili.


caspita 0.00A 

pero per avvicinarmi il più possibile a un valore di lettura giusto cosa bisogna fare?

bodo81 :
caspita 0.00A 

pero per avvicinarmi il più possibile a un valore di lettura giusto cosa bisogna fare?

Correggere il fattore di conversione che nel tuo caso .0264
Nuovo fattore= vecchio fattore / valore letto Arduino * valore letto strumento

Esempio :
Poni un carico per avere il massimo assorbimento ad esempio 4 Ampere letti su un amperometro di riferimento
-Arduino invece leggerà ad esempio 3.6A

Nuovo fattore = 0.0264 / 3.6  * 4 = 0.0293

Correggi il valore e ricarichi il codice.
Successivamente noterai che avrai perso lo zero.
Per recuperarlo ti basterà leggere il valore senza carico e sottrarlo o sommarlo come hai fatto in precedenza.

Personalmente non mi piace molto come metodo di taratura ,ma per quel codice è così.

Appena posso ti posto il mio.
Implemnetiamo un pulsante che regola lo zero  ;) come i strumenti professionali

bel trucchetto  ;) funziona, ho giocato un po' e  si avvicina parecchio al valore reale
aspetto il tuo codice per approfondire e fare una cosa definitiva

  fantastico.
Effettivamente è laborioso con quel codice ,però regala esperienza.

Appena ho un secondo metto il codice  ;)

ma con
LINK andrebbe meglio?

bodo81 :
ma con
LINK andrebbe meglio?

Gran bel schema.
Hanno introdotto un filtro come il tuo per eliminare le oscillazioni e due trimmer per aumentare la sensibilità  (si riduce però  il fondo scala) e per l'offset ,consentendo di tarare lo zero senza il software .

ElettroshockNow :

Appena ho un secondo metto il codice  ;)


[smiley=vrolijk_26.gif]

....cavolo ... son proprio fuso  ...
Oggi pomeriggio rimedio  ;)

Scritto dal cell e a memoria ...domani lo provo.

Alimenti il circuito senza carico,cosi esegue la taratura automatica dello zero.
Ovviamente può essere eliminata  ;) ..,ma qui serve come esempio


[color=#ff0000]ATTENZIONE PRESENTA UN ERRORE ...

#define Pin_Corrente 0 //ingresso analogico dedicato al sensore
#define Pin_Zero 2 //ingresso per azzerare la lettura
#define Fattore_Conversione_Corrente 0.0264 //sensore ACS512-5
//#define Fattore_Conversione_Corrente 0.0488 //sensore ACS512-20
//#define Fattore_Conversione_Corrente 0.074 //sensore ACS512-30

//porre a negativo il pin per azzerare lo strumento

int OffSet;//viene memorizzato l'offset del sensore
float I_DC;

void setup() {
  pinMode(Pin_Zero, INPUT);//imposta il pin "Zero" come ingresso
  digitalWrite(Pin_Zero, HIGH);//attiva la resistenza pullup sul pin
  Serial.begin(9600);
  OffSet=analogRead(Pin_Corrente);//misura l'offset al primo avvio
  //Offset=511; //imposta il valore standard
}

void loop() {

if (digitalRead(Pin_Zero) == 0) {//se pulsante Zero premuto azzera lo strumento
OffSet=analogRead(Pin_Corrente);
}
 
unsigned long Somma_I=0;
for(int i = 0; i < 1000; i++) {
     Somma_I+=(analogRead(Pin_Corrente)- OffSet);
delay(1);
}
I_DC=(Somma_I/1000)*Fattore_Conversione_Corrente;

Serial.print("Current :");
Serial.print(I_DC);
Serial.println("A");
}


l sensore và sul pin A0.
Invece il pulsante per azzerare la lettura (sempre senza carico) và connessa al pin D2 (pulsante tra D2 e massa).

Il codice calcola il valore medio di 1000 letture con un tempo di 100mS.

grazie, dopo cena lo provo e ti dico come va  ;)

perché fa cosi?




forse sono i contati su Arduino, xche ho mosso un po' il A0 e non l'ha più fatto
mo' ci riprovo

...avrò  commesso un errore .
Domani con il computer lo controllo 😉

mi son dimenticato un abs  ....
In mattinata correggo e posto  ;)

Corretto ,ma ancora da testare

#define Pin_Corrente 0 //ingresso analogico dedicato al sensore
#define Pin_Zero 2 //ingresso per azzerare la lettura
#define Fattore_Conversione_Corrente 0.0264 //sensore ACS512-5
//#define Fattore_Conversione_Corrente 0.0488 //sensore ACS512-20
//#define Fattore_Conversione_Corrente 0.074 //sensore ACS512-30

//porre a negativo il pin "Pin_Zero" per azzerare lo strumento

int OffSet;//viene memorizzato l'offset del sensore
float I_DC;

void setup() {
  pinMode(Pin_Zero, INPUT);//imposta il pin "Zero" come ingresso
  digitalWrite(Pin_Zero, HIGH);//attiva la resistenza pullup sul pin
  Serial.begin(9600);
  OffSet=analogRead(Pin_Corrente);//misura l'offset al primo avvio
  //OffSet=511; //imposta il valore standard
}

void loop() {

if (digitalRead(Pin_Zero) == 0) {//se pulsante Zero premuto azzera lo strumento
OffSet=analogRead(Pin_Corrente);
}
 
unsigned long Somma_I=0;
for(int i = 0; i < 1000; i++) {
     Somma_I+=abs(analogRead(Pin_Corrente)-OffSet);
}
I_DC=(Somma_I/1000)*Fattore_Conversione_Corrente;

Serial.print("Current :");
Serial.print(I_DC);
Serial.println("A");
}


quasi quasi andava meglio il primo, era molto più preciso come lettura e il scorrimento della lettura era più lenta, questo corre come un pazzo   

La velocità la imposti te (basta aggiungere un delay)e per la precisione ...fanno entrambi lo stesso calcolo .
I fattori di conversione sono calcolati a tavolino e se l'ACS rispetta le specifiche sono i valori corretti (probabile che sia lo strumento )

Devi tenere in considerazione un fattore che non tutti dicono.
Quando alimentato dall'usb ,la tensione non risulta spesso correttamente 5V e delle volte è lei ad essere la colpevole.

Comunque sia ,modificando il fattore conversione puoi adattare il sensore alle tue condizioni.

Sempre con la formula :

Nuovo fattore = vecchio fattore * tensione letta strumento / tensione letta Arduino

Per ridurre la velocità in maniera semplice aggiungi:

delay (1000);

Sotto l'ultimo print  ;)

grazie Elettro  ;) funziona bene e anche preciso....con il codice che avevo provato io al inizio ero lontanissimo dal valore reale 

Prego ...è un piacere .

Se vuoi possiamo anche postare un codice per le letture della corrente alternata ...potrebbe risultare utile in qualche progetto  ;)

E se può essere utile ,aggiungerei un semplice trucchetto per visualizzare le letture a velocità "umana" ,ma lasciare Arduino libero di fare altri calcoli ....sempre per eventuali progetti

ElettroshockNow :
le letture a velocità "umana"


a proposito di questa cosa, ho notato che mentre attacco o stacco il carico la lettura non e immediata, tipo se ho un carico da 300mA inizia a leggere 100--160-190-220-300 e quando stacco non va subito a 0
ha che vedere con questo il trucchetto?