Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur le langage C !

Modérateur : Jérémy

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#81 Message par Jérémy » ven. 23 déc. 2016 14:44 lien vers la Data-Sheet : Cliquez ici

Photo de ma plaque test

IMG_0095.JPG


Schéma modifié et corrigé ( merci DAUDET78) mais pas encore testé ( faute de composants à la maison) :

test.png


Modification Hard:
Sans titre.jpg
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#82 Message par Jérémy » mer. 1 févr. 2017 15:37 lien vers la Data-Sheet : Cliquez ici

Bonjour à tous,

Je continue toujours sur mon module !

Premier point la partie Hard est bonne , plus de reset au démarrage, je pense maintenant qu'il y avait un problème HARD mais aussi SOFT ! en tout cas merci à tous !

j'ai donc tout repris depuis zéro, en avançant à tâtons! Pour le moment je n'ai aucun loupé et une liaison à 100% opérationnelle.

Cependant j'entrevois des "améliorations" ou des futurs bogues à venir .

A l'heure actuelle, dans un boucle infinie , je demande à mon module ( toutes les 3 secondes) si il a un message "lu" ou "non lu" . cette demande m'affiche tous les messages "lus" et "non lus" si il y en a bien sur .

Mais je trouve cela pas très optimisé, car il se peut que pendant ces trois secondes je reçoive 2 messages ! et la ,les deux messages seront traités en même temps , et ça , ben c'est pas bon du tout !

Pour palier à ce problème je compte demander à lire seulement le premier message en mémoire ! ( en imaginant que j'en reçoive deux à la suite), je le traite puis je l'efface !

Ma question est : est ce que le second message va venir en emplacement mémoire 1 après l'effacement du #1, ou restera-t-il en #2 ?

J'ouvre la DS du module en page 98 , mais mon anglais me joue des tours et la traduction google n'ai pas claire du tout sur le comportement d'un effacement d'un message .

Une âme charitable pourrait-elle me dire la quelle est la bonne solution a adopté pour ce cas de figure , il y à 5 options possibles ?

Merci à vous !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#83 Message par Jérémy » dim. 5 févr. 2017 15:09 lien vers la Data-Sheet : Cliquez ici

Bonjour à tous,

Je me permet un petit UP sur ma question d'anglais ! oops ( ou de compréhension )

Sinon je vais partir sur un test pour savoir si un message aussi en #2 , voir aussi en #3 !

Merci !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#84 Message par Jérémy » ven. 10 févr. 2017 09:33 lien vers la Data-Sheet : Cliquez ici

Bonjour à tous,

Une âme charitable pourrait-elle me dire la quelle est la bonne solution a adopté pour ce cas de figure , il y à 5 options possibles ?

Après moultes Tests , sans résultats probants , j'ai donc opté pour le test des trois messages .

Si j'ai un message en #1 je le traite -> je sors . Si je n'en ai pas, je vais regarder en #2 , si y'en a un en #2 je le traite et je sors , si y'en a pas je vais regarder en #3 , je le traite et j'efface tout les messages !

Ceci est juste un pare-feu, car la personne est censée attendre la réponse du GSM à chaque fois !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#85 Message par Jérémy » sam. 11 févr. 2017 18:00 lien vers la Data-Sheet : Cliquez ici

Bonjour à tous,

Mon tout dernier soucis avec ce module GSM !!

Il s'agit d'une énigme pour moi .
Je calcul la valeur de mon chrono en seconde ! jusque la rien de particulier !

pour afficher le temps restant je dois donc convertir ces secondes en string formaté comme suit : jj hh mm ss . rien de bizarre !

Pour ce faire j'utilise cette portion de code ! que je vous ai simplifié : je force la valeur Chrono à 86466 , ce qui correspond à
1 jour , 0h , 1 minute et 6 secondes

On s'attend donc à ce que j'obtiens : 1j 0h 1m 6s

Code : Tout sélectionner


                     Chrono 
= 86466 ;

                    LongWordToStr (Chrono, temp);
                    strConstRamCpy(T_message+57, temp); //

                     strConstRamCpy(T_message+67, "\r\n..j ..h ..m ..s");
                     // Calcul des Jours restants
                     ByteToStr ( (unsigned char)(Chrono/86400), temp);
                     T_message[69] = temp[1];
                     T_message[70] = temp[2];
                     // Calcul des Heures restantes
                     ByteToStr ( (unsigned char)((Chrono%86400)/3600), temp);
                     T_message[73] = temp[1];
                     T_message[74] = temp[2];
                     // Calcul des Minutes restantes
                     ByteToStr ((unsigned char)(((Chrono%84600)%3600)/60), temp);
                     T_message[77] = temp[1];
                     T_message[78] = temp[2];
                     // Calcul des Secondes restantes
                     ByteToStr ((unsigned char)(((Chrono%84600)%3600)%60), temp);
                     T_message[81] = temp[1];
                     T_message[82] = temp[2]; 



A votre avis quel est le résultat ???


► Afficher le résultat



Je suppute un probléme de conversion encore
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#86 Message par Jérémy » sam. 11 févr. 2017 19:20 lien vers la Data-Sheet : Cliquez ici

Quel boulet encore !!!!

                     Chrono = 86466 ;

                    LongWordToStr (Chrono, temp);
                    strConstRamCpy(T_message+57, temp); //

                     strConstRamCpy(T_message+67, "\r\n..j ..h ..m ..s");
                     // Calcul des Jours restants
                     ByteToStr ( (unsigned char)(Chrono/86400), temp);
                     T_message[69] = temp[1];
                     T_message[70] = temp[2];
                     // Calcul des Heures restantes
                     ByteToStr ( (unsigned char)((Chrono%86400)/3600), temp);
                     T_message[73] = temp[1];
                     T_message[74] = temp[2];
                     // Calcul des Minutes restantes
                     ByteToStr ((unsigned char)(((Chrono%84600)%3600)/60), temp);
                     T_message[77] = temp[1];
                     T_message[78] = temp[2];
                     // Calcul des Secondes restantes
                     ByteToStr ((unsigned char)(((Chrono%84600)%3600)%60), temp);
                     T_message[81] = temp[1];
                     T_message[82] = temp[2];  


Forcement avec les mauvaises valeurs ca ne peut pas fonctionner !

je crois que j'ai fini !!!!!!!

Fiabilité à 100% ( pour le moment) Je ne suis pas très content de ma gestion des réceptions de messages! je pense qu'on peut mieux faire mais bon , ça fait trop de temps que je suis al dessus et je commence à saturer !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Temps-x
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 792
Enregistré en : juillet 2016
Localisation : Terre

#87 Message par Temps-x » dim. 12 févr. 2017 02:37 lien vers la Data-Sheet : Cliquez ici

Bonjour Jérémy ,

J'avoue que je comprends pas car : 86400 secondes = 24 heures x 3600 secondes :eek:

D’où vient tes 84600 secondes ? :sifflotte:

A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#88 Message par Jérémy » dim. 12 févr. 2017 07:24 lien vers la Data-Sheet : Cliquez ici

Temps-x a écrit :Source du message D’où vient tes 84600 secondes ?

Justement c'est mon erreur, j'ai jsute fait une faute de frappe en mettant 84600 à la place de 86400 ! Donc le résultat du modulo n'est pas le bon ! et donc le résultat final ne l'ai pas non plus !

J'ai galérer pour le voir !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#89 Message par Jérémy » dim. 12 févr. 2017 08:29 lien vers la Data-Sheet : Cliquez ici

Dernier point noir , je n'arrive pas à afficher des caractères spéciaux genre "à" :mur: :mur: :mur: :mur:
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Module GSM2-Click
Jérémy
Administrateur du site
Administrateur du site
Messages : 2044
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#90 Message par Jérémy » dim. 12 févr. 2017 09:57 lien vers la Data-Sheet : Cliquez ici

Re,

Bon je pense que la c'est bon !! ( mise à part les caractères spéciaux dommage).

Aucun problèmes à signaler après deux jours de tests au moins 1000 SMS envoyer !

je sais que mon code n'est pas optimiser! je ne cherche pas la performance étant donné que mon module n'a qu'a attendre la fin du chrono .

Je vous montre mon code, si quelqu'un à la courage de le regarder , et de trouver un éventuel probléme à venir !

Afin d'aérer mon code j'ai placer les Interruptions dans un fichier Header !

Code : Tout sélectionner

/*

Test du module GSM2 pour http://www.FantasPIC.fr
lien command AT du module M95 : http://www.quectel.com/UploadImage/Downlad/M95_AT_Commands_Manual_V1.2.pdf
Data-Sheet du PIC 16F1847     : http://ww1.microchip.com/downloads/en/DeviceDoc/41453B.pdf

version du 12/02/17

*/

#include "timelib.h"


#define Vert RA2_bit
#define Jaune RA3_bit
#define Orange RA4_bit
#define Rouge RB0_bit
#define Bleu RB6_bit
#define Alim RB5_bit
#define PWRKEY  RB3_bit
#define Envoi_tension RA0_bit

#define T_Off 30       // Temps d'extinction en secondes
#define T_On 60        // Temps de reveil en secondes

//------------------------------------------------------------------------------
// Tables des Réponses attendues
const GSM_OK       = 0;
const GSM_FLECHE   = 1;
const GSM_ERROR    = 2;
const GSM_UNREAD   = 3;

//------------------------------------------------------------------------------
// Tables des reponses SMS possibles
const R_CHRONO = 1;
const R_OUI    = 2;
const R_NON    = 3;
const R_STOP   = 4;
const R_ETAT   = 5;
const R_AIDE   = 6;
const R_REVEIL = 7;

// Tableaux
char T_numero_tel[20];  // tableau pour placer le numéro de téléphone en string format : {"+336********"}
char T_message[200];      // Stockage du SMS à envoyer pendant la composition
char T_Reveil[20];
char T_Chrono[15];
char T_Tension[4];
char T_Signal[4];
char T_GDH[30];         // Tableau de reception de valeurs du Groupe Date Heure (GDH)

// Variables
short ReponseID = -1;
short SMS_ID = 0;

char Valeur, Index_num_tel, Fin_Chrono, Etat_module, Index_chrono, SMS_recu, Signal,Index_GDH, Index_REVEIL, moinsde30 ;
char Heures, Minutes, secondes;
char F_envoi_ok, F_READ, F_CMGS;
char Demande_lancement_chrono,Demande_lancement_reveil, Chrono_lance=0, Emplacement_SMS=0;

unsigned int i, Sablier, Sablier_temp, Chrono_temp;

signed long Chrono = -1;

unsigned long epoch1=0, epoch2=0;

TimeStruct ts1, ts2 ;     // déclaration des structures pour le calcul du temps avec calendrier

#include "Interruptions.h"

//########################   PROTOTYPE DE FONCTION     #########################
void envoi_commande_sans_reponse(char *s1);
void envoi_commande_avec_reponse(char *s1, char);
void envoi_et_composition_SMS(char numero_message);
void strConstRamCpy(char *dest, const char *source);
void analyse_SMS();
void On_M95();
void Off_M95();
void Lecture_T();

//------------------------------------------------------------------------------
// Compose le SMS , puis l'envoie avec fonction de time out et re-envoie
// Param. d'entrée : Le numéro correspondant au message à envoyer
void envoi_et_composition_SMS(char numero_message){

  char Compteur=0, Compteur2=0, Temporaire; // compteur pour time-out et re-envoie

  char temp[30];                // tableau temporaire pour les calculs

  F_envoi_ok = 0;               // RAZ de la variable, que indique que l'envoie c'est bien passé

  T_message[0] = 0;             // On se positionne au début du tableau
  temp[0] = 0;

  //--------------------    séléction et Création du message      -------------------
  switch (numero_message){

         case 1:{
                 strConstRamCpy(T_message , "Valeurs recues:\r\n..h ..m ..s\r\nVoulez-vous le lancer ?");  // On copie en ROM avec un Terminateur de string à la fin
                 T_message[17] = T_CHRONO[0];              // On compléte les "."
                 T_message[18] = T_CHRONO[1];
                 T_message[21] = T_CHRONO[2];
                 T_message[22] = T_CHRONO[3];
                 T_message[25] = T_CHRONO[4];
                 T_message[26] = T_CHRONO[5];
                 break;
                }
         case 2:{
                 strConstRamCpy(T_message, "Le Chrono est déja lancé.\r\nUtilisez le mot \"STOP\" si vous souhaitez l'arreter");
                 break;
                }
         case 3:{
                 strConstRamCpy(T_message, "Erreur, les valeurs ne sont pas correctes\r\nHeures<100\r\nMinutes<60\r\nsecondes<60");
                 break;
                }
         case 4:{
                 strConstRamCpy(T_message, "Le chrono est lancé !");
                 break;
                }
         case 5:{
                 strConstRamCpy(T_message, "Abandon de l'initialisation");
                 break;
                }
         case 6:{
                 strConstRamCpy(T_message, "Erreur, ce mot ne convient pas ici !");
                 break;
                }
         case 7:{
                 strConstRamCpy(T_message, "Arret du chrono");
                 break;
                }
         case 8:{
                  strConstRamCpy(T_message, "Etat du module:\r\nRéseau : ..%\r\nNiveaux Batterie : ..%\r\nChrono lancé : ");

                  // rajoute le signal
                  T_message[26] = T_Signal[1];
                  T_message[27] = T_Signal[2];

                  // rajoute la tension
                  T_message[50] = T_Tension[1];
                  T_message[51] = T_Tension[2];


                  if (Chrono_lance==1){     // Si le Chrono est en cours
                     strConstRamCpy(T_message+70, "Oui\r\nTemps restant :\r\n");

                     if ( (Chrono/86400) >= 1){              // Donc plus de 1 jour restant
                         strConstRamCpy(T_message+92, "..j ");
                         Temporaire = 4;
                         // Calcul des Jours restants
                         ByteToStr ( (unsigned char)(Chrono/86400), temp);
                         T_message[92] = temp[1];
                          T_message[93] = temp[2];
                      }

                     strConstRamCpy(T_message+92+Temporaire, "..h ..m ..s");
                     // Calcul des Heures restantes
                     ByteToStr ( (unsigned char)((Chrono%86400)/3600), temp);
                     T_message[92+Temporaire] = temp[1];
                     T_message[93+Temporaire] = temp[2];
                     // Calcul des Minutes restantes
                     ByteToStr ((unsigned char)(((Chrono%86400)%3600)/60), temp);
                     T_message[96+Temporaire] = temp[1];
                     T_message[97+Temporaire] = temp[2];
                     // Calcul des Secondes restantes
                     ByteToStr ((unsigned char)(((Chrono%86400)%3600)%60), temp);
                     T_message[100+Temporaire] = temp[1];
                     T_message[101+Temporaire] = temp[2];
                   }
                 else{
                     strConstRamCpy(T_message+70 , "Non");
                   }
                   break;
               }
        case 9:{
                 strConstRamCpy(T_message, "LES MOTS CLES SONT:\r\nChrono hh mm ss\r\nStop\r\nOui\r\nNon\r\nEtat");
                 break;
               }
        case 10:{
                 strConstRamCpy(T_message, "Réveil reglé pour le :\r\n..-..-.. a ..:..:..\r\n");
                 // rajoute la date
                 T_message[24] = T_reveil[0];
                 T_message[25] = T_reveil[1];
                 T_message[27] = T_reveil[2];
                 T_message[28] = T_reveil[3];
                 T_message[30] = T_reveil[4];
                 T_message[31] = T_reveil[5];
                 // rajoute l'heure
                 T_message[35] = T_reveil[6];
                 T_message[36] = T_reveil[7];
                 T_message[38] = T_reveil[8];
                 T_message[39] = T_reveil[9];
                 T_message[41] = T_reveil[10];
                 T_message[42] = T_reveil[11];

                 strConstRamCpy(T_message+45, "Voulez-vous le lancer ?");

                 break;
               }
       case 11:{
                 strConstRamCpy(T_message, "La Valeur du réveil est anterieur a l\'heure actuelle\r\n");
                 break;
               }
       case 12:{
                 strConstRamCpy(T_message, "Les valeurs du réveil ne sont pas correctes !\r\n\"Reveil JJ MM AA HH MM SS\"");
                 break;
               }
       case 13:{
                 strConstRamCpy(T_message, "Le Chrono est inférieur a 30 Minutes.\r\nLe module restera actif en permanence.");
                 break;
               }
       case 14:{
                 strConstRamCpy(T_message, "Réglage inférieur a 30 Minutes.\r\nLe module restera actif en permanence.\r\n\r\nLe chrono est lancé !");
                 break;
               }
       case 99:{
                 strConstRamCpy(T_message, "Erreur, mot inconnu!");
                 break;
               }
      case 100:{
                 strConstRamCpy(T_message, "FIN !");
                 break;
               }
    }

   //--------------------   creation de l'en-tete     ------------------------------
  do{
        temp[0] = 0;
        strConstRamCpy(temp , "AT+CMGS=\"............\"");
        for (i=0;i<12;i++)
            temp[9+i] = T_numero_tel[i];  // Je remplis la commande avec le numéro de telephone stocké

        envoi_commande_avec_reponse(temp, GSM_FLECHE );    // Envoi la commande pour envoyer le message

        RCIE_bit = 1;               // Activation des INT Rx UART

  // ------------------       envoi du message        -------------------------------
        UART_Write_Text(T_message);
        UART_Write(0x1A);               // Envoi CTRL + Z comme caractere de fin
        Delay_ms(500);

        while(1){                       // Boucle d'attente de CMGS pour signifier l'envoi du message
            Compteur++;                 // Time out de 5s avant d'essayer de le re-envoyer
            Delay_ms(50);               // Avec 3 tentatives d'envoi

            if (F_CMGS==1){             // receptiopn du Flag pour signaler que l'envoi est bien parti
                F_CMGS = 0;             // RAZ du flag
                F_envoi_ok = 1;         // On leve le drapeau pour sortir de la fonction , RAZ se fait au début de la fonction
                break;
             }
            if ( (ReponseID == GSM_ERROR) || (Compteur > 100) ){        // Au bouit de 5s on sort pour re-envoyer le message
                Compteur = 0;           // RAZ du compteur
                Compteur2++;            // compteur de renvoi de commande
                F_envoi_ok = 0;
                break;
             }
         }
     }while( (Compteur2<3) && (F_envoi_ok==0) );

     RCIE_bit = 0;
}

//------------------------------------------------------------------------------
// Envoi de commande ou donnée avec attente de la réponse
// Param. d'entrée : La commande à executer, et la réponse attendue a cette commande
void envoi_commande_avec_reponse(char *s1, char rspns ){

    char Compteur=0, Compteur2 =0, Bonne_reponse = 0;      // Variables locales

    RCIE_bit = 1;         // Autorise les INT Rx UART

    do{
         // ---- Envoi de la commande
         while(*s1) {
            UART_Write(*s1++);
          }
         UART_Write(0x0D);   // On termine par un CR

        //---- Boucle d'attente de Reponse ou timeout
        while (1){
             Compteur++;              // compteur de time out
             delay_ms(50);
             if (ReponseID == rspns){
                 Bonne_reponse = 1;   // le léve le drapeau pour sortir de la fonction
                 break;               // Je sors de la boucle
              }
             else if ( (ReponseID == GSM_ERROR) || (Compteur>100) ){
                 Compteur = 0;  // RAZ du time out
                 Compteur2++;   // compteur de renvoi de commande
                 Bonne_reponse = 0;
                 break;
              }
         }

     }while ( (Compteur2<3) && (Bonne_reponse==0) ); // Je sors apres 3 tentatives d'envoi ou j'ai recu la Reponse attendue

   RCIE_bit = 0;
}

//###########################################################################################################################
//##################################         TRAITEMENT DES REPONSES RECUES          ########################################
//  Si il y a un message non traité , je vais le retraiter ! lu ou non lu ;
void analyse_SMS(){

  F_READ = 0;          // RAZ du flag

  for (i=0;i<6;i++){
      Rouge = ~Rouge;
      delay_ms(100);
   }

  //###############    "Chrono"    ##############
  if (SMS_ID == R_CHRONO){
      SMS_ID = SMS_recu = 0;   // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS

      //--- récupération et calcul du Chrono en seconde
      Heures   = ((T_Chrono[0]-48)*10) + (T_Chrono[1]-48);
      Minutes  = ((T_Chrono[2]-48)*10) + (T_Chrono[3]-48);
      Secondes = ((T_Chrono[4]-48)*10) + (T_Chrono[5]-48);

      Chrono = ( ((unsigned long)Heures*3600) + (Minutes*60) + Secondes );  // Calcul du temps en secondes ATTENTION AU CAST!!

      if ( (Heures>99) || (Minutes>59) || (Secondes>59) ){  // Si une Valeur est supérieur à la normale
          envoi_et_composition_SMS(3);  // "Erreur, les valeurs ne sont pas correctes"
       }
      else if (Chrono_lance == 1){
         envoi_et_composition_SMS(2);   // "le Chrono est deja lance "
       }
     else{
         envoi_et_composition_SMS(1);  // "Valeurs recues etc....."
          if (F_envoi_ok==1)               // Si le message est bien parti !
              Demande_lancement_chrono=1;      // je l'indique pour attendre le OUI ou NON
          else
              Demande_lancement_chrono
=0;
       }
   }

  //###############    "REVEIL"    ##############
  else if (SMS_ID == R_REVEIL){
      SMS_ID = SMS_recu = 0;   // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS

      // remplissage de la structure GDH
      ts1.ss = (((T_GDH[15])-48)*10)+(((T_GDH[16])-48));
      ts1.mn = (((T_GDH[12])-48)*10)+(((T_GDH[13])-48));
      ts1.hh = (((T_GDH[9])-48)*10)+(((T_GDH[10])-48));
      ts1.md = (((T_GDH[6])-48)*10)+(((T_GDH[7])-48));
      ts1.mo = (((T_GDH[3])-48)*10)+(((T_GDH[4])-48));
      ts1.yy = 2000 + ((((T_GDH[0])-48)*10)+(((T_GDH[1])-48))) ;

      // remplissage de la structure REVEIL
      ts2.ss = (((T_REVEIL[10])-48)*10)+(((T_REVEIL[11])-48)) ;
      ts2.mn = (((T_REVEIL[8])-48)*10)+(((T_REVEIL[9])-48)) ;
      ts2.hh = (((T_REVEIL[6])-48)*10)+(((T_REVEIL[7])-48)) ;
      ts2.md = (((T_REVEIL[0])-48)*10)+(((T_REVEIL[1])-48)) ;
      ts2.mo = (((T_REVEIL[2])-48)*10)+(((T_REVEIL[3])-48)) ;
      ts2.yy = 2000 + ((((T_REVEIL[4])-48)*10)+(((T_REVEIL[5])-48)))  ;

      // calcul du temps
      epoch1 =Time_dateToEpoch(&ts1);
      epoch2 = Time_dateToEpoch(&ts2);
      Chrono = epoch2 - epoch1 ;

      if (Chrono_lance==1){              // Si le Chrono est déjà lancé
         envoi_et_composition_SMS(2);    // "le Chrono est deja lance "
       }
      else if ( epoch2 <= epoch1){       // Le reveil est inferieur à la date actuelle
           envoi_et_composition_SMS(11);
       }
      else if ( (T_REVEIL[2]>49) || ( (T_REVEIL[2]==49)&&(T_REVEIL[3]>50) ) || ( T_REVEIL[0]>51 ) || ( (T_REVEIL[0]==51)&&(T_REVEIL[1]>49) ) || ( T_REVEIL[6]>50 ) || ( (T_REVEIL[6]==50)&&(T_REVEIL[7]>51) ) || ( T_REVEIL[8]>53 ) ||  ( T_REVEIL[10]>53 ) ){
           envoi_et_composition_SMS(12);       // Si une Valeur n'est pas convenable
       }
     else{
         envoi_et_composition_SMS(10);     // "Réveil reglé pour le :\r\n..-..-.. a ..:..:..\r\n"
          if (F_envoi_ok==1)               // Si le message est bien parti !
              Demande_lancement_reveil=1;  // je l'indique pour attendre le OUI ou NON
          else
              Demande_lancement_reveil
=0;
       }
   }

   //###############    "OUI"    ################
  else if (SMS_ID == R_OUI){
       SMS_ID = SMS_recu = 0;   // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS

      if ( (Demande_lancement_chrono==1) || (Demande_lancement_reveil==1) ) {        // Si la demande de lancement à été effectuée
          Demande_lancement_chrono = Demande_lancement_reveil = 0;

          if (Chrono<=30){         // Le Chrono est réglé < 30minutes
              TMR0IE_bit = 0;       // On arrete le Sablier
              Sablier = 0;
              moinsde30 = 1;        // Pas besoin d'indiquer que le Chrono est < 30
              envoi_et_composition_SMS(14);     // "Réglage inférieur a 30 Minutes"
           }
          else{
              moinsde30 = 0;               // A chaque nouveau lancement je RAZ ppour l'indiquer à nouveau
              envoi_et_composition_SMS(4); // "Le Chrono est lancé"
           }

          if (F_envoi_ok==1){          // Si le message est bien parti
              TMR1IE_bit = 1;          // je lance le chrono
              Chrono_lance = 1;        // J'indique que le Chrono est lancé
           }
       }
       else{
           envoi_et_composition_SMS(6);   // "ERREUR, ce mot ne convient pas ici"
       }
   }
   //###############    "NON"    ################
  else if (SMS_ID == R_NON){
      SMS_ID = SMS_recu = 0;   // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS

      if ( (Demande_lancement_chrono==1) || (Demande_lancement_reveil==1) ){
         Demande_lancement_chrono = Demande_lancement_reveil = 0;
         envoi_et_composition_SMS(5);     // "Abandon de l'initialisation"
       }
      else{
           envoi_et_composition_SMS(6);   // "ERREUR, ce mot ne convient pas ici"
       }
   }
   //###############    "STOP"    ################
  else if (SMS_ID == R_STOP){
       SMS_ID = SMS_recu = 0;      // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS

      if (Chrono_lance==1){        // Si le Chrono est lancé
          TMR1IE_bit = 0;          // j'arrete le chrono
          Chrono_lance = 0;        // J'indique que le Chrono est arreté
          Vert = 0;
          envoi_et_composition_SMS(7); // "Arret du Chrono"
       }
       else{
           envoi_et_composition_SMS(6);   // "ERREUR, ce mot ne convient pas ici"
       }
   }
   //###############    "ETAT"    ################
  else if (SMS_ID == R_ETAT){
       SMS_ID = SMS_recu = 0;   // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS

       envoi_commande_avec_reponse("AT+CSQ", GSM_OK); // Je demande l'état du réseau
       Signal =  100 - ((((T_Signal[0]-48)*10) + ((T_Signal[1]-48)))*2);
       ByteToStr ( Signal, T_Signal);

       Lecture_T();                  // Je demande la Tension de la batterie

       envoi_et_composition_SMS(8);
   }
   //###############    "AIDE"    ################
  else if (SMS_ID == R_AIDE){
       SMS_ID = SMS_recu = 0;   // Je RAZ tous les flags pour eviter les doubles mots clefs dans le meme SMS
       envoi_et_composition_SMS(9);
   }
   //###########    AUCUN MOT NE CONVIENT    #############
  else{
        envoi_et_composition_SMS(99);   // "Erreur, mot inconnu!"
   }

  if (F_envoi_ok == 1){          // Si la réponse à été envoyé alors on peut l'effacer, sinon on l'efface pas pour la relancer
      F_envoi_ok = 0;
      if (Emplacement_SMS == 1){
         envoi_commande_avec_reponse("AT+CMGR=2", GSM_OK);     // Je demande si j'ai recu un message entre temps
         if (F_READ==1)                                        // Si je trouve "READ" ou "UNREAD" à l'emplacement 3
             envoi_commande_avec_reponse("AT+CMGD=1", GSM_OK); // On efface seulement le premier message
         else
             envoi_commande_avec_reponse
("AT+QMGDA=\"DEL ALL\"", GSM_OK);   // Sinon je les supprimes TOUS
       }
      else if (Emplacement_SMS == 2)
         envoi_commande_avec_reponse("AT+CMGD=2", GSM_OK); // On efface seulement le premier message
      else if (Emplacement_SMS == 3)
         envoi_commande_avec_reponse("AT+QMGDA=\"DEL ALL\"", GSM_OK); // On efface seulement le premier message

      delay_ms(1000);
      Sablier = 0;       // On RAZ le Sablier à la sortie

      for (i=0;i<6;i++){
           Bleu = ~Bleu;   // A supprimer aprés les tets
           delay_ms(100);
       }
   }
}

//##############################################################################
//###########################     MAIN     #####################################
//##############################################################################
void main(){
  ANSELA = 0b00000010;  // RA1 en Analogique pour lecture tension
  ANSELB = 0;
  TRISB  = 0b00000010;  // RB1 en entrée pour UART, RB3 en sortie PWRKEY
  TRISA  = 0b00000010;  // RA1 en entrée pour lecture tension

  Alim = 1;             // Module éteint
  PWRKEY = 0;

  Vert = Jaune = Orange = Rouge = Bleu = 0;
  Etat_module = Valeur = 0;

//------------------------------------------------------------------------------
// Réglages du Timer1 à 10 ms pour le chronometre
  TMR1IE_bit = 0;          // désactiver au départ
  T1CON      = 0b00010001;
  TMR1IF_bit = 0;
  TMR1H      = 0x63;
  TMR1L      = 0xC0;
//------------------------------------------------------------------------------
// Réglages du Timer 0 à 1 ms  pour la tempo On/Off "sablier"
  TMR0IE_bit = 1;    // activer au départ
  OPTION_REG = 0x84; // Presacler 1:32
  TMR0       = 6;    // Offset
  TMR0IF_bit = 0;    // On RAZ le flag
//------------------------------------------------------------------------------
// Réglages de l'interruption sur Reception UART
  GIE_bit  = 1;     // Active toutesl es INT
  PEIE_bit = 1;     // Active les INT peripherique
  RCIE_bit = 0;     // Desactive les Interruptions sur Rx UART

//------------------------------------------------------------------------------
// Configuration du convertisseur analogique/numérique avec reference interne
  // Configuration de l'ADCON0  ------------------------------------
                        // bit 7 non utilisé
                        // CHS<4:0> = choix du canal AN1  = 00001
  ADCON0 = 0b00000101;  // Go/~DONE = ? je met 0 dans le doute
                        // ADON = 1, activation du module AD

  // Configuration de l'ADCON1  --------------------------------------
                        // ADFM = 1, justification à droite
                        // ADCS<2:0>= 001, Fosc/8
  ADCON1 = 0b10010011;  // bit 3 non utilisé
                        // ADNREF = 0, ref- = GND
                        // ADPREF = 11, REF+ = FVR ( reglé sur 2.048V)

  // Configuration de Vref  -----------------------------------------
                         //  FVREN_bit = 1;   // Activation du Vref
                         //  FVRRDY_bit = 1;  // Pret a etre utilisé
                         //  TSEN_bit = 0;
   FVRCON = 0b11000010 ; //  TSRNG_bit = 0;
                         //  CDAFVR0_bit = 0;
                         //  CDAFVR1_bit = 0;
                         //  ADFVR1_bit = 1;  // ADFVR = 0b10
                          // ADFVR0_bit = 0;  // Mise du Vref à 2.048V

//------------------------------------------------------------------------------
  UART1_Init(9600); // Initialisation de l'UART à 9600 bauds
  delay_ms(200);

//------------------------------------------------------------------------------
  On_M95();         // On allume le module

//##############################################################################
//####################### BOUCLE PRINCIPALE     ################################
//##############################################################################
 while(1) {

 //------------     Gestion de l'extinction automatique      ----------------------
   if ((Sablier >= T_On) && ( Etat_module==1) ){     // Test de mise en pause
       Off_M95();
    }
    if ( (Sablier >= T_Off) && (Etat_module==0) ){   // Test de réveil
       On_M95();
    }

    if ( (Chrono<=30) && (Chrono>0) && (moinsde30==0) ){    // Le Chrono approche de la fin < 30minutes

       moinsde30 = 1;   // je leve le drapeau comme quoi j'ai deja envoyer le message moins de 30

       if (Etat_module==0)   // Si il est éteint je l'allume
           On_M95();

       TMR0IE_bit = 0;       // On arrete le Sablier
       Sablier = 0;
       envoi_et_composition_SMS(13);     // "Le Chrono est inférieur à 30 Minutes..."
     }

 //---------------------     Lecture des messages  (Si le module  est allumé )     -------------------------------
    if (Etat_module==1){
      delay_ms(2000);

      envoi_commande_avec_reponse("AT+CMGR=3", GSM_OK); // Je lis le message à l'emplacement 3 de la memoire
      delay_ms(10);
      if (F_READ==1){             // Si je trouve "READ" ou "UNREAD" à l'emplacement 3
          Emplacement_SMS = 3;
          analyse_SMS();          // j'analyse le SMS à  l'emplacement 3
       }
      else{                      // Si je n'ai pas de SMS en #3 alors je regarde en #2
         envoi_commande_avec_reponse("AT+CMGR=2", GSM_OK);
         delay_ms(100);
         if (F_READ==1){             // Si je trouve "READ" ou "UNREAD"
             Emplacement_SMS = 2;
             analyse_SMS();
          }
         else{                   // Si je n'ai pas de SMS en #2 alors je regarde en #1
            envoi_commande_avec_reponse("AT+CMGR=1", GSM_OK);
            delay_ms(100);
            if (F_READ==1){             // Si je trouve "READ" ou "UNREAD"
                Emplacement_SMS = 1;
                analyse_SMS();
             }
          }
       }
    }

 //---------------------     action à executer à la fin du chrono     -------------------------------
    if ( (Fin_Chrono==1) && (Chrono_lance==1) ){   // Fin du chronometre detecté

        for (i=0;i<12;i++){
            Rouge = ~Rouge;       // A supprimer apres les tests
            Bleu = ~Bleu;
            delay_ms(100);
         }
        Vert = 0;                 // A supprimer apres les tests
        
        Fin_Chrono 
= 0;     // RAZ du flag
        TMR1IE_bit = 0;     // J'arrete le chrono
        Chrono_lance = 0;   // J'indique que le Chrono est arreté
        Chrono = -1;        // Je réinitialise le Chrono

        TMR0IE_bit = 1;       // Je relance le Sablier
        Sablier = 0;

        envoi_et_composition_SMS(100); // "FIN !"
     }
 }
}

//##############################################################################
//#######################   FONCTIONS SECONDAIRES    ###########################
//##############################################################################

//------------------------------------------------------------------------
//-------------------   Envoi de commande ou donnée    -------------------
//------------------------------------------------------------------------
// Param. d'entrée : La commande à envoyer
void envoi_commande_sans_reponse(const code char *s1){
   while(*s1) {
    UART_Write(*s1++);
   }
   UART_Write(0x0D);   // On termine par un CR
}

//------------------------------------------------------------------------
//-----------------  Copie le texte depuis ROM vers RAM    ---------------
//------------------------------------------------------------------------
// Param. d'entrée : le tableau où on doit stocker le texte, et la chaine de caracteres à stocker
void strConstRamCpy(char *dest, const char *source){
  while(*source)
       *(dest++) = *(source++) ;
  *dest = 0 ;    // Rajout du terminateur
}

//------------------------------------------------------------------------
//-----------------    ACTIVATION DU MODULE     --------------------------
//------------------------------------------------------------------------
void On_M95(){
   Alim = 0;               // Activation de l'alimentation du module par MOSFET
   Delay_ms(500);          // Stabilisation de la tension

   PWRKEY = 0;             // Mise à zéro
   Delay_ms(3000);         // Maintenir à 0 pendant plus de 2S
   PWRKEY = 1;             // Allume le module
   Delay_ms(100);

   // Test du baud rate
   RCIE_bit = 1;           // Autorise les INT UART
   do{
     envoi_commande_sans_reponse("AT"); // On envoi la commande "AT" pour obtenir la réponse "OK" et verifier la com
     Delay_ms(100);                     // Laisse le temps de recevoir la réponse
   } while (ReponseID != GSM_OK);
   RCIE_bit = 0;                  // Coupe Les INT UART

   Delay_ms(8000);                // Attendre pour que le réseau GSM se configure, 8 secondes.

   // RAZ des variables
   F_READ = F_CMGS = F_envoi_ok = SMS_recu = Valeur = 0;

   // Parametrage du module
   envoi_commande_avec_reponse("ATE0", GSM_OK);                 // echo sur Off
   envoi_commande_avec_reponse("AT+CMGF=1", GSM_OK);            // Mode "TEXTE"
   envoi_commande_avec_reponse("AT+QMGDA=\"DEL ALL\"", GSM_OK); // On efface tout les messages

   // Allume la LED rouge pour signifier l'initialisation c'est bien passéee et finie
   for (i=0;i<6;i++){
       Rouge = ~Rouge;   // A supprimer apres tests
       Delay_ms(500);
    }

   Etat_module = 1;               // On signale que le module est allumé
   Sablier = 0;
}

//------------------------------------------------------------------------
//-----------------    EXTINCTION DU MODULE     --------------------------
//------------------------------------------------------------------------
void Off_M95(){
   envoi_commande_sans_reponse("AT+QPOWD=1");   // On arrete le module proprement
   Delay_ms(100);

   RCIE_bit = 0;      // Coupe Les INT UART
   Alim = 1;          // On eteint l'alim du module avec le MOSFET
   Etat_module = 0;   // On indique que le module est éteint
   Sablier = 0;       // On RAZ le Sablier
}

//------------------------------------------------------------------------
//-----------------   LECTURE DE LA TENSION     --------------------------
//------------------------------------------------------------------------
void Lecture_T(){
    int Tension = 0;    // Variable locale

    Envoi_tension = 1;  // Alumage du pont diviseur (PIN RA0)
    delay_ms(200);      // Stabilisation de la Tension sur la PIN

         //-----    Moyenne sur 8 valeurs     ------
         for (i=; i<; i++){
             ADCON0.B1 = 1;     // On démarre la conversion
             while (ADCON0.B1); // J'attend que le bit soit effacé à la fin de la conversion
             Tension += ( (ADRESH<<8) + (ADRESL) ); // j'enregistre et je convertis la Valeur des registres
             delay_ms(1);
           }
          Tension >>= 3;                 // On divise par 8 pour obtenir la moyenne

    Tension = (((Tension-830)*100)/193); // Mise à l'echelle de 1023 à 830 en pourcentage
    ByteToStr(Tension, T_Tension);       // On place la valeur dans le tableau pour l'envoyer par SMS

    Envoi_tension = 0;  // Exctinction du pont diviseur
}


Pour les Interruptions, c'est long mais simple, il s'agit d'une machine d'état !

Code : Tout sélectionner

//##############################################################################
// Lecture des données dans le buffer UART par INT
void interrupt(){
char tmp;

//----------------     TIMER 1 interruption toute les 10 ms   -----------------
  if ((TMR1IF_bit) && (TMR1IE_bit)) {
      TMR1IF_bit = 0;       // RAZ Flag
      TMR1H      = 0x63;    // Offset
      TMR1L      = 0xC0;

      Chrono_temp++;        // Incrementation toutes les 10ms

      if (Chrono_temp >= 100){
          Chrono_temp = 0;
          Vert = ~Vert;
          Chrono--;
           if (Chrono==0)
               Fin_Chrono = 1;
        }
   }

//--------     TIMER 0 interruption toute les 1ms pour sablier     ------------
  if ((TMR0IF_bit) && (TMR0IE_bit)) {
      TMR0IF_bit = 0;            // RAZ Flag
      TMR0       = 6;            // Offset

      Sablier_temp++;            // Incrementation toutes les 1ms

      if (Sablier_temp >= 1000){
         Jaune = ~Jaune;
         Sablier_temp = 0;       // 1000 ms écoulé
         Sablier++;              // j'incremente le Sablier Seconde
       }
   }

//-----------------------          UART        -----------------------------
  if (RCIF_bit == 1) {      // Si INT UART détecté

    tmp = UART_Read();      // On récupere et stock la donnée

    switch (Valeur) {
      case  0: {
                ReponseID = -1;                // RAZ de la réponse

                if ( (tmp == 'O') || (tmp == 'o') )// "OK" ou "OUI"
                  Valeur = 1;
                if ( (tmp == 'N') || (tmp == 'n') )// "NON"
                  Valeur = 6;
                if (tmp == '>')                    // "> "
                  Valeur = 10;
                if ( (tmp == 'S') || (tmp == 's') )// "STOP"
                  Valeur = 15;
                if ( (tmp == 'C') || (tmp == 'c') )// "CMGS"  ou "Chrono" ou "CSQ"
                  Valeur = 20;
                if ( (tmp == 'E') || (tmp == 'e') )// "ERROR" ou "ETAT"
                  Valeur = 30;
                if ( (tmp == 'R') || (tmp == 'r') )// "READ" ou "REVEIL"
                  Valeur = 40;
                if ( (tmp == 'A') || (tmp == 'a') )// "AIDE"
                  Valeur = 45;
                if (tmp == '"')                    // " "+33612345678"
                  Valeur = 60;
                if (tmp == ',')                    // " ,"20xxxxxxxxxxx" GDH
                  Valeur = 70;
                break;
               }
      case  1: {
                if (tmp == 'K')                // "OK"
                  Valeur = 2;
                else if ((tmp == 'U') || (tmp == 'u') )  // "OUI"
                  Valeur = 5;
                else
                  Valeur 
= 0;
                break;
               }
      case 2: {
                if (tmp == 13)                // "OK"
                  Valeur = 3;
                else
                  Valeur 
= 0;
                break;
               }
      case 3: {
                if (tmp == 10)               // "OK"
                   ReponseID = GSM_OK;
                Valeur = 0;
                break;
               }
      case  5: {
                if ( ((tmp == 'I') || (tmp == 'i')) && (SMS_recu == 0) ){   // "OUI"
                      SMS_recu = 1;
                      SMS_ID = R_OUI ;
                 }
                Valeur = 0;
                break;
               }
      case  6: {
                if ((tmp == 'O') || (tmp == 'o') )   // "NON"
                  Valeur = 7 ;
                else
                  Valeur 
= 0;
                break;
               }
      case  7: {
                if ( ((tmp == 'N') || (tmp == 'n')) && (SMS_recu == 0) ){   // "NON"
                   SMS_recu = 1;
                   SMS_ID = R_NON ;
                 }
                Valeur = 0;
                break;
               }
      case 10: {
                if (tmp == ' '){
                   ReponseID = GSM_FLECHE;     // "FLECHE"
                 }
                Valeur = 0;
                break;
               }
      case  15: {
                if ((tmp == 'T') || (tmp == 't') )   // "STOP"
                    Valeur = 16;
                else
                    Valeur 
= 0;
                break;
               }
      case  16: {
                if ((tmp == 'O') || (tmp == 'o') )   // "STOP"
                    Valeur = 17;
                else
                    Valeur 
= 0;
                break;
               }
      case  17: {
                if ( ((tmp == 'P') || (tmp == 'p')) && (SMS_recu == 0) ){   // "STOP"
                    SMS_recu = 1;
                    SMS_ID = R_STOP ;
                 }
                Valeur = 0;
                break;
               }
      case 20: {
                if (tmp == 'M')               // "CMGS"  ou "Chrono" ou "CSQ"
                  Valeur = 21;
                else if (tmp == 'S')
                  Valeur = 25;
                else if ((tmp == 'H') || (tmp == 'h') )
                  Valeur = 80;
                else
                  Valeur 
= 0;
                break;
               }
      case 21: {
                if (tmp == 'G')               // "CMGS"
                    Valeur = 22;
                else
                    Valeur 
= 0;
                break;
               }
      case 22: {
                if (tmp == 'S')              // "CMGS"
                    F_CMGS = 1;
                Valeur = 0;
                break;
               }
      case 25: {
                if (tmp == 'Q')        // "CSQ"
                    Valeur = 26;
                else
                    Valeur 
= 0;
                break;
               }
      case 26: {
                if (tmp == ':')       // "CSQ"
                    Valeur = 27;
                else
                    Valeur 
= 0;
                break;
               }
      case 27: {
                if (tmp == ' ')      // "CSQ"
                    Valeur = 28;
                else
                    Valeur 
= 0;
                break;
               }
      case 28: {
                if (tmp >= '0' && tmp <= '9'){  // "CSQ"
                     T_Signal[0] = '0' ;
                     T_Signal[1] = tmp ;
                     Valeur = 29;
                 }
                else
                    Valeur 
= 0;
                break;
               }
      case 29: {
                if (tmp >= '0' && tmp <= '9'){  // "CSQ"
                     T_Signal[0] = T_Signal[1] ;
                     T_Signal[1] = tmp ;
                     T_Signal[2] = 0;           // terminateur de string
                   }
                Valeur = 0;
                break;
               }
      case 30: {
                if (tmp == 'R')              //  "ERROR" ou "ETAT"
                    Valeur = 31;
                else if ((tmp == 'T') || (tmp == 't') )
                    Valeur = 35;
                else
                  Valeur 
= 0;
                break;
               }
      case 31: {
                if (tmp == 'R')              //  "ERROR"
                    Valeur = 32;
                else
                    Valeur 
= 0;
                break;
               }
      case 32: {
                if (tmp == 'O')             //  "ERROR"
                    Valeur = 33;
                else
                    Valeur 
= 0;
                break;
               }
      case 33: {
                if (tmp == 'R'){             //  "ERROR"
                   ReponseID = GSM_ERROR;
                 }
                 Valeur = 0;
                 break;
               }
      case  35: {
                if ((tmp == 'A') || (tmp == 'a') )   // "ETAT"
                    Valeur = 36;
                else
                    Valeur 
= 0;
                break;
               }
      case  36: {
                if ( ((tmp == 'T') || (tmp == 't')) && (SMS_recu == 0) ){   // "ETAT"
                    SMS_recu = 1;
                    SMS_ID = R_ETAT ;
                 }
                Valeur = 0;
                break;
               }
      case 40: {
                if ( (tmp == 'E') || (tmp == 'e') )              //  "READ"  ou "REVEIL"
                    Valeur = 41;
                else
                    Valeur 
= 0;
                break;
               }
      case 41: {
                if (tmp == 'A')              //  "READ"  ou "REVEIL"
                    Valeur = 42;
                else if ((tmp == 'V') || (tmp == 'v') )
                    Valeur = 100;
                else
                    Valeur 
= 0;
                break;
               }
      case 42: {
                if (tmp == 'D'){             //  "READ"
                    F_READ = 1 ;
                    SMS_recu = 0;
                 }
                  Valeur = 0;
                break;
               }
      case  45: {
                if ((tmp == 'I') || (tmp == 'i') )   // "AIDE"
                    Valeur = 46;
                else
                    Valeur 
= 0;
                break;
               }
      case  46: {
                if ((tmp == 'D') || (tmp == 'd') )   // "AIDE"
                    Valeur = 47;
                else
                    Valeur 
= 0;
                break;
               }

      case  47: {
                if ( ((tmp == 'E') || (tmp == 'e')) && (SMS_recu == 0) ){   // "AIDE"
                    SMS_recu = 1;
                    SMS_ID = R_AIDE ;
                 }
                Valeur = 0;
                break;
               }

      case 60 :{
                if (tmp == '+'){
                   Index_num_tel = 0;
                   T_numero_tel[Index_num_tel] = tmp;
                   Index_num_tel++;
                   Valeur = 61;
                 }
                else
                   Valeur 
= 0;
                break;
               }
      case 61 :{
                if (tmp >= '0' && tmp <= '9'){
                   T_numero_tel[Index_num_tel] = tmp;
                   Index_num_tel ++;
                 }
                else if (tmp == '"'){                      // si on retrouve des guillemets
                   T_numero_tel[Index_num_tel] = 0;   // Place un terminateur de string à la fin
                   Valeur = 0;
                 }
                else{
                   T_numero_tel[0] = 0;
                   Index_num_tel = 0;
                   Valeur = 0;
                 }
                break;
               }
      case  70: {
                if (tmp == '"')   // "GDH"
                    Valeur = 71;
                else
                    Valeur 
= 0;
                break;
               }
      case  71: {
                if (tmp == '2')   // "GDH"
                    Valeur = 72;
                else
                    Valeur 
= 0;
                break;
               }
      case  72: {
                if (tmp == '0'){   // "GDH"
                    Valeur = 73;
                    Index_GDH = 0;
                 }
                else
                    Valeur 
= 0;
                break;
               }
      case  73: {
                if ( (tmp != '+') && (Index_GDH<17) )      // "GDH"    sécurité avec (Index_GDH<17)
                  {
                    T_GDH[Index_GDH] = tmp;
                    Index_GDH++;
                  }
                else
                  
{
                    T_GDH[Index_GDH] = 0;   // Je termine le Gdh par un "NULL" terminateur
                    Index_GDH = 0;
                    Valeur = 0;
                  }
                break;
               }
      case 80: {
                  if ( (tmp == 'R') || (tmp == 'r') )    //  "CHRONO"
                    Valeur = 81;
                  else
                    Valeur 
= 0;
                  break;
                 }
      case 81: {
                  if ( (tmp == 'O') || (tmp == 'o') )    //  "CHRONO"
                    Valeur = 82;
                  else
                    Valeur 
= 0;
                  break;
                 }
      case 82: {
                  if ( (tmp == 'N') || (tmp == 'n') )    //  "CHRONO"
                    Valeur = 83;
                  else
                    Valeur 
= 0;
                  break;
                 }
      case 83: {
                  if ( (tmp == 'O') || (tmp == 'o') )    //  "CHRONO"
                    Valeur = 84;
                  else
                    Valeur 
= 0;
                  break;
                 }
      case 84: {
                  if (tmp == ' ')                      //  "CHRONO"
                     Valeur = 85;
                  else
                    Valeur 
= 0;
                  break;
               }
      case  85: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "CHRONO"
                    T_Chrono[0] = tmp;
                    Valeur = 86;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  86: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "CHRONO"
                    T_Chrono[1] = tmp;
                    Valeur = 87;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  87: {
                if (tmp == ' ')         // "CHRONO"
                    Valeur = 88;
                else
                  Valeur 
= 0;
                break;
               }
      case  88: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "CHRONO"
                    T_Chrono[2] = tmp;
                    Valeur = 89;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  89: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "CHRONO"
                    T_Chrono[3] = tmp;
                    Valeur = 90;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  90: {
                if (tmp == ' ')         // "CHRONO"
                    Valeur = 91;
                else
                  Valeur 
= 0;
                break;
               }
      case  91: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "CHRONO"
                    T_Chrono[4] = tmp;
                    Valeur = 92;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  92: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "CHRONO"
                    T_Chrono[5] = tmp;
                    if (SMS_recu ==0){
                        SMS_recu = 1;
                        SMS_ID = R_CHRONO ;
                     }
                 }
                Valeur = 0;
                break;
               }

      case  100: {
                if ((tmp == 'E') || (tmp == 'e') )   // "REVEIL"
                  Valeur = 101 ;
                else
                  Valeur 
= 0;
                break;
               }
      case  101: {
                if ((tmp == 'I') || (tmp == 'i') )   // "REVEIL"
                  Valeur = 102 ;
                else
                  Valeur 
= 0;
                break;
               }
      case  102: {
                if ((tmp == 'L') || (tmp == 'l') )   // "REVEIL"
                  Valeur = 103 ;
                else
                  Valeur 
= 0;
                break;
               }
      case  103: {
                if (tmp == ' '){   // "REVEIL"
                  Index_REVEIL = 0;
                  Valeur = 104 ;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  104: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[0] = tmp;
                    Valeur = 105;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  105: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[1] = tmp;
                    Valeur = 106;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  106: {
                if (tmp == ' ')         // "REVEIL"
                    Valeur = 107;
                else
                  Valeur 
= 0;
                break;
               }
      case  107: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[2] = tmp;
                    Valeur = 108;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  108: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[3] = tmp;
                    Valeur = 109;
                 }
                else
                  Valeur 
= 0;
                break;
               }
      case  109: {
                if (tmp == ' ')         // "REVEIL"
                    Valeur = 110;
                else
                  Valeur 
= 0;
                break;
               }
     case  110: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[4] = tmp;
                    Valeur = 111;
                 }
                else
                  Valeur 
= 0;
                break;
               }
     case  111: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[5] = tmp;
                    Valeur = 112;
                 }
                else
                  Valeur 
= 0;
                break;
               }
     case  112: {
                if (tmp == ' ')         // "REVEIL"
                    Valeur = 113;
                else
                  Valeur 
= 0;
                break;
               }
     case  113: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[6] = tmp;
                    Valeur = 114;
                 }
                else
                  Valeur 
= 0;
                break;
               }
     case  114: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[7] = tmp;
                    Valeur = 115;
                 }
                else
                  Valeur 
= 0;
                break;
               }
     case  115: {
                if (tmp == ' ')         // "REVEIL"
                    Valeur = 116;
                else
                  Valeur 
= 0;
                break;
               }
     case  116: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[8] = tmp;
                    Valeur = 117;
                 }
                else
                  Valeur 
= 0;
                break;
               }
     case  117: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[9] = tmp;
                    Valeur = 118;
                 }
                else
                  Valeur 
= 0;
                break;
               }
     case  118: {
                if (tmp == ' ')         // "REVEIL"
                    Valeur = 119;
                else
                  Valeur 
= 0;
                break;
               }
     case  119: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[10] = tmp;
                    Valeur = 120;
                 }
                else
                  Valeur 
= 0;
                break;
               }
     case  120: {
                if ( (tmp >= '0') && (tmp <= '9') ){   // "REVEIL"
                    T_Reveil[11] = tmp;
                       if (SMS_recu ==0){
                           SMS_recu = 1;
                           SMS_ID = R_REVEIL ;
                        }
                 }
                Valeur = 0;
                break;
               }
      default: {
                Valeur = 0;
               }
    }
 }
}


Et pour le calcul du temps : rajouter la librairie "time" :

Code : Tout sélectionner



// some constants
#define Time_secInMn    60                      // seconds per minute
#define Time_secInH     (Time_secInMn * 60)     // seconds per hour
#define Time_secIn24h   (Time_secInH * 24)      // seconds per day

// simple time structure
typedef struct
        
{
        unsigned char   ss ;    // seconds
        unsigned char   mn ;    // minutes
        unsigned char   hh ;    // hours
        unsigned char   md ;    // day in month, from 1 to 31
        unsigned char   wd ;    // day in week, monday=0, tuesday=1, .... sunday=6
        unsigned char   mo ;    // month number, from 1 to 12 (and not from 0 to 11 as with unix C time !)
        unsigned int    yy ;    // year Y2K compliant, from 1892 to 2038
        } TimeStruct ;


// private variables
extern  long            Time_jd1970 ;   // 01/01/1970 julian day number

// public functions
long    Time_dateToEpoch(TimeStruct *ts) ;
void    Time_epochToDate(long e, TimeStruct *ts) ;


// macro definitions
/*
 * compares two dates,
 * return time difference in seconds as a signed long
 * result is positive if t1 is before t2
 * result is null if t1 is the same as t2
 * result is negative if t1 is after t2
 */
#define Time_dateDiff(t1, t2) (Time_dateToEpoch(t2) - Time_dateToEpoch(t1))


Sinon voici le fichier complet :
GSM2_Proto.rar


Il me reste le Tuto je pense !
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
C'est en faisant des erreurs, que l'on apprend le mieux !!!


Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 13 invités