Bibliothèque incompatible ?

bonjour,

voici mon souci,

le programme fonctionne mais bug un moment bien précis ce n'est pas aléatoire donc  je pense un problème d'incompatibilité.
au démarrage chaque info qui arrive via le wire s'enregistre bien sur la carte sd !
mais si entre temps je reçois via le gsm la led s'allume ou s' éteint convenablement mais plus rien ne peut s'écrire sur la carte sd.
en somme une foie la réception via le port softserial la sd.begine(4) n'est pas 1 et myfile n'est pas 1 non plus !!!

je ne comprend pas pourquoi !

merci de votre aide

code: [select]

/*
  sd card read/write

 this example shows how read , write data , sd card file
 the circuit:
 * sd card attached spi bus follows:
 ** mosi - pin 11
 ** miso - pin 12
 ** clk - pin 13
 ** cs - pin 4

 
 */
#include <softwareserial.h>
#include <spi.h>
#include <sd.h>
#include <wire.h>

softwareserial myserial(2, 3);


string smsstorepos = string("");
string msg = string("");
string sntmp = string("");
string snfull = string("");
int smscontentflag = 0;
int ledpin = 10;



file myfile;


void setup() {

  wire.begin(8);                // join i2c bus address #8
  wire.onreceive(receiveevent); // register event

  serial.begin(9600);
  myserial.begin(9600)
  pinmode(ledpin, output );
  digitalwrite( ledpin, low );
 
  delay (500);
  myserial.print("\r");
  delay(1000);
  myserial.println ("at+cpin=xxxx"); // xxxx code pin de la sim
  myserial.write(0x0d);
  /*
  delay (5000);
  myserial.println ("at+cmgs=\"xxxxxxxxxx\""); \\ xxxxxxxx numero appeler.
  myserial.write(0x0d);
  delay (1000);
  myserial.print ("gsm ready");
  myserial.write (0x1a);
  delay (2000);
  myserial.println ("at+cmgd=1");
  myserial.write (0x0d);
  delay (2000); 
  serial.println("started!");
  */
  pinmode(ledpin, output );
  digitalwrite( ledpin, low );




  while (!serial) {
    ; // wait serial port connect. needed native usb port only
   
  }

  serial.print("initializing sd card...");
  if (!sd.begin(4)) {
    serial.println("initialization failed!");
    return;
  }
  serial.println("initialization done.");
  // re-open file reading:
  myfile = sd.open("alarme.csv");
  if (myfile) {
   // read file until there's nothing else in it:
    while (myfile.available()) {
      serial.write(myfile.read());
    }
    // close file:
    myfile.close();
  } else {
    // if file didn't open, print error:
    serial.println("error opening alarme.csv");
  }
}

void loop() {
 
receptiongsm();
wire.onreceive(receiveevent);


     
}

void receiveevent() {
  while (!sd.begin(4)) {
    serial.println("initialization seconde");
    sd.begin(4);
    delay(1000);
    file myfile;
    delay(1000);
    if (myfile) {
      break;
    }

  }
  myfile = sd.open("alarme.csv", file_write);

   
    if (myfile) {
    while ( wire.available()>0) { // loop through last
    char c = wire.read(); // receive byte character
    myfile.print(c);
 
  }
    myfile.println(" ");
    myfile.close();
    serial.println("done.");
  } else {
    // if file didn't open, print error:
    serial.println("error opening alarme.csv");
  }
}


void processsms( string sms ){
 //sms = "on";
  serial.print (sms);
  sms.tolowercase();
  serial.print( "processsms [" );
  serial.print( sms );
  serial.println( "]" );
////////////////////////////////////////////////////////////////////////////////
  if(sms==("\ron")){
    digitalwrite( ledpin, high );
 

    serial.println( "led on" );
    return;
  }
//////////////////////////////////////////////////////////////
  if( sms==("\roff")){
    digitalwrite( ledpin, low );

    serial.println( "led off" );
    return;
  } else {
    myserial.print("at+cmgf=1\r");    //because want send sms in text mode
    delay(1000);
    myserial.print("at+cmgs=\"");
    myserial.print(snfull);
    myserial.print("\"\r");
    delay(1000);
    myserial.print("unknown command: ");
    myserial.print(sms);
    myserial.print("\r");
    delay(1000);
    myserial.write(0x1a);  //equivalent sending ctrl+z     
    return;
  }
}

// fr: demande d'utiliser le mode text pour la gestion des messages
void gprstextmodesms(){
  myserial.println( "at+cmgf=1" );
}

void gprsreadsmsstore( string smsstorepos ){
  // serial.print( "gprsreadsmsstore storepos " );
  // serial.println( smsstorepos );
  myserial.print( "at+cmgr=" );
  myserial.println( smsstorepos );
}


// fr: efface le contenu de la mémoire tampon des messages du gprs shield.
void cleargprsmsg(){
  msg = "";
}

// fr: interprete le message du gprs shield et agit en conséquence
void processgprsmsg() {
  serial.println("");
  serial.print( "gprs message: [" );
  serial.print( msg );
  serial.println( "]" );

  if( msg.indexof( "call ready" ) >= 0 ){
     serial.println( "*** gprs shield registered on mobile network ***" );
     gprstextmodesms();
  }

  // fr: message non sollicité quand un sms arrive
  if( msg.indexof( "+cmti" ) >= 0 ){
     serial.println( "*** sms received ***" );
     // fr: rechercher la position de la virgule dans le message complet (+cmti: "sm",6)
     //     dans l'exemple, le sms est stocké à la position 6
     int ipos = msg.indexof( "," );
     smsstorepos = msg.substring( ipos+1 );
     serial.print( "sms stored @ " );
     serial.println( smsstorepos );

     // en: ask read sms store
     // fr: demande de lecture du stockage sms
     gprsreadsmsstore( smsstorepos );
  }

  // fr: lecture du stockage sms via l'uart (résultat de la requete gprsreadsmsstore)
  if( msg.indexof( "+cmgr:" ) >= 0 ){
    // number of sender
    int snpos = msg.indexof("+3");
    serial.print("sms from: ");
    sntmp = msg.substring(snpos+1);
    snfull = "";
    (int = 0; < 11; i++){
      snfull += sntmp[i];   
    }
    serial.println(snfull);


    // fr: le prochain message contiendra le contenu du sms
    smscontentflag = 1;

    // fr: les ligne suivantes sont essentielle pour ne pas effacer le flag!
    cleargprsmsg();
    return;
  }


  // fr: le message +cmgr précédent indiquait que le message suivant du shield gprs
  //     (ce message) contient le corps du sms
  if( smscontentflag == 1 ){
    serial.println( "*** sms message content ***" );
    serial.println( msg );
    serial.println( "*** end of sms message ***" );
    processsms( msg );
    delsms();
  }

  cleargprsmsg();

  // fr: toujours mettre le flag à 0
  smscontentflag = 0;
}
void delsms() {
  myserial.print("at+cmgd=");
  myserial.println(smsstorepos);
} 


void receptiongsm(){

    char serialinbyte;
    if(serial.available())
    {
       myserial.print((unsigned char)serial.read());
     } 
    else  if(myserial.available())
    {
        char serialinbyte;
        serialinbyte = (unsigned char)myserial.read();
        serial.print( serialinbyte );
        // -------------------------------------------------------------------
        // fr: le programme écoute également les messages issus du gprs shield.
        // fr: si le message se termine par un <cr> alors traiter le message
        if( serialinbyte == 13 ){
          // en: store char message buffer
          // fr: stocké le caractère dans le buffer de message
          processgprsmsg();
         }
         if( serialinbyte == 10 ){
         }
         else {
           msg += string(serialinbyte);
         }
     }
}

 

comment est alimenté votre shield gsm et votre carte sd?

Arduino Forum > International > Français (Moderators: jfs, Snootlab) > Bibliothèque incompatible ?

arduino