Ho ancora bisogno di voi.
Ho un sensore LDR che mi scrive il dato rilevato (ma alla fine a cosa corrsponde? LUX?) sulla sd collegata. Ho deciso di inserire un tasto che al valore High inizia a scrivere i valori sulla scheda ma non capisco come farlo.
E' corretto dire
if (buttonState == HIGH) {
// scrivi su SD:
Serial.println(dataString)
So che a voi sembrerà facile, ma io sto cercando di imparare...a fatica però
Grazie ancora
Forse ti manca qualcosa in più di un istruzione.
http://www.ladyada.net/products/microsd/
questo server è andato off-line comunque basta google "arduino sd card" escono tsunami di tutorial 
iniziamo dal facile: il bottone non puoi dire HIGH o LOW, per via del bounce. In pratica quando molli il pulsante il tato simbalza per un pò tra lo stato HIGH e LOW.
ma è una cosa che ad occhio umano non te ne accorgi. per la SD devi dirci che schield usi, le cose possono cambiare molto. Tra glli esempi di base dell'arduino c'è qualcosa.
Infine per interpretare i dati del sensore ci serve anche quì il modello: alcuni sono "intelligenti" e danno i valori in LUX, altri danno un valore che secondo il datashett va moltiplicato/diviso/manipolato per ottenere il dato in LUX o altre forme di misura.
Fondamentalmente il secondo caso è il più comune, e di gran lunga.
Lo shield sd è questo:
Il sensore invece è un semplice LDR ma non so dirvi altro.
Io dovrei già avere corretta l'istruzione della scrittura su SD ma volevo solamente mettere in mezzo un tasto che alla pressione iniziasse la scrittura
Ma non è un istruzione....
Va utilizzata una libreria "che trovi negli esempi della IDE"
Vanno dichiarati i pin che utilizzano lo shield
Vanno dichiarate le variabili File
Vanno dichiarate le variabili Volume
Vanno dichiarate le variabili Root
Il file deve essere creato
Il file deve essere aperto
il file deve essere scritto
il file deve essere chiuso
cercati dei tutorial, non è solo un "print.sd"
Inoltre la scrittura non deve essere persistente, non è un hard disk, pochi giorni di scrittura e la butti nel cestino
Questo è quello che ho scritto:
int sensore = 0; // pin analogico LDR
int val; // dichiariamo una variabile val
void setup(){
Serial.begin(9600);
Serial.println("Initializing SD card...");
pinMode(ledPin, OUTPUT); // settiamo lo stato del led
}
//se il modulo sd non viene correttamente inizializzato
if (!SD.begin(chipSelect)) {
//messaggio di errore sul nostro monitor seriale
Serial.println("Card failed, or not present");
}
return;
}
//se correttamente inizializzata...
Serial.println("card initialized.");
void loop(){
val = analogRead(sensore); // diciamo di leggere i valori associati al sensore
Serial.print("Valore: ");
Serial.println(val); // leggiamo i valori che ha il sensore
File dataFile = SD.open("datalog.txt", FILE_WRITE)
delay(100);
}
else {
//errore nell'apertura del file o card rimossa
Serial.println("error opening datalog.txt");
for (i=0;i<10;i++) {
}
}
Prima domanda: Fino a qui è corretto?
Seconda domanda: Se si, dopo la lettura del valore, come posso inserire un tasto che inizi la scrittura su SD? Per gli errori del tasto HIGH/LOW ci sto già lavorando
bibopm:
Prima domanda: Fino a qui è corretto?
No, è tutto errato.
Dovresti prima studiarti la sintassi del linguaggio C. Ci sono molti errori.
Dai una lettura qui --> C (linguaggio): tutorial per imparare programmare | Guida HTML.it e qui --> C++: tutorial del linguaggio di programmazione | HTML.it
Poi per il logger leggi questo esempio.
#include <SD.h>
#include <Wire.h>
#include "RTClib.h"
// A simple data logger for the Arduino analog pins
// how many milliseconds between grabbing data and logging it. 1000 ms is once a second
#define LOG_INTERVAL 1000 // mills between entries (reduce to take more/faster data)
// how many milliseconds before writing the logged data permanently to disk
// set it to the LOG_INTERVAL to write each time (safest)
// set it to 10*LOG_INTERVAL to write all data every 10 datareads, you could lose up to
// the last 10 reads if power is lost but it uses less power and is much faster!
#define SYNC_INTERVAL 1000 // mills between calls to flush() - to write data to the card
uint32_t syncTime = 0; // time of last sync()
#define ECHO_TO_SERIAL 1 // echo data to serial port
#define WAIT_TO_START 0 // Wait for serial input in setup()
// the digital pins that connect to the LEDs
#define redLEDpin 2
#define greenLEDpin 3
// The analog pins that connect to the sensors
#define photocellPin 0 // analog 0
#define tempPin 1 // analog 1
#define BANDGAPREF 14 // special indicator that we want to measure the bandgap
#define aref_voltage 3.3 // we tie 3.3V to ARef and measure it with a multimeter!
#define bandgap_voltage 1.1 // this is not super guaranteed but its not -too- off
RTC_DS1307 RTC; // define the Real Time Clock object
// for the data logging shield, we use digital pin 10 for the SD cs line
const int chipSelect = 10;
// the logging file
File logfile;
void error(char *str)
{
Serial.print("error: ");
Serial.println(str);
// red LED indicates error
digitalWrite(redLEDpin, HIGH);
while(1);
}
void setup(void)
{
Serial.begin(9600);
Serial.println();
// use debugging LEDs
pinMode(redLEDpin, OUTPUT);
pinMode(greenLEDpin, OUTPUT);
#if WAIT_TO_START
Serial.println("Type any character to start");
while (!Serial.available());
#endif //WAIT_TO_START
// initialize the SD card
Serial.print("Initializing SD card...");
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(10, OUTPUT);
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
error("Card failed, or not present");
}
Serial.println("card initialized.");
// create a new file
char filename[] = "LOGGER00.CSV";
for (uint8_t i = 0; i < 100; i++) {
filename[6] = i/10 + '0';
filename[7] = i%10 + '0';
if (! SD.exists(filename)) {
// only open a new file if it doesn't exist
logfile = SD.open(filename, FILE_WRITE);
break; // leave the loop!
}
}
if (! logfile) {
error("couldnt create file");
}
Serial.print("Logging to: ");
Serial.println(filename);
// connect to RTC
Wire.begin();
if (!RTC.begin()) {
logfile.println("RTC failed");
#if ECHO_TO_SERIAL
Serial.println("RTC failed");
#endif //ECHO_TO_SERIAL
}
logfile.println("millis,stamp,datetime,light,temp,vcc");
#if ECHO_TO_SERIAL
Serial.println("millis,stamp,datetime,light,temp,vcc");
#endif //ECHO_TO_SERIAL
// If you want to set the aref to something other than 5v
analogReference(EXTERNAL);
}
void loop(void)
{
DateTime now;
// delay for the amount of time we want between readings
delay((LOG_INTERVAL -1) - (millis() % LOG_INTERVAL));
digitalWrite(greenLEDpin, HIGH);
// log milliseconds since starting
uint32_t m = millis();
logfile.print(m); // milliseconds since start
logfile.print(", ");
#if ECHO_TO_SERIAL
Serial.print(m); // milliseconds since start
Serial.print(", ");
#endif
// fetch the time
now = RTC.now();
// log time
logfile.print(now.unixtime()); // seconds since 1/1/1970
logfile.print(", ");
logfile.print('"');
logfile.print(now.year(), DEC);
logfile.print("/");
logfile.print(now.month(), DEC);
logfile.print("/");
logfile.print(now.day(), DEC);
logfile.print(" ");
logfile.print(now.hour(), DEC);
logfile.print(":");
logfile.print(now.minute(), DEC);
logfile.print(":");
logfile.print(now.second(), DEC);
logfile.print('"');
#if ECHO_TO_SERIAL
Serial.print(now.unixtime()); // seconds since 1/1/1970
Serial.print(", ");
Serial.print('"');
Serial.print(now.year(), DEC);
Serial.print("/");
Serial.print(now.month(), DEC);
Serial.print("/");
Serial.print(now.day(), DEC);
Serial.print(" ");
Serial.print(now.hour(), DEC);
Serial.print(":");
Serial.print(now.minute(), DEC);
Serial.print(":");
Serial.print(now.second(), DEC);
Serial.print('"');
#endif //ECHO_TO_SERIAL
analogRead(photocellPin);
delay(10);
int photocellReading = analogRead(photocellPin);
analogRead(tempPin);
delay(10);
int tempReading = analogRead(tempPin);
// converting that reading to voltage, for 3.3v arduino use 3.3, for 5.0, use 5.0
float voltage = tempReading * aref_voltage / 1024;
float temperatureC = (voltage - 0.5) * 100 ;
float temperatureF = (temperatureC * 9 / 5) + 32;
logfile.print(", ");
logfile.print(photocellReading);
logfile.print(", ");
logfile.print(temperatureF);
#if ECHO_TO_SERIAL
Serial.print(", ");
Serial.print(photocellReading);
Serial.print(", ");
Serial.print(temperatureF);
#endif //ECHO_TO_SERIAL
// Log the estimated 'VCC' voltage by measuring the internal 1.1v ref
analogRead(BANDGAPREF);
delay(10);
int refReading = analogRead(BANDGAPREF);
float supplyvoltage = (bandgap_voltage * 1024) / refReading;
logfile.print(", ");
logfile.print(supplyvoltage);
#if ECHO_TO_SERIAL
Serial.print(", ");
Serial.print(supplyvoltage);
#endif // ECHO_TO_SERIAL
logfile.println();
#if ECHO_TO_SERIAL
Serial.println();
#endif // ECHO_TO_SERIAL
digitalWrite(greenLEDpin, LOW);
// Now we write data to disk! Don't sync too often - requires 2048 bytes of I/O to SD card
// which uses a bunch of power and takes time
if ((millis() - syncTime) < SYNC_INTERVAL) return;
syncTime = millis();
// blink LED to show we are syncing data to the card & updating FAT!
digitalWrite(redLEDpin, HIGH);
logfile.flush();
digitalWrite(redLEDpin, LOW);
}
E' sovrabbondante in confronto a quello che vorresti fare tu, credo, ma è un buon punto di partenza.
Ricorda di usare i tag CODE (tasto # sopra le faccine) quando posti codice nel forum.
Giusto per capire verso cosa mi devo muovere, che cosa è sbagliato?
int sensore = 0; // pin analogico LDR
int val; // dichiariamo una variabile val
void setup(){
Serial.begin(9600);
Serial.println("Initializing SD card...");
pinMode(ledPin, OUTPUT); // settiamo lo stato del led
}
//se il modulo sd non viene correttamente inizializzato
if (!SD.begin(chipSelect)) {
//messaggio di errore sul nostro monitor seriale
Serial.println("Card failed, or not present");
}
return;
}
//se correttamente inizializzata...
Serial.println("card initialized.");
void loop(){
val = analogRead(sensore); // diciamo di leggere i valori associati al sensore
Serial.print("Valore: ");
Serial.println(val); // leggiamo i valori che ha il sensore
File dataFile = SD.open("datalog.txt", FILE_WRITE)
delay(100);
}
else {
//errore nell'apertura del file o card rimossa
Serial.println("error opening datalog.txt");
for (i=0;i<10;i++) {
}
}
Questo codice non compila.
Mancano definizioni di variabili
C'è un else senza if
Ci sono istruzioni fuori dalle funzioni
La classe SD non ha il costruttore
C'è un cliclo for vuoto
Il conto delle parentesi non torna
Ops. Forse nel copia e incolla ho mancato qualcosa. Vedrò di migliorare
La mia domanda iniziale però è ancora irrisolta. Se io collego un ldr che mi legge un dato e me lo scrive sulla seriale e poi ci metto un bottone che mi limita la funzione, nella logica dello strumento, è corretto mettere un tasto che abilità e disabilita l'ldr e quindi la scrittura seriale, oppure è giusto continuare a far leggere al ldr e limitare solo la scrittura?
... è corretto mettere un tasto che abilità e disabilita l'ldr e quindi la scrittura seriale, oppure è giusto continuare a far leggere al ldr e limitare solo la scrittura?
Tutte due le soluzioni portano al risultato desiderato visto ch non fai nessun controllo sul dato letto. se per esempio controlli se il valore letto supera una certa soglia devi leggerlo di continuo anche senza memorizzazione.
Ho un sensore LDR che mi scrive il dato rilevato (ma alla fine a cosa corrsponde? LUX?) sulla sd collegata.
La quantitá di luce fa cambiare la resistenza del LDR. Non c'é rapporto diretto tra luce e resistenza perché il LDR non é tarato e perché la curva di conversione é tutt'altro che lineare.
Ciao Uwe
Grazie mille
PaoloP:
Questo codice non compila.
Mancano definizioni di variabili
C'è un else senza if
Ci sono istruzioni fuori dalle funzioni
La classe SD non ha il costruttore
C'è un cliclo for vuoto
Il conto delle parentesi non torna
Per non parlare dei ";" mancanti
E, visto che siamo a correggerti :P.... indenta per bene il codice e commentalo. Fra 6 mesi mi ringrazierai per questo, se mai andrai a rileggerti il tuo programma 