Buongiorno a tutti,
Vi ringrazio da subito per il vostro aiuto.
Sto costruendo una piccola stazione meteo provvisoria utilizzando un Arduino UNO con un GROOVE shield (con sensore di polveri sottili HM3301 di seeedstudio nella porta I2C) e con sopra un altro shield questa volta per una scheda microSD.
Il sensore e la scheda sembrerebbero funzionare tranquillamente ma purtroppo non riesco a scrivere i valori presi (visualizzati sul monitor seriale) sopra la microSD (riesco a creare il file dati.txt ma rimane vuoto)
Buongiorno e benvenuto nella sezione Italiana del forum,
cortesemente, come prima cosa, leggi attentamente il REGOLAMENTO di detta sezione, (... e, per evitare future possibili discussioni/incomprensioni, prestando molta attenzione al punto 15), dopo di che, come da suddetto regolamento (punto 16.7), fai la tua presentazione NELL'APPOSITA DISCUSSIONE spiegando bene quali esperienze hai in elettronica e programmazione, affinché noi possiamo conoscere la tua esperienza ed esprimerci con termini adeguati.
Grazie,
Guglielmo
P.S.: Ti ricordo che, purtroppo, fino a quando non sarà fatta la presentazione nell’apposita discussione, nel rispetto del succitato regolamento nessuno ti risponderà (eventuali risposte o tuoi ulteriori post, verrebbero temporaneamente nascosti), quindi ti consiglio di farla al più presto.
... aggiungo, metti anche una verifica sulla open() ... dataFile deve essere un file handle o "false" se qualche cosa è andato storto e, subito prima di scriverlo su SD, stampa il valore di "datapm" per essere sicuro che contenga qualche cosa di sensato.
E' proprio li il problema, non so che variabile mettere per far si che possa diciamo immagazzinare quel tipo di informazione (che dovrebbe essere un char moltiplicato per dei valori).
A me andrebbe benissimo anche salvare il monitor seriale su SD solo che ho provato di tutto, voi avete idea?
ora guardo bene cosa rimandano quelle funzioni, grazie per il consiglio (ho paura di non essere in grado di capirlo però)
quello che intendevo dire io è che le tue funzioni ritornano un "HM330XErrorCode" che è un enumeratore definito nella libreria "Seeed_HM330X.h" i questo modo:
quindi il "NO_ERROR" ti ritorna 0 che tradotto in char diventa "nullo" e nella tua SD, appunto, non salvi nulla.
se non ho capito male tu nella SD devi salvare quanto in "buf", che è un array di byte, preso a due a due e salvato in una variabile a 16 bit...
Continua a non scrivere, rifaccio velocissimo il codice facendo scrivere su SD tutto ciò che c'è sul monitor seriale sperando di bypassare i problemi (anche se qualche giorno fa non funzionava).
Appena finisco condivido il codice.
Ho provato a cambiare codice come scritto nel mio ultimo post:
#include <SPI.h>
#include <SD.h>
#include "Seeed_HM330X.h"
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL_OUTPUT SerialUSB
#else
#define SERIAL_OUTPUT Serial
#endif
const int chipSelect = 4; // Use the appropriate CS pin
HM330X sensor;
u8 buf[30];
const char *str[]={"sensor num: ","PM1.0 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
"PM2.5 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
"PM10 concentration(CF=1,Standard particulate matter,unit:ug/m3): ",
"PM1.0 concentration(Atmospheric environment,unit:ug/m3): ",
"PM2.5 concentration(Atmospheric environment,unit:ug/m3): ",
"PM10 concentration(Atmospheric environment,unit:ug/m3): ",
};
HM330XErrorCode print_result(const char* str,u16 value)
{
if(NULL==str)
return ERROR_PARAM;
SERIAL_OUTPUT.print(str);
SERIAL_OUTPUT.println(value);
return NO_ERROR;
}
/*parse buf with 29 u8-data*/
HM330XErrorCode parse_result(u8 *data)
{
u16 value=0;
if(NULL==data)
return ERROR_PARAM;
for(int i=1;i<8;i++)
{
value = (u16)data[i*2]<<8|data[i*2+1];
print_result(str[i-1],value);
}
return NO_ERROR;
}
HM330XErrorCode parse_result_value(u8 *data)
{
if(NULL==data)
return ERROR_PARAM;
for(int i=0;i<28;i++)
{
SERIAL_OUTPUT.print(data[i],HEX);
SERIAL_OUTPUT.print(" ");
if((0==(i)%5)||(0==i))
{
SERIAL_OUTPUT.println(" ");
}
}
u8 sum=0;
for(int i=0;i<28;i++)
{
sum+=data[i];
}
if(sum!=data[28])
{
SERIAL_OUTPUT.println("wrong checkSum!!!!");
}
SERIAL_OUTPUT.println(" ");
SERIAL_OUTPUT.println(" ");
return NO_ERROR;
}
/*30s*/
void setup()
{
SERIAL_OUTPUT.begin(115200);
delay(100);
SERIAL_OUTPUT.println("Serial start");
if(sensor.init())
{
SERIAL_OUTPUT.println("HM330X init failed!!!");
while(1);
}
// Initialize SD card
if (!SD.begin(chipSelect))
{
Serial.println("SD card initialization failed!");
return;
}
Serial.println("SD card initialized.");
}
void loop()
{
// Open the file in append mode
File dataFile = SD.open("data.txt", FILE_WRITE);
// If the file opened successfully, write the data to it
if (dataFile)
{
// Read the incoming data and write it to the file
while (Serial.available())
{
char datapm = Serial.read();
dataFile.write(datapm);
}
dataFile.close(); // Close the file
}
if(sensor.read_sensor_value(buf,29))
{
SERIAL_OUTPUT.println("HM330X read result failed!!!");
}
parse_result_value(buf);
parse_result(buf);
SERIAL_OUTPUT.println(" ");
SERIAL_OUTPUT.println(" ");
SERIAL_OUTPUT.println(" ");
delay(5000);
}
Purtroppo continua a non scrivere nulla (il file dati.txt viene creato ma rimane vuoto, proprio 0K), non capisco come mai.
Avevo inoltre trovato una discussione uguale, ormai chiusa, nella quale alla fine non hanno risolto, questo sensore è rognoso .
Non ho compreso molto prima del loop, ma in altre discussioni si diceva inutile aprire il file ad ogni loop
Io apro e scrivo solo se ci sono le condizioni e ad intervalli regolari poi chiudo
un passo alla volta...in primis attenzione tra write e print...fanno cose diverse.
prova questo pezzo di codice che legge da seriale...se trova un '\n' come terminatore o passa un tot di tempo chiude il file; esguilo e dimmi cosa scrive sulla SD:
ciao...scusa ma non ho capito...hai usato esattamente il pezzo di codice che ho postato io o il "mix" che hai postato tu?
se usi solo quello che ho postato io scrive nel file o no?
perchè se scrive si procede con la gestione dei comandi da programma per integrare il sensore...se non scrive ci sono altri problemi...ed è necessario capire se l'uno o l'altro.
Funziona con gli esempi, questo codice ha creato e fatto scrivere:
/*
SD card read/write
This example shows how to read and write data to and from an SD card file
The circuit:
SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
created Nov 2010
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe
This example code is in the public domain.
*/
#include <SPI.h>
#include <SD.h>
File myFile;
void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB port only
}
Serial.print("Initializing SD card...");
if (!SD.begin(4)) {
Serial.println("initialization failed!");
while (1);
}
Serial.println("initialization done.");
// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
myFile = SD.open("test.txt", FILE_WRITE);
// if the file opened okay, write to it:
if (myFile) {
Serial.print("Writing to test.txt...");
myFile.println("testing 1, 2, 3.");
// close the file:
myFile.close();
Serial.println("done.");
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}
// re-open the file for reading:
myFile = SD.open("test.txt");
if (myFile) {
Serial.println("test.txt:");
// read from the file until there's nothing else in it:
while (myFile.available()) {
Serial.write(myFile.read());
}
// close the file:
myFile.close();
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}
}
void loop() {
// nothing happens after setup
}
.
.