Sto facendo uno studio approfondito sugli operazionali (ad esempio il classico LM358) come amplificatori differenziali con uscita verso l'ADC di Arduino.
Ne ho tratto diverse conclusioni interessanti, ma mi sono posto la domanda se sia indispensabile il resistore di carico in uscita all'operazionale e, pur cercando, non ho trovato una risposta definitiva.
Di solito si inserisce un resistore da 1-10k.
mah... meglio mettere sia un 10 k di carico sia una in serie all'uscita che limiti la corrente se qualcosa gira " male"
in genere più la resistenza di carico e bassa più il circuito risulta immune da disturbi
Se l'operazionale è alimentato con la stessa tensione del uC ed è retroazionato con un partitore c'è già un carico, e comunque mai avuto problemi per mancanza di carico, però una resistenza in serie all'uscita è molto utile in caso di guasto dell'amp-op.
Grazie per le risposte.
Esatto sono le stesse conclusioni a cui sono arrivato io:
1 - essendoci normalmente una retroazione, esiste già un resistore di carico;
2 - sarebbe meglio inserire un resistore in serie per limitare la corrente, MA con Arduino, essendo l'impedenza di ingresso di 10k (circa), si riduce la tensione per effetto del partitore che si viene a creare.
Ad esempio con un resistore da 1k la tensione viene ridotta di circa il 10%
No , la caduta di tensione di un ingresso analogico della serie AVR con una resistenza in serie da 10k è < 1mV, chi ti ha detto questa cosa ? Basta una semplice prova per verificare che è solo una burla.
cyberhs:
sarebbe meglio inserire un resistore in serie per limitare la corrente, MA con Arduino, essendo l'impedenza di ingresso di 10k (circa), si riduce la tensione per effetto del partitore che si viene a creare.
Assolutamente NO cyberhs ...
... l'impedenza di ingresso del ADC è di circa 100 Mohm. Quella di cui tu parli e l'impedenza di out della sorgente del segnale che deve essere al massimo di circa 10 Kohm perché ... c'è sempre fare i conti con la capacità da caricare del S&H che richiede una certa corrente per poterlo fare entro il tempo massimo richiesto 
Guglielmo
Caro Guglielmo, era quello che credevo anche io (dai manuali dei processori ad 8 bit ATMEL - Analog Input Circuitry) .
...The ADC is optimized for analog signals with an output impedance of approximately 10k or less...
Poi il manuale fa vedere che uno schema semplificato con un resistore (interno) di valore da 1k a 100k che carica il condensatore di sampling.
Tuttavia, da misure effettuate (per adesso solo su MICRO) nel resistore (1k) tra l'uscita di un OP differenziale (esterno) e l'ingresso ADC scorre una certa corrente e da calcoli che ho fatto questa corrente viene giustificata da una impedenza interna di appunto 10k.
cyberhs:
...
Tuttavia, da misure effettuate (per adesso solo su MICRO) nel resistore (1k) tra l'uscita di un OP differenziale (esterno) e l'ingresso ADC scorre una certa corrente e da calcoli che ho fatto questa corrente viene giustificata da una impedenza interna di appunto 10k.
Mi sembra incredibile ...
... in che condizioni hai fatto le misure ? Con l'ADC che acquisisce ? Se metti il codice (così siamo nelle stesse condizioni) provo a fare delle misure anche io ...
Guglielmo
Comunque ripeto che secondo me stai sbagliando qualche cosa ...
Il circuito rappresentato a pag. 249 del datasheet indica chiaramente che devi caricare il condensatore del S/H che è circa da 14pF e lo devi fare con un qualche cosa che loro indicano da 1..100 K? (per ovvie ragioni di tempo di carica).
Inoltre dicono chiaramente :
The ADC is optimized for analog signals with an output impedance of approximately 10 K? or less. If such a source is used, the sampling time will be negligible. If a source with higher impedance is used, the sampling time will depend on how long time the source needs to charge the S/H capacitor, with can vary widely.
Ed infine, a pagina 317 del datasheet, è chiaramente indicato : RAIN - Analog Input resistance - 100 M?.
Spiega come stai facendo le misure perché c'è qualche cosa che non va ... 
Guglielmo
Adesso le rifaccio e ti so dire.
Grazie!
Occhio a non fare un loop stretto di acquisizioni ... altrimenti leggi in continuazione la corrente di carica del S/H XD
Guglielmo
Mi permetto di suggerire un metodo molto semplice.
Colleghi un potenziometro da 1MOhm tra i +5V e l'ingresso di Arduino.e regoli la sua posizione per una tensione al pin di 2,5V (1/2 Vcc).
A questo punto la resistenza inserita con il poteziometro equivale a quella equivalente interna del dispositivo.
gpb01:
Occhio a non fare un loop stretto di acquisizioni ... altrimenti leggi in continuazione la corrente di carica del S/H XDGuglielmo
Difatti era il dubbio che era venuto anche a me. Il circuito S&H carica il condensatore attraverso il resistore, poi stacca il pin e devia il circuito al comparatore che, per comparazioni successive, restituisce la tensione che era presente in ingresso sotto forma di un valore digitale. Durante la scarica del condensatore, il pin non è collegato all'S&H, giusto? Quindi non dovrebbe assorbire corrente durante la fase di scarica. Se noti un consumo costante, allora ci sta che stai facendo una lettura dietro l'altra, quindi leggi la corrente delle cariche successive.
Mi intrometto in questo topic per avere una utile info visto che si parla di S&H, letture consecutive veloci di multipli pin analogici, e avendo nel mio sketch questa porzione di codice per leggere 5 porte analogiche:
//###################
//LETTURA SENSORI ###
//###################
//Lettura dati dei sensori e calcolo della corrente assorbita e dei consumi in watt
ampereTot = 0.00;
ampereCucina = 0.00;
ampereStanze = 0.00;
ampereBagni = 0.00;
numeroCampionamenti = 0;
inizioCampionamenti = millis() ;
do
{
numeroCampionamenti++;
//offsetValue è la lettura senza carico quindi lo sottraiamo alle letture dei sensori
offsetValue = analogRead(offsetPin);
sensorStanzeValue = analogRead(sensorStanzePin);
sensorStanzeValue -= offsetValue;
sensorBagniValue = analogRead(sensorBagniPin);
sensorBagniValue -= offsetValue;
sensorCucinaValue = analogRead(sensorCucinaPin);
sensorCucinaValue -= offsetValue;
sensorTotValue = analogRead(sensorTotPin);
sensorTotValue -= offsetValue;
//Alcune letture potrebbero avere valore negativo per cui noi consideriamo il valore assoluto
ampereTot += abs(sensorTotValue);
ampereCucina += abs(sensorCucinaValue);
ampereStanze += abs(sensorStanzeValue);
ampereBagni += abs(sensorBagniValue);
}
while ((millis() - inizioCampionamenti) < 80);
/*Serial.print(offsetValue);
Serial.println(sensorTotValue);
Serial.println(sensorCucinaValue);
Serial.println(sensorBagniValue);
Serial.println(sensorStanzeValue);
Serial.println("-------------------");*/
//Per ottenere gli ampere reali moltiplichiamo la media di ampere letti negli 80ms per 0.166 che è il fattore di conversione calcolato con un carico noto
ampereTot = (ampereTot / numeroCampionamenti) * fattoreConversione;
ampereCucina = (ampereCucina / numeroCampionamenti) * fattoreConversione;
ampereStanze = (ampereStanze / numeroCampionamenti) * fattoreConversione;
ampereBagni = (ampereBagni / numeroCampionamenti) * fattoreConversione;
//Infine moltiplichiamo gli ampere per la tensione stabilita per ottenere il consumo in Watt
consumoTot = ampereTot * tensione;
consumoCucina = ampereCucina * tensione;
consumoStanze = ampereStanze * tensione;
consumoBagni = ampereBagni * tensione;
e avendo riscontrato il problema che il consumo calcolato dalla sezione Bagni si trascina qualche lettura dal sensore Stanze (che viene letto appena prima) ...
Si potrebbe risolvere con l'uso di un operazionale ? O in qualche altro modo ?
Il tuo metodo per calcolare il valore della corrente non è esatto.
Si deve calcolare il valore RMS della corrente e non la sua media.
Leggi questo articolo:
http://openenergymonitor.org/emon/buildingblocks/ac-power-introduction
Ho deciso a monte di "accontentarmi" di una certa approssimazione, considera che do per fisso il valore della tensione @ 230v per il calcolo dei watt, almeno per il momento, e ovviamente ti ringrazio per il consiglio 
e ci darò un occhiata
Tuttavia attualmente volevo capire ed eventualmente risolvere il problema delle letture "false"...
Visto che a breve dovrò anch'io sviluppare del codice con l'ADC di arduino, volevo capire il cosidetto problema di "trascinamento" degli ingressi analogici.
Ho preso Arduino Uno con due potenziometri da 10kOhm e collegato gli estremi a Vcc e Gnd ed i centrali agli ingressi A0 e A2.
Caricato il seguente codice.
word V0; // variabile lettura pin 0
word V2; // variabile lettura pin 2
unsigned long t0; // variabile supporto intervalli letture
unsigned long ti=1000; // periodo di lettura
void setup() {
Serial.begin(57600);
t0=millis();
}
void loop() {
if ((millis()-t0) > ti) {
t0= t0 + ti;
Serial.print("V0="); Serial.println(V0);
Serial.print("V2="); Serial.println(V2);
Serial.println();
}
V0= V0 + analogRead(A0);
V0 = V0 /2;
V2= V2 + analogRead(A2);
V2 = V2 /2;
}
Risultato, i valori rispettano la posizione del cursore del rispettivo potenziometro.
Nessun segno che la lettura di A0 sia influenzata da A2 e viceversa.
Ho ripetuto il test anche tra A0 e A1, ho tolto quella sorta di calcolo della media, ma niente tutto è ok.
Chiedo aiuto al riguardo.
Supponiamo che su un ingresso analogico di Arduino siano presenti 2.5V e che la Vref sia esattamente 5V.
Come è noto il valore ADC sarà 512 (+/- 1).
Qualsiasi misura analogica è afflitta da "rumore" (noise), cioè è possibile che la lettura del ADC non siano sempre 512 ma alle volte un valore superiore od inferiore.
Per ridurre questo noise si usa leggere più volte l'ADC (oversampling), sommare i valori ed alla fine estrarne la media.
Se l'oversampling si limita a due letture, la cosa non ha molto senso: immaginate di sommare un valore "buono" (512) ad un valore "rumoroso" (540), il risultato della media sarebbe 526 = (512+540) / 2.
Ma se le letture sono 4 (ad esempio) di cui solo una vale 540, la media fornisce un netto miglioramento: 519 = (512+512+512+540) / 2.
Inoltre, se il rumore è stocastico (casuale o aleatorio) le letture più grandi di 512 vengono compensate da quelle inferiori a 512 nel calcolo della media, migliorando ulteriormente il risultato.
C'è molto altro da dire, ma per ora mi fermo qui.
cyberhs:
Sto facendo uno studio approfondito sugli operazionali (ad esempio il classico LM358) come amplificatori differenziali con uscita verso l'ADC di Arduino.
Ne ho tratto diverse conclusioni interessanti, ma mi sono posto la domanda se sia indispensabile il resistore di carico in uscita all'operazionale e, pur cercando, non ho trovato una risposta definitiva.
Di solito si inserisce un resistore da 1-10k.
Si può mettere per tante cose.. per corrispondere l'impedenza di uscita, per stabilizzare capacità di uscita elevate, etc.. per collegare un LM358 all'ADC di Arduino.. io non lo metterei
cyberhs:
Per ridurre questo noise si usa leggere più volte l'ADC (oversampling)
Sicuro?
L'oversampling si usa fare sugli ADC per "simulare" una risoluzione maggiore rispetto a quella realmente fornita dall'ADC stesso. Si fa campionando 22n dove n è il numero di bit risoluzioni in più voluta. Ma non si fa la media ma la media scalata.
Ad esempio, per simulare un ADC a 12 bit con l'ADC dell'Arduino (10 bit) si devono fare 22(12-10)=16 letture. Poi si prende la somma delle 16 letture ottenute e la si divide per 2n per avere la media scalata.
Leggere sequenzialmente un segnale analogico e poi farne la media non è... una "media" e basta?