Fusion de Programme pour Mémorisation SD
Répondre à la discussion
Affichage des résultats 1 à 2 sur 2

Fusion de Programme pour Mémorisation SD



  1. #1
    Szigetzy

    Fusion de Programme pour Mémorisation SD


    ------

    Bonjour,
    Nous devons réaliser un projet de mémorisation SD, cependant quand nous souhaitons combiner nos deux programmes il est impossible de les faire fonctionner ensemble.

    Le 1er programme permet Gérer les informations reçus depuis un ordinateur, le second programme doit récupérer et mémoriser sur la carte SD les données en provenance du tableau du 1er programme.

    Les deux programmes fonctionnent individuellement.
    Notre soucis est donc que l'on n'arrive pas intégrer le programme 2 dans le programme 1 afin de pouvoir effectuer la fonction mémorisation dans le 1er programme.
    Nous utilisons Mpide qui est comme Arduino.


    PROGRAMME 1 :

    Code:
     
    int octet_dispo=0;                      // présence d'un octet à stocker ou non
    int nb_octet=-1;                        // variable comptant les octets entrants
    int nb_trame=0;                         // variable comptant le nombre de trames reçues
    int nb_trame_memorisee;                 // variable comptant le nombre de trames mémorisée
    byte incByte;                           // variable de stockage des données entrantes
    byte trame[48];                         // création d'un tableau de 49 colonnes
    byte i;
    boolean M;                              // variable indiquant le mode de fonctionnement mémorisation
    boolean R;                              // variable indiquant le mode de fonctionnement restitution
    boolean A;                              // variable indiquant le mode de fonctionnement arrêt
    
    void setup() 
    {
      Serial.begin(9600);                   // initialise la communication série
      Serial1.begin(9600);                  
      U2MODE = U2MODE & 0xFFFFFFF5;
      U2MODE = U2MODE | 0x00000002;         // parité paire
      Serial.print("nb_octet");             // afficher le numero d'arrivé de l'octet
      Serial.print("     ");                // afficher un espace
      Serial.println("trame[nb_octet]");    // afficher les octets mémorisés dans le tableau
      M=0;                                  // met M à 0
      R=0;                                  // met R à 0
      A=0;                                  // met A à 0
    }
    
     void lecture ()
      {
       incByte = Serial1.read();                               // lecture du port 0
       octet_dispo=1;                                          // octet près à être stocké
       nb_octet ++;                                            // incrémente la variable nb_octet
       if( (trame[0] == 255 && trame[1] == 250 && trame[2] == 255) || (trame[0] == 255 && trame[1] == 251 && trame[2] == 255) || (trame[0] == 255 && trame[1] == 252 && trame[2] == 255) ) // si les trois premiers octets enregistés dans le tableau sont 255 250 255 ou 255 251 255 ou 255 252 255  
       {
        remise_a_zero_tableau();                               // appel la fonction remise_a_zero_tableau
        nb_octet = 0;                                          // met la variable nb_octet à 0 
       }
      }
    
    
     void ecriture_tableau ()
      { 
       octet_dispo = 0;                      // remise à zéro de octet_dispo
       trame[nb_octet] = incByte;            // la valeur de l'octet entrant est enregistré dans la colonne correspondant à son numéro d'arrivée
       Serial.print(nb_octet);               // afficher le numero d'arrivé de l'octet
       Serial.print("           ");          // afficher un espace
       Serial.println(trame[nb_octet],DEC);  // afficher la valeur de l'octet enregistré dans le tableau 
      }
    
    
     void remise_a_zero_tableau ()
      {
       for ( i=0 ; i<=48 ; i++ )         // compteur de 0 à 48
        {
         trame[i]=0;                     // le tableau est complètement effacé
        }
       nb_octet = -1;                    // remet la variable nb_octet à -1
      }
       
    
    
     void memorisation ()
         
      {
         A=0;                                             // met A à 0
         M=1;                                             // met M à 1
         Serial.print("envoie du caractere M ");          // afficher "envoie du caractere M"                            
         Serial.println();                                // revenir à la ligne
         Serial.println("// debut memorisation // ");     // afficher "// debut memorisation //                                   
         remise_a_zero_tableau();                         // appel la fonction remise_a_zero_tableau
         while(A==0)                                      // tant que A est égal à 0
          {
           if (Serial1.available())                       // si des données entrantes sont présentes
              {
               lecture();                                 // appel de la fonction lecture
              }
                       
           if(octet_dispo == 1)                           // si octet_dispo est égal à 1
              {
               ecriture_tableau();                        // appel de la fonction ecriture_tableau 
              }
                       
           if(nb_octet == 48)                             // si nb_octet est égal à 48 
              {
               nb_trame++;                                // incrémente la variable nb_trame
               nb_trame_memorisee++;
               Serial.print(nb_trame_memorisee);          // afficher le nombre de trame mémorisée
               Serial.println(" trames memorisees");      // afficher " trames méorisées"
               Serial1.print(nb_trame_memorisee);         // envoyer le nombre de trame mémorisée
               Serial.println();                          // revenir à la ligne
               remise_a_zero_tableau();                   // appel de la fonction remise_a_zero_tableau
               Serial.print("// fin de trame ");          // afficher "// fin de trame "
               Serial.print(nb_trame,DEC);                // afficher le nombre de trames reçues dans le serial monitor
               Serial.println(" //");                     // afficher " //"
              }
              
           if(trame[0] == 255 && trame[1] == 251 && trame[2] == 255)   // si les trois premiers octets enregistés dans le tableau sont 255 251 255
              {
               nb_trame_memorisee=0;                       // met nb_trame_memorisee à 0
               arret();                                    // appel de la fonction arret
               Serial1.write('A');                         // envoyer "A"ascii
               Serial.println("// commande arret // ");    // afficher "// commande arret // "
               Serial.println("// fin memorisation // ");  // afficher "// fin memorisation // "
              }
              
           if(trame[0] == 255 && trame[1] == 250 && trame[2] == 255)  // si les trois premiers octets enregistés dans le tableau sont 255 250 255
              {
               nb_trame_memorisee=0;                                 // met nb_trame_memorisee à 0
               restitution();                                        // appel de la fonction restitution
              } 
          }  
      }
         
     
     
     void restitution ()
      {
       A=0;                                         // met A à 0
       R=1;                                         // met R à 1
       Serial.print("envoie du caractere R ");      // afficher "envoie du caractere R"
       Serial1.write('R');                          // envoyer "R"ascii
       Serial.println();                            // revenir à la ligne
       Serial.println("// debut restitution // ");  // afficher "// debut restitution // "
       nb_octet=-1;                                 // remet à -1 de la variable nb_octet 
       remise_a_zero_tableau();                     // appel de la fonction remise_a_zero_tableau
       while(A==0)                                  // tant que A est égal à 0
             {
              if (Serial1.available())              // si des données entrantes sont présentes
                 {
                  lecture();                        // appel de la fonction lecture
                 }
              
              if(octet_dispo == 1)                  // si octet_dispo est égal à 1
                 {
                  ecriture_tableau();               // appel de la fonction ecriture_tableau 
                 }
                          
              if(nb_octet == 48)                    // si nb_octet est égal à 48 
                 {
                  nb_trame++;                       // incrémente la variable nb_trame
                  remise_a_zero_tableau();          // appel de la fonction remise_a_zero_tableau
                  Serial.print("// fin de trame "); // afficher "// fin de trame "
                  Serial.print(nb_trame,DEC);       // afficher le nombre de trames reçues dans le serial monitor
                  Serial.println(" //");            // afficher " //"
                 }
              
              if(trame[0] == 255 && trame[1] == 251 && trame[2] == 255) // si les trois premiers octets enregistés dans le tableau sont 255 251 255
                 {
                  arret();                                   // appel de la fonction arret
                  Serial1.write('A');                        // envoyer "A"ascii
                  Serial.println("// commande arret // ");   // afficher "// commande arret // "
                  Serial.println("// fin restitution // ");  // afficher "// fin restitution // " 
                 }
              
              if(trame[0] == 255 && trame[1] == 252 && trame[2] == 255)  // si les trois premiers octets enregistés dans le tableau sont 255 252 255
                 {
                  memorisation();                                       // appel de la fonction memorisation
                 }
             }
      }
      
    
     void arret ()
     {
       while(A==0)
       {
        M=0;                            // met M à 0
        R=0;                            // met R à 0
        A=1;                            // met A à 1
        nb_octet=-1;                    // remet à -1 la variable nb_octet     
        remise_a_zero_tableau();        // appel la fonction remise_a_zero_tableau
       } 
     }  
    
    
    void loop()
     {
       if (Serial1.available())               // si des données entrantes sont présentes
         
          {
            lecture();                        // appel de la fonction lecture
          }
      
       if(octet_dispo == 1)                   // si octet_dispo est égal à 1
         
          {
            ecriture_tableau();               // appel de la fonction ecriture_tableau 
          }
      
       if(nb_octet == 48)                     // si nb_octet est égal à 49 
         
          {
            remise_a_zero_tableau();          // appel de la fonction remise_a_zero_tableau
            nb_trame++;                       // incrémente la variable nb_trame
            Serial.print("// fin de trame "); // afficher "// fin de trame "
            Serial.print(nb_trame,DEC);       // afficher le nombre de trames reçues dans le serial monitor
            Serial.println(" //");            // afficher " //"
          }
      
       if(trame[0] == 255 && trame[1] == 252 && trame[2] == 255)  // si les trois premiers octets enregistés dans le tableau sont 255 252 255
         
          {
            memorisation();                                       // appel de la fonction memorisation
          }
      
       if(trame[0] == 255 && trame[1] == 250 && trame[2] == 255)  // si les trois premiers octets enregistés dans le tableau sont 255 250 255
         
          {
            restitution();                                        // appel de la fonction restitution
          }
       
       if(trame[0] == 255 && trame[1] == 251 && trame[2] == 255)  // si les trois premiers octets enregistés dans le tableau sont 255 251 255
         
          {
            arret();                                              // appel de la fonction restitution
          }
     }

    PROGRAMME 2 :

    Code:
    #define DATAOUT 11      //MOSI
    #define DATAIN  12      //MISO 
    #define SPICLOCK  13    //sck
    #define SLAVESELECT 10  //ss
    #include <SD.h>
    
    File myFile;
    int Trame[i];
    byte incByte; 
    
    
    void setup() 
    {
      Serial.begin(9600);
      pinMode(DATAOUT, OUTPUT);
      pinMode(DATAIN, INPUT);
      pinMode(SPICLOCK,OUTPUT);
      pinMode(SLAVESELECT,OUTPUT);
      digitalWrite(SLAVESELECT,HIGH); 
      
      
      Serial.print("Initialisation SD card ...");
    
       pinMode(10, OUTPUT);
       
        if (!SD.begin(10)) {
        Serial.println("echec de l'initialisation ");
        return;
      }
      Serial.println("initialisation Ok.");
    }
    
    
    
    void loop()
    {
       
     
    myFile = SD.open("CarteSD.txt", FILE_WRITE);
       
      
         // si le fichier est ouvert, on peut y écrire.
    
         if (myFile)
         {
          Serial.print("Writing to CarteSD.txt...");
          myFile.print("Donnees Stockees");
          myFile.print("    ");
          myFile.println("Octets");
          
          
          for (int i=0; i<=48; i++)
          {
          myFile.print(Trame[i]);    // trame[nb_octet] Tableau de ... ou je viendrais récupérer les Octets
          myFile.print("                    "), myFile.println(i);
          }
          
          myFile.println("Fin de trame");
         
          // Fermuture du fichier:
          myFile.close();
          Serial.println("done.");
    
         
         }
    
        
         else 
         {
           
           
         // si le fichier n'a pas été ouvert, Message erreur:
          Serial.println("error opening CarteSD.txt");
    
         }
       
         // ré-ouvrir le fichier pour la lecture:
         myFile = SD.open("CarteSD.txt");
         if (myFile) 
         {
           Serial.println("CarteSD.txt");
           // lire le fichier jusqu'à ce qu'il n'y ai rien d'autre:
           while (myFile.available()) 
           {
        	Serial.write(myFile.read());
           }
            // fermeture du fichier:
            myFile.close();
         } 
           
        else 
       {
        // si le fichier n'a pas été ouvert, Message erreur:
        Serial.println("error opening CarteSD.txt");
     }
     while(1); // stoppe loop
     
    }

    Merci de l'attention et de l'aide que vous porterez à mon sujet

    -----

  2. #2
    azad

    Re : Fusion de Programme pour Mémorisation SD

    1ere question :Est-ce que les données provenant de l'ordinateur et chargée dans le programme 1 arrivent de façon aléatoire ?
    Si c'est le cas, je verrais bien un fichier créé avec les données du tableau. Lequel fichier serait remis à jour à chaque nouvelle donnée entrante, mise à jour suivie par une remise à zéro du tableau. Mais de toutes façons, cela ne résoudrait pas tout à fait ton problème : comment savoir si la carte SD est à jour ?
    Deuxième cas, les données arrivent par flux et ce flux est interrompu de façon périodique. Pendant cette interruption programme 2 devrait fonctionner parfaitement et la carte SD serait toujours à jour.
    Et enfin, si pendant l'interruption, d'autres données devaient se manifester, il faudrait alors les sauvegarder dans l'ordinateur "source".
    Du coup l'idée devient
    Mettre Programme 1 dans l'ordinateur source et laisser Programme2 gérer la carte SD. Cela permet de ne plus avoir de problèmes qui seraient liés au multi-thread. Quand Programme2 a mis la SD à jour, il interroge Programme1 via le port série.

Discussions similaires

  1. Fusion de Programme pour Mémorisation SD
    Par Szigetzy dans le forum Électronique
    Réponses: 2
    Dernier message: 26/05/2014, 16h55
  2. Vitesse pour la fusion nucléaire
    Par astro2011 dans le forum Physique
    Réponses: 4
    Dernier message: 24/10/2011, 12h08
  3. materiaux pour sel en fusion
    Par Eric DUPONT dans le forum Technologies
    Réponses: 14
    Dernier message: 21/04/2011, 21h33
  4. [Blanc] Mémorisation programme sur lave vaisselle Bauknecht gsf 4862
    Par matheo07 dans le forum Dépannage
    Réponses: 5
    Dernier message: 20/04/2010, 20h57