next topic »

[on:]

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..

[Reply #1 on:]

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

[Reply #2 on:]

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

[Reply #3 on:]

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

[Reply #4 on:]

Ok, domani la scarico a scuola perchè quà a casa ci metto delle ore sennò 
intanto provo ad addentrarmi nei meandri dell'incasinatissima SDfat 

[Reply #5 on:]

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...

Code:

#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 

[Reply #6 on:]

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

[Reply #7 on:]

Ci avevo pensato, infatti avevo inserito

Code:

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..

[Reply #8 on:]

Fatto, la standard SD ora funziona solo su ATmega 328 , sul mega non cè verso che vada...

[Reply #9 on:]

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

[Reply #10 on:]

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ù..

[Reply #11 on:]

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

[Reply #12 on:]

grazie del codice intanto
per caso per farlo funzionare te hai cambiato qualcosa dentro ad SPI.h ?

[Reply #13 on:]

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 ....

[Reply #14 on:]

Ve beh, poi provo e ti so dire