sto usando il sensore LM35 per la temperatura ( supply V5 resistor di 100 ohm ) però mi da la temperatura tra 12 c° e 13 c° non cambia anche se lo metto vicino l'aria calda ma la temperatura non cambia o sto sbagliando la formula per la conversione della temperatura ? grazie mille
innanzitutto i pin d'ingresso analogici non necessitano di alcuna inizializzazione, perciò in void setup() il pinMode che hai messo non serve. Inoltre, la dichiarazione del pin dovrebbe essere fatta senza la "A", non so però se inserendola può dare problemi o meno, comunque ho sempre visto usare dichiarazioni tipo questa:
int lm35Temp =1;
Per quanto concerne la formula per calcolare la temperatura in Celsius devi utilizzare questa:
float tempC = readTemp / 9.31;
il perché del 9.31 te lo spiega bene il playground
Dopo puoi eseguire correttamente la conversione in °F così come hai fatto!!
se io seguo l'esempio di playground mettendo analogReference(INTERNAL) ora la temperatura è di 28 gradi e 84 F e il valore letto da LM35 è di 261 secondo voi può essere un problema di resister di 100 ohm che fornisce poca corrente o magari è il sensore LM35 che non rileva la temperatura esatta
ssmm:
..........secondo voi può essere un problema di resister di 100 ohm che fornisce poca corrente o magari è il sensore LM35 che non rileva la temperatura esatta
Normalmente non ho mai avuto grossi problemi con gli lm35, ma ultimamente in una determinata configurazione di un mio progetto ho richiesto aiuto al forum per delle letture decisamente "sballate"! In quell'occasione cyberhs mi ha consigliato di inserire un resistore pull down da 18k sull'uscita del sensore. Nel mio caso questo particolare è stato risolutivo.
meluino:
comunque ho sempre visto usare dichiarazioni tipo questa:
int lm35Temp =1;
Definire i pin come
int lm35Temp =1;
o
int lm35Temp =A1;
sono due cose diverse.
Il primo è il pin digitale 1 dove tral'altro si trova il segnale seriale TX, mentre A1 è il secondo pin analogico (che può essere usato anche in digitale).
La confusione avviene perché la funzione analogRead accetta una diversa numerazione dei pin.
Infatti mentre
int val = analogRead(1);
e
int val = analogRead(A1);
sono la stessa cosa, è diverso fare
int val = digitaRead(1);
e int val = digitalRead(A1);.
Quindi per il pin A1 l'indicazione corretta è A1 e non 1, anche con la analogRead. che poi si possa usare anche uno.. questo crea confusione.
PaoloP:
Quindi per il pin A1 l'indicazione corretta è A1 e non 1, anche con la analogRead. che poi si possa usare anche uno.. questo crea confusione.
Perfetto, mi hai dato una spiegazione a delle domande che spesso mi trovavo a pormi!! Infatti su questo particolare avevo posto il condizionale
C'è da dire che effettivamente molti esempi che trovo su manuali vari (fatti soprattutto per chi sta imparando) non ti agevolano nella comprensione, in quanto spesso la dichiarazione del pin è senza la "A"!!
Per rimanere in tema anche l'esempio del playgraund a cui ho rimandato utilizza una forma per così dire contratta!
float tempC;
int reading;
int tempPin = 0;
Se avessero utilizzato A0, non avrebbero tolto o aggiunto nulla a chi è esperto e avrebbero aiutato noi poveri profani ad avere le idee più chiare, giusto?
Comunque grazie per la delucidazione d'ora in poi cambierò il modo di dichiarare i pin analogici nei miei sketch!
io non sono tanto esperto di elettronica piano piano sto imparando ma mettendo pin 1 mi ha dato un valore molto strano secondo me lo prende come pin digitale non analogico
PaoloP:
Quindi per il pin A1 l'indicazione corretta è A1 e non 1, anche con la analogRead. che poi si possa usare anche uno ...
... infatti mica sono tanto convito che si può usare anche 1 :
A1 è in realtà solo una costante che definisce il pin 15, infatti (... come tu Paolo già sai), basta prendere il file pins_arduino.h del core per trovare:
gpb01:
... infatti mica sono convito che si può usare anche 1 :
Scusate un attimo, giusto per capire!
Preso da dubbi Amletici sono andato a riguardarmi il primo manuale che ho acquistato su Arduino (Getting Started with Arduino) e nei primi esempi di sketch con ingresso analogico il pin viene dichiarato senza che venga interposta la "A".
Nello specifico mi riferisco all'esempio 7:
const int SENSOR = 0;
int val = 0;
void setup(){
Serial.begin(9600);
}
void loop(){
val = analogRead(SENSOR);
Serial.println(val);
delay(100);
}
Ho provato il codice con e senza la "A" utilizzando un semplice potenziometro, il risultato è il medesimo.
Sicuramente dichiarere un pin analogico ad esempio con A0 anziché 0 è più comprensibile e formalmente più corretto, però il programma funziona correttamente in entrambe le situazioni!
Oppure ho sbagliato io nel comprendere qualcosa del discorso?
Come ti ha detto prima Paolo, quella dichiarazione è usata solo nella analogRead(), che infatti accetta sia 1 che A1 (con lo stesso significato), dato che comunque non sussiste ambiguità, essendo impossibile fare analogRead() su un pin digitale.
Ma concordo che questa notazione crea solo casino, usa sempre A1 e non avrai problemi. Sulla scheda è marchiato così ed è la cosa più chiara che si può fare.
non so cosa dire esattamente perchè ho appena visto un esempio su github un utente che ha creato la libreria per il sensore LM35 nel setup ha messo pinMode(lm35,INPUT)
Allora, dato che l_e chiacchiere stanno a zero e le supposizioni pure_, sono andato a verificare come stanno le cose e, come sempre, per avere una risposta ESATTA, tocca andare a spulciare nel "core" ...
Contrariamente a quanto pensavo, La risposta è SI, si può usare 0 ... 5 nella analogRead() e, per rispondere a ssmm, NO non ha senso usare il pinMode() prima di una analogRead().
Entrambe le affermazioni trovano risposta in come è fatta la analogRead():
int analogRead(uint8_t pin)
{
uint8_t low, high;
#if defined(analogPinToChannel)
#if defined(__AVR_ATmega32U4__)
if (pin >= 18) pin -= 18; // allow for channel or pin numbers
#endif
pin = analogPinToChannel(pin);
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
if (pin >= 54) pin -= 54; // allow for channel or pin numbers
#elif defined(__AVR_ATmega32U4__)
if (pin >= 18) pin -= 18; // allow for channel or pin numbers
#elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega644__) || defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__)
if (pin >= 24) pin -= 24; // allow for channel or pin numbers
#else
if (pin >= 14) pin -= 14; // allow for channel or pin numbers
#endif
#if defined(ADCSRB) && defined(MUX5)
// the MUX5 bit of ADCSRB selects whether we're reading from channels
// 0 to 7 (MUX5 low) or 8 to 15 (MUX5 high).
ADCSRB = (ADCSRB & ~(1 << MUX5)) | (((pin >> 3) & 0x01) << MUX5);
#endif
// set the analog reference (high two bits of ADMUX) and select the
// channel (low 4 bits). this also sets ADLAR (left-adjust result)
// to 0 (the default).
#if defined(ADMUX)
ADMUX = (analog_reference << 6) | (pin & 0x07);
#endif
// without a delay, we seem to read from the wrong channel
//delay(1);
#if defined(ADCSRA) && defined(ADCL)
// start the conversion
sbi(ADCSRA, ADSC);
// ADSC is cleared when the conversion finishes
while (bit_is_set(ADCSRA, ADSC));
// we have to read ADCL first; doing so locks both ADCL
// and ADCH until ADCH is read. reading ADCL second would
// cause the results of each conversion to be discarded,
// as ADCL and ADCH would be locked when it completed.
low = ADCL;
high = ADCH;
#else
// we dont have an ADC, return 0
low = 0;
high = 0;
#endif
// combine the two bytes
return (high << 8) | low;
}
Come ben si vede, nel caso del ATmega328P (che non rientra nei casi particolari) viene eseguita la semplice operazione ... if (pin >= 14) pin -= 14; ... che taglia la testa al toro
Per il resto, la lettura avviene accedendo direttamente hai registri e selezionando il giusto canale, quindi ... la pinMode() non serve a nulla se non a perdere tempo (... e chi la mette dimostra la sua poca conoscenza della materia).
... per inciso, diverso è il comportamento della analogWrite() che ... in realtà di analog ha ben poco, dato che usa i pin in modo digitale e genera un segnale PWM.
Anche per essa è comunque inutile ed una perdita di tempo, mettere la pinMode() dato che, la prima istruzione che viene eseguita dalla analogWrite(), è esattamente quella ...
void analogWrite(uint8_t pin, int val)
{
// We need to make sure the PWM output is enabled for those pins
// that support it, as we turn it off when digitally reading or
// writing with them. Also, make sure the pin is in output mode
// for consistenty with Wiring, which doesn't require a pinMode
// call for the analog output pins.
pinMode(pin, OUTPUT);
if (val == 0)
{
digitalWrite(pin, LOW);
}
else if (val == 255)
{
digitalWrite(pin, HIGH);
}
else
{
....
....
....
}
}
ad avere le idee più chiare, giusto?
