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

Fusion de Programme pour Mémorisation SD



  1. #1
    invitee949d373

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

    -----

  2. #2
    invitee949d373

    Re : Fusion de Programme pour Mémorisation SD

    Personne n'a de piste pour savoir comment fusionner nos deux programmes pour les faire fonctionner ensemble ?

  3. #3
    Bluedeep

    Re : Fusion de Programme pour Mémorisation SD

    Bonjour
    Dans la mesure où tu n'indiques pas les difficultés rencontrées pour "fusionner" les deux programmes, il est plutôt difficile de te donner une piste. (après avoir lu en diagonale, si on excepte le conflit de nom sur les fonctions setup & loop - assez facile à résoudre - , je ne vois pas bien ce qui pose problème, mais je maitrise mal les problèmes d'IT embarqué).
    Dernière modification par Bluedeep ; 26/05/2014 à 16h58.

Discussions similaires

  1. Vitesse pour la fusion nucléaire
    Par astro2011 dans le forum Physique
    Réponses: 4
    Dernier message: 24/10/2011, 12h08
  2. materiaux pour sel en fusion
    Par Eric DUPONT dans le forum Technologies
    Réponses: 14
    Dernier message: 21/04/2011, 21h33
  3. [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
Dans la rubrique Tech de Futura, découvrez nos comparatifs produits sur l'informatique et les technologies : imprimantes laser couleur, casques audio, chaises gamer...