modulo micro sd e leonardo, alcune difficoltà.

Ho realizzato un data logger con
modulo SHT25
modulo OLED display
modulo RTC
modulo micro sd carc adapter

inizialmente montato su MEGA, per problemi di memoria. in quanto per poco non ci sta su Arduino UNO, ma su MEGA funziona perfettamente.

Per ridurre lo spazio fisico senza andare in out-of-memory, l’unica possibilità è sostituire il mega con il leonardo. Ci sta pelo pelo…

“Lo sketch usa 28.226 byte (98%) dello spazio disponibile per i programmi. Il massimo è 28.672 byte.
Le variabili globali usano 2.280 byte (89%) di memoria dinamica, lasciando altri 280 byte liberi per le variabili locali. Il massimo è 2.560 byte.”

Ricollego il tutto, ma la SD mi da problemi, non mi apre il file. Ho due routine , una verifica la presenza della sd card, l’altra successivamente verifica l’apertura del file.

  // START *** initialize SDcard
  pinMode(CS_PIN, OUTPUT); // CS modulo SD card
  if (!SD.begin(CS_PIN)) {  //se non viene letta la card si blocca
    display.clearDisplay();
    display.setCursor(0, 0);
    display.setTextColor(WHITE);
    display.setTextSize(2);
    display.print  (F("  INSERT  "));
    display.println(F(" SD CARD! "));
    display.display();
    while (1 == 1) {};
  }
  myFile = SD.open("HTLOG000.txt", FILE_WRITE);

  if (myFile) {       // se il file non viene creato si blocca
    myFile.println(F("data; temperatura; umidità"));
  } else {
    display.clearDisplay();
    display.setCursor(0, 0);
    display.setTextColor(WHITE);
    display.setTextSize(2);
    display.print  (F("  ERROR!  "));
    display.println(F(" NO FILE! "));
    display.display();
    while (1 == 1) {};
  }
  //END **** fine initialize SDcard

Mi riporta questo secondo errore. Deduco quindi che il problema non è un problema di connessioni SPI, in quanto la MicroSD viene rilevata correttamente, quanto un problema di scrittura (creazione) del file txt.

Ora è possibile che sia un problema di FAT, che su MEGA non c’è, mentre si manifesta su Leonardo?
la SD è formattata FAT32 attualmente.

SE vado sulla funzione di Windows di formattazione tra le opzioni non ho “FAT” (16), che cmq non credo supporti sd da 8 Gb, giusto?

Ne penso dovrebbe essere un problema di dimensioni della SD, che è da 8Gb, perchè la library su mega la gestisce.

qualche idea?

la library SDFat-beta-master mi puo servire a qualcosa?

Ho letto diversi post sull’argomento ma non trovo niente di simile al mio problema.

aggiornamento:

il problema è l'apertura del file, in quanto ho verificato che il file viene creato, ma non sembra venire aperto.

Libreria usata? impostazioni ? variabili globali? serve qualcosa di più... La formattazione deve essere a 32 non a 16

ho eseguito la ruotine

risultato
*******************************+
Initializing SD card…Wiring is correct and a card is present.

Card type: SDHC

Volume type is FAT32

Volume size (bytes): 3430940672
Volume size (Kbytes): 3350528
Volume size (Mbytes): 3272

Files found on the card (name, date and size in bytes):
HTLOG000.TXT 2000-01-01 01:00:00 0
HTLOG01.TXT 2000-01-01 01:00:00 0


la libreria usata è la SD.h

“// SD CARD R/W
#include <SD.h>
int CS_PIN = 4;
File myFile;”

Sembra tutto ok, quindi non capisco perchè mi da errore al

" myFile = SD.open(“HTLOG01.txt”, FILE_WRITE);
if (myFile) { "

e qui si blocca, myFile = falso, eppure il file c’è. :o

che sia un problema di poca memoria rimasta?

Mi vuoi dare lo sketch o no?

hai messo l'inizializzazione init(SPI_HALF_SPEED, chipSelect) inizializzi il root?

senza scketch completo come si fa a dirti cosa manca o dove sbagli

no non ho fatto quelle operazioni. Neanche sul Mega. come mai li funziona?

Eccolo!! :smiley:

// TEMP/HUMID DATA LOGGER X LEONARDO

// OLED 128*64 Display
#include <SPI.h>             // BUS per Display e SDcard
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_DC    13
#define OLED_CS     9
#define OLED_RESET 12
Adafruit_SSD1306 display(OLED_DC, OLED_RESET, OLED_CS);

// SD CARD R/W
#include <SD.h>
int CS_PIN = 4;
File myFile;

#include <Wire.h>           // BUS per scheda RTC e Sesore SHT21
#include <SHT2x.h>          // SHT21 sensore temp/hum
#include "Sodaq_DS3231.h"   // RTC real time clk

// numero campioni
word num_cam[] = {25, 50, 100, 250, 500, 1000, 5000};
byte ncam = 0;
word camp = 0;

// intervallo minuti
word min_int[] = {1, 15, 30, 60, 120};
byte mint = 0;
word inter = 0;

boolean START = false;
unsigned long tempo = 0;
unsigned long buttonTime = 0;
byte debounce = 500;

const int pin_start = A0;
int oldval_start = 0;
int val_start = 0;

const int pin_min = A1;
int oldval_min = 0;
int val_min = 0;

const int pin_smp = A2;
int oldval_smp = 0;
int val_smp = 0;

void setup()   {

  pinMode(pin_start, INPUT);
  pinMode(pin_min, INPUT);
  pinMode(pin_smp, INPUT);

  Wire.begin();
  display.begin(SSD1306_SWITCHCAPVCC);

  // mesaggio iniziale
  display.clearDisplay();
  display.setCursor(0, 0);
  display.setTextColor(WHITE);
  display.setTextSize(2);
  display.println(F("T/H Logger"));
  display.setTextSize(1);
  display.println(F("V.Guxxxx Scxxxxx"));
  display.println(F("rev. 1.0 30/09/15"));
  display.display();
  delay (1000);

  // START *** initialize SDcard
  pinMode(CS_PIN, OUTPUT); // CS modulo SD card
  if (!SD.begin(CS_PIN)) {  //se non viene letta la card si blocca
    display.clearDisplay();
    display.setCursor(0, 0);
    display.setTextColor(WHITE);
    display.setTextSize(2);
    display.print  (F("  INSERT  "));
    display.println(F(" SD CARD! "));
    display.display();
    while (1 == 1) {};
  }
  
  myFile = SD.open("HTLOG01.txt", FILE_WRITE);
  if (myFile) {       // se il file non viene aperto si blocca
    myFile.println(F("data; temperatura; umidità"));
  } else {
    display.clearDisplay();
    display.setCursor(0, 0);
    display.setTextColor(WHITE);
    display.setTextSize(2);
    display.print  (F("  ERROR!  "));
    display.println(F("OPEN FILE!"));
    display.display();
    while (1 == 1) {};
  }
  //END **** fine initialize SDcard

  tempo = millis();

}

void loop() {

inizio: ;

  // **** LETTURA/ACQUISIZIONE VALORI *******
  DateTime now = rtc.now();
  float humd = SHT2x.GetHumidity();
  float temp = SHT2x.GetTemperature();

  // ***** ROUTINE DI STAMPA **********
  display.clearDisplay();
  display.setCursor(0, 0);
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.println(F("*VALERIO DATA LOGGER"));

  display.print(F("  "));
  display.print(now.date(), DEC);
  display.print('/');
  display.print(now.month(), DEC);
  display.print('/');
  display.print(now.year(), DEC);
  display.print(' ');
  display.print(now.hour(), DEC);
  display.print(':');
  display.print(now.minute(), DEC);
  display.print(':');
  display.println(now.second(), DEC);

  display.setTextSize(2);
  display.print(F(" Tc: "));
  display.println(temp, 1);
  display.print(F(" H%: "));
  display.println(humd, 1);

  display.setTextSize(0);
  display.print("Samples : ");
  display.println(num_cam[ncam]);
  display.print("Interval: ");
  display.print(min_int[mint]);
  display.print("m ");

  if (!START) {
    display.setTextColor(WHITE, BLACK);
    display.println(" STOP");
  }
  else {
    display.setTextColor(BLACK, WHITE);
    display.println(" START!");
  }
  display.display();

  // ***** ROUTINE DI STAMPA FINE ********

  // ***** IMPOSTA VALORI CON PULSANTI

  // Pulsante Start/Stop
  val_start = digitalRead(pin_start);
  if (val_start && oldval_start && (millis() - buttonTime) > debounce) {
    START = !START;
    buttonTime = millis();
  }  // FINE TASTO premuto
  oldval_start = val_start;

  if (!START) {

    // Pulsante numero campioni
    val_smp = digitalRead(pin_smp);
    if (val_smp && oldval_smp && (millis() - buttonTime) > debounce) {
      ncam = ++ ncam;
      if (ncam > 6) { // Pulsante a 7 stati 0-6
        ncam = 0;
      }
      buttonTime = millis();
    }  // FINE TASTO premuto
    oldval_smp = val_smp;

    // Pulsante minuti
    val_min = digitalRead(pin_min);
    if (val_min && oldval_min && (millis() - buttonTime) > debounce) {
      mint = ++ mint;
      if (mint > 4) { // Pulsante a 5 stati 0-4
        mint = 0;
      }
      buttonTime = millis();
    }  // FINE TASTO premuto
    oldval_min = val_min;

    goto inizio;
  }

  // ***** SCRITTURA SU SD ********
  if ((now.minute() != tempo) and now.second() == 0 and START) {
    inter = ++inter ;
    tempo = now.minute();

    if (inter >= min_int[mint]) {
      inter = 0;
      num_cam[ncam] = -- num_cam[ncam];

      //scrivi su SD card
      myFile.print(now.date(), DEC);
      myFile.print('/');
      myFile.print(now.month(), DEC);
      myFile.print('/');
      myFile.print(now.year(), DEC);
      myFile.print(' ');
      myFile.print(now.hour(), DEC);
      myFile.print(':');
      myFile.print(now.minute(), DEC);
      myFile.print(':');
      myFile.print(now.second(), DEC);
      myFile.print(';');
      myFile.print(temp, 1);
      myFile.print(';');
      myFile.print(humd, 1);
      myFile.println();
    }
  }

  if (START and num_cam[ncam] == 0) {
    myFile.close();
    START = false;
  }
}

Confermo l'errore che visualizzi. Neanche a me funzionano più gli sketch SD che un anno fa andavano benissimo, probabilmente lo causa la nuova IDE ... ora ci studio su.

ciao

tieni conto che a me sul mega funzionava fino a ieri, provato e riprovato piu volte, andava alla grande, poi l'ho scollegato per ricablare tutto con leonardo... e plof! fine ...

ciao

Prova questo legge e scrive correttamente

#include <SPI.h>
#include <SD.h>
File myfile;

void setup(){
  Serial.begin(9600);  
  Serial.print("Initializing card...");
   pinMode(4, OUTPUT);
   
  if (!SD.begin(4)) {
    Serial.println("initialization of the SD card failed!");
    return;
  }
  Serial.println("initialization of the SDcard is done.");
  myfile = SD.open("mio.TXT", FILE_WRITE);

  if (myfile){
    Serial.print("Writing to the text file...");
    myfile.println("Congratulations! You have successfully wrote on the text file.");
 
    myfile.close(); // close the file:
    Serial.println("done closing.");
  }
     else{ 
    Serial.println("error opening the text file!");
  }
  myfile = SD.open("mio.TXT");
  if (myfile){
    Serial.println("mio.TXT:");
 
    while (myfile.available()) {
     Serial.write(myfile.read());
    }
    myfile.close();
  } 
  else 
    Serial.println("error opening the text file!");
}

void loop(){}

Le funzioni che ho sempre usato non sembrano andare a buon fine, devo ancora indagare

ok, prova effettuata, ma ho apportato una piccola modifica al tuo sketch

ho messo "while (!Serial) ;"

void setup(){ Serial.begin(9600); while (!Serial) ;

in tal modo attende fino a che non apriro il monitor seriale.

cmq funziona. A questo punto dove sta il problema? mi pare di eseguire gli stessi comandi...

potrebbe essere la poca memoria disponibile?