TimeStamp file sd

Ciao, qualcuno ha qualche tutorial, esempio, su come creare file su sd, tramite eth shield, con nome in time stamp? Es. 20111129.csv

Ho trovato questo codice (non ho modo di testarlo perché sono lontana dall'arduino) e sebbene ci capisca qualcosa, mi sfugge una cosa.

in setup:
char filename[] = "00000000.CSV";

function call:
getFilename(filename);

function:
  void getFilename(char *filename) {
    DateTime now = RTC.now(); int year = now.year(); int month = now.month(); int day = now.day();
    filename[0] = '2';
    filename[1] = '0';
    filename[2] = year%10 + '0';
    filename[3] = year%10 + '0';
    filename[4] = month/10 + '0';
    filename[5] = month%10 + '0';
    filename[6] = day/10 + '0';
    filename[7] = day%10 + '0';
    filename[8] = '.';
    filename[9] = 'C';
    filename[10] = 'S';
    filename[11] = 'V';
    return;
  }

capisco la char nel setup e la funzione mi è chiara. Non mi è molto chiara la chiamata della funzione.

function call:
getFilename(filename);

Dove la metto, come la uso? Ho pensato una cosa simile, l'IDE me la compila, ma non ho modo di testarla al momento.

if (!SD.exists(filename)) {
    Serial.print(filename);
    Serial.println(" esiste.");
  }
  else {
    Serial.println("File di Log non presente."); 
    Serial.println("Creazione File di Log...");
    myFile = SD.open(filename, FILE_WRITE);
    myFile.close(); 
  }

la chiamata a funziona la fai nel setup, o nel loop, o in un’altra funzione, quando vuoi avere il dato. esattamente come se fosse una delay(), una digitalRead(), o una normalissima altra funzione. Se non ti è chiaro come possa modificare la stringa di partenza, sappi che è un gioco di puntatori.

ah dimenticavo: char filename = “00000000.CSV”; non va nel setup… essa è la stringa che conterrà la data, quindi deve essere accessibile sia per essere usata come parametro per la funzione, sia per la SD.open() o come diavolo si chiama

ci sono 2 soluzioni veloci:

  1. rendi la variabile globale mettendola sia fuori dal setup che da qualsiasi altra funzione; in questo modo tute le funzioni la vedono. quindi la void getFilename(char *filename) { va modificata in void getFilename() {, ma funziona lo stesso anche se non lo fai, ma il codice risulta “sporco”

  2. sposti la ichiarazione appena prima della chiamata a funzione getFilename, tanto non ti serve da tenere in memoria quel numero. In questo modo il loop funziona così:
    leggi i sensori
    char filename = “00000000.CSV”;
    getFilename(filename);
    SD.open(filename, “w”);
    blablabla…

Grazie Lesto, sei sempre utilissimo e molto disponibile :slight_smile:
Se hai qualche link sui puntatori lo leggo volentieri.

Cmq, sketch sistemato, credo funzioni anche se ancora non lo posso provare.
C’è però un arcano molto misterioso.
Come mai un codice di 82 righe mi occupa 14882 kb (quasi la metà dello spazio a disposizione)
mentre il codice globale dei sensori (quasi 220 righe) occupa solo 9000kb o giù di li?
Mi sono fatta l’idea che sia la libreria SD che è piuttosto pesante, se ciò fosse ce ne sono di più leggere per le cavolatine che devo fare io?

Posto il codice per chi ne avrà, come ne ho avuto io, bisogno:

// Creazione file di log con TimeStamp

#include <SD.h>
#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 RTC;
File myFile;


void setup () {
  Serial.begin(57600);
  Wire.begin();
  RTC.begin();

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");    
  }

  Serial.print("Initializing SD card...");
  // On the Ethernet Shield, CS is pin 4. It's set as an output by default.
  // Note that even if it's not used as the CS pin, the hardware SS pin 
  // (10 on most Arduino boards, 53 on the Mega) must be left as an output 
  // or the SD library functions will not work. 
  pinMode(10, OUTPUT);

  if (!SD.begin(4)) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");
}

// funzione creazione timestamp file di log
void getFilename(char *filename) {
  DateTime now = RTC.now(); 
  int year = now.year(); 
  int month = now.month(); 
  int day = now.day();
  filename[0] = '2';
  filename[1] = '0';
  filename[2] = year%10 + '0';
  filename[3] = year%10 + '0';
  filename[4] = month/10 + '0';
  filename[5] = month%10 + '0';
  filename[6] = day/10 + '0';
  filename[7] = day%10 + '0';
  filename[8] = '.';
  filename[9] = 'c';
  filename[10] = 's';
  filename[11] = 'v';
  return;
}

void loop () {
  DateTime now = RTC.now();

  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.println();

  Serial.print(" since midnight 1/1/1970 = ");
  Serial.print(now.unixtime());
  Serial.print("s = ");
  Serial.print(now.unixtime() / 86400L);
  Serial.println("d");

  // Verifica presenza file di log formattato in TimeStamp:
  char filename[] = "00000000.csv";
  getFilename(filename);
  if (!SD.exists(filename)) {
    Serial.print(filename);
    Serial.println(" esiste.");
  }
  else {
    Serial.println("File di Log non presente."); 
    // Se il file di log non esiste viene creato:
    Serial.println("Creazione File di Log...");
    myFile = SD.open(filename, FILE_WRITE);
    // Scrittura dell'Header del file di Log e successiva chiusura:
    myFile.println("millis, date, t_out, rh_out, t_in, rh_in, t_h20, t_heat, heat");
    myFile.close(); 
  } 
  // Ricontrolla l'esistenza del file di log con il corretto TimeStamp: 
  if (SD.exists(filename)) {
    Serial.print(filename);
    Serial.println(" esiste.");
  }
  else {
    Serial.println("File di Log non presente.");  
  }
  delay (1000);
}

la SD.h, non solo deve leggere e scrivere la SD, ma se non erro lo fa seguendo il filesystem FAT16, che di certo non è stato pensato per essere semplice, ecco da dove arriva quella differenza :-)

ora hai un altro problema: scrivi sulla SD ogni ciclo, cioè circa qualche decina di migliaia di volte (se non di più! ho tolto qualcosa per via del FAT) al secondo... e una scheda SD regge (per ogni singolo bit) in media "solo" 100.000 riscritture o giù di lì... insomma in qualche ora riempi la memoria, e in qualche giorno (ammesso che sovrascrivi i dati) la SD è da buttare!

lesto: ora hai un altro problema: scrivi sulla SD ogni ciclo, cioè circa qualche decina di migliaia di volte (se non di più! ho tolto qualcosa per via del FAT) al secondo... e una scheda SD regge (per ogni singolo bit) in media "solo" 100.000 riscritture o giù di lì... insomma in qualche ora riempi la memoria, e in qualche giorno (ammesso che sovrascrivi i dati) la SD è da buttare!

Qua i problemi pullulano... si usa ancora pullulano come termine o fa anziana? :)

BTW. Questo dimostra che non capisco una mazza di programmazione, perché non comprendo bene come possa accadere quello che scrivi.

Le operazioni sulla SD nel ho messe nel void loop, il loop alla fine ha un delay di 1 secondo... credevo quindi che tutto il cliclo, compreso il datalogging, avvenisse quindi ad intervalli di 1 secondo. Non capisco dove siano queste decine di migliaia di cicli al secondo :\ Lesto please illuminami :)

sìsì, io lo uso "pullulano" :)

non mi ero accorto del delay, allora hai ragione! devi solo farti il calcolo in quanto tempo la SD si riempie, e ottinei il tempo massimo entro cui devi scaricare i file dalla SD,. poi moltiplichi per 10.000 ( il ciclo di vita della SD) ed ottieni la durata media della SD nella tua applicazione

Mannaggia a te Lesto, ho passato ore in ansia pensando di aver creato uno sketch in grado di friggermi la SD :) A mozzichi! Altro che Fiorello quando imita il vampiro di twilight ;)

Battute a parte, grazie del tempo che passate a darci una mano, senza l'assistenza di molti di voi noi novizi combineremmo ben poco :)

Ed ora speriamo che con l'arrivo dell'IDE 1.0 non debba rifare tutto da capo :)

lesto: secondo... e una scheda SD regge (per ogni singolo bit) in media "solo" 100.000 riscritture o giù di lì... insomma in qualche ora riempi la memoria, e in

Una SD decente, p.e. quelle di SanDisk, ha un endurance minima di 300.000 cicli di scrittura per ogni singolo blocco di 512 byte. Le SD cinesi da due soldi non arrivano nemmeno a 5000 cicli.