Sto avendo dei grossi problemi ad usare le librerie per SD, mettendo mano al codice del sismografo mi son messo a pulire e riordinare le funzioni, ho detto, perchè non usare la SD.h che è più semplice (e il codice mi viene meglio) che non la SDfat, avete mai avuto problemi voi ?
La SDfat mi scrive la Sd (formattata in FAT) senza problemi, mentre per la seconda non cè verso..
Nella 0022 usavo SDfat e non riuscivo a usare la SD.h passando tutto con la 1.0 con la SD.h non ho problemi, in cosa posso esserti utile? non so cosa hai un modulo sd ... una ethernet con modulo sd?
ciao
Intanto grazie della risposta, ho sia una eth shield che un adattatore per SD americano di cui non ricordo il nome, l'errore è il medesimo con entrambe, però sarò sincero con l'IDE 1.0 non ho ancora provato ora sto usando lo 0023, dici che sia la libreria in esso contenuta a dare problemi ?
ps sto usando la mega, dopo aver abilitato il cs in SPI.h
allora sei nel mio stesso problema con la 22-23 non riuscivo proprio a usare quella lib da diventare scemo, solo la fat andava bene, quando ho trovato esempi con la 1.0 che usavano la SD.h mi è venuto un coccolone, poi li ho provati e ci sono rimasto male funzionavano 
Se utilizzi la shield ethernet w5100 ti consiglio di passare alla 1.0 - 1.0.1 hai molte meno rogne, da allora sono più tranquillo e mi faccio meno nervoso ahahahahahah
Ok, domani la scarico a scuola perchè quà a casa ci metto delle ore sennò 
intanto provo ad addentrarmi nei meandri dell'incasinatissima SDfat 
Ok, sono arrivato ad un binario morto, ho riscritto parte del codice del sismografo, mancano ancora tutte le funzioni di conversione ma quelle non sono un problema.
Non capisco dove sbaglio, i dati d (xyz) dichiarati alla fine non vengono salvati nel file che viene creato, sapreste dirmi dove sbaglio ? la sintassi è corretta l'unica mia perplessità riguarda la scrittura sul file usando appunto la SDfat...
#include <Wire.h>
#include <SdFat.h>
#include <SdFatUtil.h>
#define address 0x40
Sd2Card card;
SdVolume volume;
SdFile root;
SdFile file;
void initBMA180()
{
int temp, result, error;
Wire.beginTransmission(address);
Wire.send(0x00);
Wire.requestFrom(address, 1);
while(Wire.available())
{
temp = Wire.receive();
}
Serial.print("Id = ");
Serial.println(temp);
result = Wire.endTransmission();
checkResult(result);
if(result > 0)
{
error = 1;
}
delay(10);
if(temp == 3)
{
Wire.beginTransmission(address);
Wire.send(0x0D);
Wire.send(B0001);
result = Wire.endTransmission();
checkResult(result);
if(result > 0)
{
error = 1;
}
delay(10);
Wire.beginTransmission(address);
Wire.send(0x20);
Wire.send(B00001000);
result = Wire.endTransmission();
checkResult(result);
if(result > 0)
{
error = 1;
}
delay(10);
Wire.beginTransmission(address);
Wire.send(0x35);
Wire.send(B0100);
result = Wire.endTransmission();
checkResult(result);
if(result > 0)
{
error = 1;
}
delay(10);
}
if(error == 0)
{
Serial.print("BMA180 Init Successful");
}
}
void checkResult(int result)
{
if(result >= 1)
{
Serial.print("PROBLEM..... Result code is ");
Serial.println(result);
}
else
{
Serial.println("Read/Write success");
}
}
void readId()
{
int temp, result;
Wire.beginTransmission(address);
Wire.send(0x00);
Wire.requestFrom(address, 1);
while(Wire.available())
{
temp = Wire.receive();
}
Serial.print("Id = ");
Serial.println(temp);
result = Wire.endTransmission();
checkResult(result);
delay(10);
}
int readAccel3(byte msbAddr, byte lsbAddr)
{
short temp, result, temp2;
byte lsb, msb = 0;
temp2 = 0;
temp = 0;
while(temp != 1)
{
Wire.beginTransmission(address);
Wire.send(msbAddr);
Wire.requestFrom(address, 1);
while(Wire.available())
{
msb = Wire.receive();
temp = msb & 0x01;
}
}
Wire.beginTransmission(address);
Wire.send(lsbAddr);
Wire.requestFrom(address, 1);
while(Wire.available())
{
lsb = Wire.receive();
temp |= lsb;
temp = temp >> 2;
}
result = Wire.endTransmission();
msb = msb >> 2;
if(lsb & B10000000){
lsb &= B01111111;
temp2 = lsb << 6;
temp2 |= msb;
temp2 = 0 - temp2;
}else{
temp2 = lsb << 6;
temp2 |= msb;
}
return temp2;
}
int readAccel2(byte lsbAddr, byte msbAddr){
byte lsb, msb = 0;
short result;
while(!(lsb & 1)){
Wire.beginTransmission(address);
Wire.send(lsbAddr);
Wire.requestFrom(address, 1);
while(Wire.available()){
lsb = Wire.receive();
}
Wire.endTransmission();
}
Serial.print("lsb: ");
Serial.println(lsb, BIN);
if(lsb & 1){
Serial.println("new_data");
}
lsb = lsb >> 2;
Serial.print("lsb: ");
Serial.println(lsb, BIN);
Wire.beginTransmission(address);
Wire.send(msbAddr);
Wire.requestFrom(address, 1);
while(Wire.available()){
msb = Wire.receive();
}
Wire.endTransmission();
Serial.print("msb: ");
Serial.println(msb, BIN);
result = msb << 6;
Serial.print("res: ");
Serial.println(result, BIN);
result |= lsb;
Serial.print("res: ");
Serial.println(result, BIN);
Serial.print("res: ");
Serial.println(result, DEC);
return 0;
}
int readAccel(byte msb, byte lsb)
{
int temp, result;
temp = 0;
while(temp != 1)
{
Wire.beginTransmission(address);
Wire.send(msb);
Wire.requestFrom(address, 1);
while(Wire.available())
{
temp = Wire.receive() & 0x01;
}
}
Wire.beginTransmission(address);
Wire.send(lsb);
Wire.requestFrom(address, 1);
while(Wire.available())
{
temp |= Wire.receive();
temp = temp >> 2;
}
result = Wire.endTransmission();
return temp;
}
#define error(s) error_P(PSTR(s))
void error_P(const char* str) {
PgmPrint("error: ");
SerialPrintln_P(str);
if (card.errorCode()) {
PgmPrint("SD error: ");
Serial.print(card.errorCode(), HEX);
Serial.print(',');
Serial.println(card.errorData(), HEX);
}
while(1);
}
void writeNumber(SdFile& f, uint32_t n) {
uint8_t buf[10];
uint8_t i = 0;
do {
i++;
buf[sizeof(buf) - i] = n%10 + '0';
n /= 10;
} while (n);
f.write(&buf[sizeof(buf) - i], i);
file.close();
Serial.println("Done");
}
void setup() {
Wire.begin();
Serial.begin(9600);
initBMA180();
delay(2000);
Serial.println();
// initialize the SD card at SPI_HALF_SPEED to avoid bus errors with
// breadboards. use SPI_FULL_SPEED for better performance.
if (!card.init(SPI_HALF_SPEED)) error("card.init failed");
// initialize a FAT volume
if (!volume.init(&card)) error("volume.init failed");
// open the root directory
if (!root.openRoot(&volume)) error("openRoot failed");
// create a new file
char name[] = "WRITE00.TXT";
for (uint8_t i = 0; i < 100; i++) {
name[5] = i/10 + '0';
name[6] = i%10 + '0';
if (file.open(&root, name, O_CREAT | O_EXCL | O_WRITE)) break;
}
if (!file.isOpen()) error ("file.create");
Serial.print("Writing to: ");
Serial.println(name);
}
void loop()
{
int X,Y,Z=0;
Serial.println(" X: ");
X = readAccel3(0x03, 0x02);
double dX;
dX = X * 0.00025;
Serial.println(dX);
Serial.println(" Y: ");
Y = readAccel3(0x05, 0x04);
double dY;
dY = Y * 0.00025;
Serial.println(dY);
Serial.println(" Z: ");
Z = readAccel3(0x07, 0x06);
double dZ;
dZ = Z * 0.00025;
Serial.println(dZ);
writeNumber(file, dX);
writeNumber(file, dY);
writeNumber(file, dZ);
delay(200);
}
Da notare che nel serial monitor mi appaiono le stringhe contenenti le letture ed anche il done di scrittura solo che poi dentro al file TXt o CSV che sia non cè niente :~
ma... secondo me il problema potrebbe essere provocato dal fatto che non apri e chiudi il file ad ogni terna di valori che scrivi, ma tieni il file aperto. così magari si riempie un buffer, che senza chiudere non forzi a scrivere, senza contare che staccare l'SD così potrebbe provocare una "rottura" del File System
Ci avevo pensato, infatti avevo inserito file.close()
alla fine del void loop() ma il problema si ripresentava....
Mi sono appena scaricato l'IDE 1.0 pr provare a vedere (su consiglio di pablos) se la SD.h funzionava ma non ho arduino qui..
Fatto, la standard SD ora funziona solo su ATmega 328 , sul mega non cè verso che vada...
Quale porte usi sulla mega?
posso vedere il tuo setup e l'istruzione che scrive su file?
o è sempre quello che hai pubblicato prima 2 post indietro
ciao
pablos:
Quale porte usi sulla mega?
posso vedere il tuo setup e l'istruzione che scrive su file?
o è sempre quello che hai pubblicato prima 2 post indietro
ciao
Ho usato tutti gli esempi forniti e anche qualcuno trovato in rete, ad ogni modo non è un problema perchè non lascio di certo la Mega dentro un pozzetto interrato in un bosco, per carità è stagno ma...
comunque uso una Seeeduino Mega, mi sa che il pin CS a cui alludono loro non corrisponde con il mio 53, devo fare qulche ricerca, perchè con la mega non condivide a pieno la piedinatura avendo tra l'altro una 10ina di pin in più..
aspetta .... io ho la mega ti passo quello che uso io che funziona veditelo e smanetta
#include <SD.h>
byte err_sd=1;
byte SD_CS = 4; // pin 4 is the SPI select pin for the SDcard
byte ETHER_CS = 10; // pin 10 is the SPI select pin for the Ethernet
Sd2Card card;
SdVolume volume;
SdFile root;
SdFile file;
void setup()
{
Serial.begin(9600);
pinMode(ETHER_CS, OUTPUT); // Set the CS pin as an output
digitalWrite(ETHER_CS, HIGH); // Turn off the W5100 chip! (wait for configuration)
pinMode(SD_CS, OUTPUT); // Set the SDcard CS pin as an output
digitalWrite(SD_CS, HIGH); // Turn off the SD card! (wait for configuration)
Serial.println("inizializzazione SD card......Attendere......");
sd_init();
}
void sd_init()
{
err_sd=0;
if (!card.init(SPI_FULL_SPEED, SD_CS)) err_sd=1;
if (!volume.init(&card)) err_sd=1;
if (!root.openRoot(&volume)) err_sd=1;
if (err_sd==0) Serial.println("inizializzazione SD completata.");
else Serial.println("inizializzazione SD fallita.");
}
void log_write() // esempio di scrittura
{
//scrittura su file txt sd .... eventi
file.open(&root, "datalog.txt", O_APPEND | O_WRITE);
String data= giorno + "/" + mese + "/" + anno + " " + ore + ":" + minuti + ":" + secondi;
file.println(data+ " >> " + log_riga);
delay(1);
file.close();
}
cosi' a me funziona con mega+ethernet shield+sd a bordo
ciao
grazie del codice intanto
per caso per farlo funzionare te hai cambiato qualcosa dentro ad SPI.h ?
Sai che non mi ricordo .... sono un po' di mesi che ho questo, ricordo che la vecchia SPI cambiava solo da cosi'
----------0022--------
#include <stdio.h>
#include <WProgram.h>
#include <avr/pgmspace.h>
----------1.0----------
#include <stdio.h>
#include <Arduino.h>
#include <avr/pgmspace.h>
però se l'ho trovata nel download già modificato o l'ho fatto io non me lo ricordo ehehehhee, se così non fosse ti darebbe errore nella compilazione, quindi dovrebbe già essere modificata la lib che scarichi nella 1.0 ....
Ve beh, poi provo e ti so dire 
Il problema sta tutto nella piedinatura del seeeduino mega 1280, non è la stessa del arduino mega..
sono riuscito a scrivere la Sd usando quel micro ma non ricordo il pin che usavo per il CS della SD card.. se mi dovesse tornare in mente lo scrivo, ricordo che era tra il 48 ed il 58 ma non mi ricordo proprio quale di preciso 
Scusate se l'ho scritto solo ora..
credo che per il CS puoi usare un pin qualsiasi, lo devi solo mettere ad HIGH
Non credo .. ho provato a farlo manualmente ovvero mettevo a massa oppure a +3.3 ma non funzionava comunque..