[Claudius]

Bonjour,

Comme je ne sais pas exactement ce qu'est une pile

Pas grave, nous sommes tous passés par là: cf. Pile d'exécution

[Jérémy]

Bonjour Claudius,

Merci pour ce lien fort instructif. Je possède 31 levels de piles sur mon PIC . J'ai seulement 3 fonctions ( 4 si on compte l'INT) et 1 header.
Je ne pense pas que je fasse déborder ma pile ; faut y aller quand même . En sachant que je reviens bien a chaque fois , sans trop d'imbrication .

savez-vous si il y à une fonction dans mikroC permettant de vérifier cela ?

[Claudius]

Ok pour les 31 niveaux d'empilement et les 3 + 1 appels...
De plus, les 3 fonctions s'appellent t'elles successivement ou pas ? La routine d'interruption pouvant, par définition, s'exécuter à tout moment sauf disable des INT !

Quel est le PIC avec lequel tu travailles ?

[Jérémy]

C'est un 18F46K22 ( DS mis en lien au dessus de chaque post).

Si tu as le temps de jeter un œil voici mon programme au complet sans aucune optimisation ! en phase de test !

attention ca pîque les yeux

Code : Tout sélectionner

#include        "timelib.h"
/*
 Test du module  GSM2 click
 * Description:
   Ce programme utilise le module GSM Quectel M95 pour envoyer et recevoir des SMS
   Je controle ma carte easy PIC et envoie son état par SMS .

 *configuration:
     MCU:             PIC18F46K22 : http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
     Carte:           EasyPIC7 : http://www.mikroe.com/easypic/
     Oscillateur:     HS 8.0000 MHz, 8.0000 MHz Crystal  PLL disable
     modules ext.:    gsm2 clickick : http://www.mikroe.com/click/gsm2/
                      Quectel M95 : https://www.soselectronic.hu/a_info/resource/c/quectel/M95_ATC_V1.0.pdf
     SW:              mikroC PRO for PIC : http://www.mikroe.com/mikroc/pic/
 * NOTES:
   - Le clignotement de la led rouge "NET" rapide pas de connexion , lentement Connexion
 */
#define PWRKEY RE1_bit

char SMS_a_envoyer[50]={0};  // Tableau de "char"  composant le SMS
char SMS_Recu[50];
char  Composition_numero[50];
char Gdh[50];
char Numero_tel[20];  // tableau pour placer le numéro de téléphone en string format : {"+336********"}
char Val_Jours[4];
char Val_Heures[4];
char Val_Minutes[4];
char Val_Secondes[4];
char Val_Jours_restant[4];
char Val_Heures_restant[4];
char Val_Minutes_restant[4];
char Val_Secondes_restant[4];
char Val_Signal[7];
char Val_diff[12];
char Val_epoch1[12];
char Val_epoch2[12];

unsigned long Chrono=0;

unsigned int i=0;
unsigned char   Heures_restant=0, Minutes_restant=0, Secondes_restant=0, Valeur=0, Heures=0, Minutes=0, Secondes=0;
unsigned char Signal=0, temp=0, Erreur=0 ;
unsigned char Ok=0, Buzzer=0, CMTI=0, SMS_enregistre=0, Fleche=0,reponse_a_envoyer=0;
unsigned char Demande_Lancement=0, Demande_Lancement_Reveil, Lancement=0, Fin_Chrono=0, Flag_Mah=0;

unsigned int Gdh_An, Gdh_Mois, Gdh_Jour ,Gdh_Heure ,Gdh_Minutes ,Gdh_Secondes ;
unsigned int Rev_An ,Rev_Mois ,Rev_Jour ,Rev_Heure ,Rev_Minutes ,Rev_Secondes ;

TimeStruct ts1, ts2 ;
unsigned long epoch1=0, epoch2=0, diff=0;


// -------- boucle d'attente -------------
// Elle permet de mettre le module dans une position connue
void attente(){
     i= Ok = 0;
     while(Ok==0)      // Ici on envoie la commande "AT" tant que le Flag "Ok" n'est pas levé
          {
             i++;
             UART1_Write_Text("AT");
             UART1_Write(13);
             delay_ms(500);
             if (i>25)
                {
                  asm reset;
                }
             else if (i>10)
                {
                  Valeur = SMS_enregistre = Chrono = CMTI = temp = Fleche = reponse_a_envoyer = 0;
                  Demande_Lancement = Demande_Lancement_Reveil = Lancement = 0 ;
                }
           }
     i = Ok = 0;
 }
// -------------- EFFACE le SMS recu ------------------------
void RAZ_SMS_Recu(){
    for (i=0;i<=50;i++){
        SMS_Recu[i] = 0;
     }
    i = 0;
 }

void Composition(){
        Composition_numero[0]=0;
        strcat(Composition_numero, "AT+CMGS=\""); // rajoute la commande d'envoi de message(CMGS) et on ouvre les guillemets
        strcat(Composition_numero, Numero_tel);   // On rajoute le nuémro de tel, Ex: "AT+CMGS=06******xx\""
        strcat(Composition_numero, "\"");         // et on ferme les guillemets
        strcat(Composition_numero, 0);
        UART1_Write_Text(Composition_numero);
        UART1_Write(13);
        delay_ms(200);
     }

//########################     INTERRUPTION     ################################
//  TIMER 0
void interrupt(){

  if ((TMR0IF_bit) && (TMR0IE_bit)) {
      TMR0IF_bit = 0;
      TMR0H         = 0x0B;
      TMR0L         = 0xDC;
      PORTD.B7  = ~PORTD.B7;
      Chrono--;
         if (Chrono==0)
            {
              Fin_Chrono = 1;
            }
  }

// Lecture des données dans le buffer UART par INT
  if (RCIF_bit == 1) {      // Si INT UART détecté

    temp = UART1_Read();      // On récupere et stock la donnée

    switch (Valeur){

           case 0:{
                    if (temp == 'O')
                        Valeur = 1;
                    else if (temp == 'C')
                         Valeur = 20;
                    else if (temp == '"')
                         Valeur = 30;
                    else if (temp == '>')
                         Valeur = 50;
                    else if (temp == 'E')
                         Valeur = 100;
                    else
                        Valeur = 0;
                    break;
                  }
           case 1:{
                    if (temp == 'K')
                        Valeur = 2;
                    else
                        Valeur = 0;
                    break;
                  }
           case 2:{
                    if (temp == 13)
                        Valeur = 3;
                    else
                        Valeur = 0;
                    break;
                  }
           case 3:{
                    if (temp == 10)
                       {
                         Ok = 1;
                         Valeur = 0;
                       }
                     else
                     Valeur = 0;
                    break;
                  }
           case 20:{
                    if (temp == 'M')
                        Valeur = 21;
                    else if (temp == 'S')
                        Valeur = 25;
                    else
                        Valeur = 0;
                    break;
                  }
           case 21:{
                    if (temp == 'T')
                        Valeur = 22;
                    else
                        Valeur = 0;
                    break;
                  }
           case 22:{
                    if (temp == 'I')
                       {
                          CMTI = 1;
                          Valeur = 0;
                        }
                    else
                        Valeur = 0;
                    break;
                  }
           case 25:{
                    if (temp == 'Q')
                          Valeur = 26;
                    else
                        Valeur = 0;
                    break;
                  }
           case 26:{
                    if (temp == ':')
                          Valeur = 27;
                    else
                        Valeur = 0;
                    break;
                  }
           case 27:{
                    if (temp == ' ')
                          Valeur = 28;
                    else
                        Valeur = 0;
                    break;
                  }
           case 28:{
                    if (temp >= '0' && temp <= '9')
                       {
                         Val_Signal[0] = '0' ;
                         Val_Signal[1] = temp ;
                       }
                    Valeur = 29;
                    break;
                  }
           case 29:{
                    if (temp >= '0' && temp <= '9')
                       {
                         Val_Signal[0] = Val_Signal[1] ;
                         Val_Signal[1] = temp ;
                       }

                    Val_Signal[2] = 0;
                    Valeur = 0;
                    break;
                  }
           case 30:{
                    if (temp == '+')
                       {
                          Numero_tel[0] = temp;
                          i = 1;
                          Valeur = 31;
                        }
                     else if (temp == '2')
                          Valeur = 40;
                    else
                        Valeur = 0;
                  };break;
           case 31:{
                     if (temp >= '0' && temp <= '9')
                        {
                          Numero_tel[i] = temp;
                          i++;
                        }
                     else if (temp == '"')
                        {
                          Numero_tel[i] = 0;
                          i = 0;
                          Valeur = 0;
                        }
                      else
                        {
                          Numero_tel[0] = 0;
                          i=0;
                          Valeur = 0;
                        }
                  };break;
           case 40:{
                    if (temp == '0')
                        Valeur = 41;
                    else
                        Valeur = 0;
                    break;
                  }
           case 41:{
                    if (temp == '1')
                       {
                         Gdh[0] = temp;
                         i = 1;
                         Valeur = 42;
                       }
                    else
                        Valeur = 0;

                    break;
                  }
           case 42:{
                     if (temp != '"')
                        {
                          Gdh[i] = temp;
                          i++;
                        }
                     else
                        {
                          Gdh[i] = 0;
                          i = 0;
                          Valeur = 43;
                        }
                     break;
                  }
           case 43:{
                    if (temp == 13)
                        Valeur = 44;
                    else
                        Valeur = 0;
                    break;
                  }
           case 44:{
                    if (temp == 10)
                       {
                         i=0;
                         Valeur = 45;
                       }
                    else
                        Valeur = 0;
                    break;
                  }
           case 45:{
                     if (temp != 13)
                        {
                          SMS_Recu[i] = temp;
                          i++;
                        }
                     else
                        {
                          SMS_Recu[i] = 0;
                          i = 0;
                          Valeur = 0;
                        }
                     break;
                  }
           case 50:{
                    if (temp == ' ')
                       {
                         Fleche = 1;
                         Valeur = 0;
                       }
                     else
                       Valeur = 0;
                    break;
                  }
           case 100:{
                    if (temp == 'R')
                        Valeur = 101;
                    else
                        Valeur = 0;
                    break;
                  }
           case 101:{
                    if (temp == 'R')
                        Valeur = 102;
                    else
                        Valeur = 0;
                    break;
                  }
           case 102:{
                    if (temp == 'O')
                        Valeur = 103;
                    else
                        Valeur = 0;
                    break;
                  }
           case 103:{
                    if (temp == 'R')
                        {
                          Erreur = 1;
                          Valeur = 0;
                        }
                    else
                        Valeur = 0;
                    break;
                  }

           default: valeur = 0;
    }
 }
}
//##############################################################################
//############################     MAIN     ####################################
//##############################################################################
void main(){
  ANSELA = ANSELB = ANSELC = ANSELD = ANSELE = 0; // Tous les PORT en Digital

  SLRCON = 0;      // Set output slew rate on all ports at standard rate

  TRISB = 0XFF ;   // Entrée
  TRISD = 0X00 ;   // Sortie
  TRISE = 0x00 ;   // Sortie
  LATD = 0;        // Mis à zéro des sorties
  LATE = 0;        // Mis à zéro des sorties

//------------------------------------------------------------------------------
// Réglages de l'interruption
  RC1IE_bit = 1;           // INT UART activé
  PEIE_bit  = 1;           // INT péripheriques Activé
  GIE_bit   = 1;           // INT Global activé

//------------------------------------------------------------------------------
// Réglages du Timer 0 pour 1 secondes
  T0CON         = 0x84;
  TMR0H         = 0x0B;
  TMR0L         = 0xDC;
  TMR0IE_bit    = 0;       // TIMER 0 Non activé au départ

//------------------------------------------------------------------------------
//  Activation de l'alim avec la pin PWRKEY
  PWRKEY = 0;             // Mise à zéro
  delay_ms(3000);         // Maintenir à 0 pendant plus de 2S
  PWRKEY = 1;             // Allume le module

//------------------------------------------------------------------------------
  UART1_Init(4800);      // Initialisation de l'UART
  Delay_ms(100);
  Sound_Init(&PORTC, 2);  // Initialisation du Sound
  Delay_ms(100);

//------------------------------------------------------------------------------
// Parametrages du débit
  while(1){
      UART1_Write_Text("AT");   // Reglage des messages de type "texte"
      UART1_Write(13);
      delay_ms(100);
      if ( Ok == 1)
         {
           Ok = 0;
           Valeur = 0;
           break;
         }
    }
 delay_ms(8000); // Configuration du baud-rate , ensuite initilaistaion du module

//------------------------------------------------------------------------------
// Parametrages du module
  while(1){
      UART1_Write_Text("AT+CMGF=1");   // Reglage des messages de type "texte"
      UART1_Write(13);
      delay_ms(100);
      if ( Ok == 1)
         {
           Ok = 0;
           break;
         }
    }

  while(1){
      UART1_Write_Text("ATE0");        // Désactivation de la commande "Echo"
      UART1_Write(13);
      delay_ms(100);
      if ( Ok == 1)
         {
           Ok = 0;
           break;
         }
    }

  while(1){
      UART1_Write_Text("AT+QMGDA=\"DEL ALL\""); // Envoi la commande pour effacer tous les messages
      UART1_Write(13);
      delay_ms(100);
      if ( Ok == 1)
         {
           Ok = 0;
           break;
         }
    }

  while(1){
      UART1_Write_Text("AT");   // Reglage des messages de type "texte"
      UART1_Write(13);
      delay_ms(100);
      if ( Ok == 1)
         {
           Ok = 0;
           break;
         }
    }
//------------------------------------------------------------------------------
// 3 Bips pour signifier l'initialisation c'est bien passéee et finie
 for (i=0;i<=2;i++){
     Sound_Play(2000, 50); // On joue un son
     delay_ms(50);
  }

i = Valeur = Ok = SMS_enregistre = Signal = 0;

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

   if (CMTI)         // On recoit un nouveau message
      {
         attente();
         CMTI = 0;
         UART1_Write_Text("AT+CMGL=\"REC UNREAD\"");  // On demande à le lire
         UART1_Write(13);
         while (Ok!=1);    // Je reste ici pour enregistrer toute mes infos
         Ok = 0;
         attente();
         SMS_enregistre = 1;  // Je signale que j'ai finis de l'enregistré
      }

   if (SMS_enregistre)       // Si il y a eu un nouveau message et que je l'ai enregistré
      {
        SMS_enregistre = 0;

        //----- On efface le message ( tous les messages)
        UART1_Write_Text("AT+QMGDA=\"DEL ALL\"");
        UART1_Write(13);
        attente();

        // ----- On met à jour le Gdh au premier SMS
        if (Flag_Mah==0)
           {
              Flag_Mah = 1;
              Gdh[8]=',';
              UART1_Write_Text("AT+CCLK=\"");
              UART1_Write_Text(Gdh);
              UART1_Write_Text("\"");
              UART1_Write(13);
              attente();
           }

        if ( ((SMS_Recu[0]=='C')||(SMS_Recu[0]=='c')) && ((SMS_Recu[1]=='H')||(SMS_Recu[1]=='h')) && ((SMS_Recu[2]=='R')||(SMS_Recu[2]=='r')) )
           {

                   Heures =  (((SMS_Recu[8])-48)*10)+(((SMS_Recu[9])-48));
                   Val_Heures[0]= SMS_Recu[8] ;
                   Val_Heures[1]= SMS_Recu[9] ;
                   Val_Heures[2]= 0;

                   Minutes =  (((SMS_Recu[12])-48)*10)+(((SMS_Recu[13])-48));
                   Val_Minutes[0]= SMS_Recu[12] ;
                   Val_Minutes[1]= SMS_Recu[13] ;
                   Val_Minutes[2]= 0;

                   Secondes =  (((SMS_Recu[16])-48)*10)+(((SMS_Recu[17])-48)) ;
                   Val_Secondes[0]= SMS_Recu[16] ;
                   Val_Secondes[1]= SMS_Recu[17] ;
                   Val_Secondes[2]= 0;

             if (Lancement == 1)
                {
                   reponse_a_envoyer = 9;
                }
             else if ( (Heures>99) || (Minutes>59) || (Secondes>59) )
                {
                  reponse_a_envoyer = 97;
                }
             else
                {
                  Chrono = (Heures*3600)+(Minutes*60)+Secondes ;
                  Demande_Lancement = 1;
                  reponse_a_envoyer = 1;
                }
           }
        else if ( ((SMS_Recu[0]=='O')||(SMS_Recu[0]=='o')) && ((SMS_Recu[1]=='U')||(SMS_Recu[1]=='u')) && ((SMS_Recu[2]=='I')||(SMS_Recu[2]=='i')) )
           {
              if ( (Demande_Lancement==1) || (Demande_Lancement_Reveil ==1 ) )
                 {
                  Demande_Lancement = 0;
                  Demande_Lancement_Reveil = 0;
                  Lancement = 1;
                  reponse_a_envoyer = 2;
                 }
               else
                 {
                   reponse_a_envoyer = 98;
                 }

           }
        else if ( ((SMS_Recu[0]=='N')||(SMS_Recu[0]=='n')) && ((SMS_Recu[1]=='o')||(SMS_Recu[1]=='O')) && ((SMS_Recu[2]=='N')||(SMS_Recu[2]=='n')) )
           {
              if (Demande_Lancement)
                 {
                    Demande_Lancement = 0;
                    reponse_a_envoyer = 3;
                 }
               else
                 {
                   reponse_a_envoyer = 98;
                 }
           }
        else if ( ((SMS_Recu[0]=='E')||(SMS_Recu[0]=='e')) && ((SMS_Recu[1]=='T')||(SMS_Recu[1]=='t')) && ((SMS_Recu[2]=='A')||(SMS_Recu[2]=='a')) )
           {
              ByteToStr( (Chrono/3600), Val_Heures_restant);
              ByteToStr( ((Chrono%3600)/60), Val_Minutes_restant);
              ByteToStr( ((Chrono%3600)%60), Val_Secondes_restant);

              UART1_Write_Text("AT+CSQ");  // On demande la qualite du reseau
              UART1_Write(13);
              delay_ms(100);
              attente();                   // On attend pour enregistré la valeur

              Signal =  100 - ((((Val_Signal[0]-48)*10) + ((Val_Signal[1]-48)))*2);
              ShortToStr(Signal, Val_Signal);
              reponse_a_envoyer = 4;
           }
        else if ( ((SMS_Recu[0]=='S')||(SMS_Recu[0]=='s')) && ((SMS_Recu[1]=='T')||(SMS_Recu[1]=='t')) && ((SMS_Recu[2]=='O')||(SMS_Recu[2]=='o')) )
           {
              if (Lancement)
                 {
                    Lancement = 0;
                    TMR0IE_bit = 0;
                    Chrono = 0;
                    reponse_a_envoyer = 5;
                 }
               else
                 {
                   reponse_a_envoyer = 98;
                 }
           }
        else if ( ((SMS_Recu[0]=='A')||(SMS_Recu[0]=='a')) && ((SMS_Recu[1]=='I')||(SMS_Recu[1]=='i')) && ((SMS_Recu[2]=='D')||(SMS_Recu[2]=='d')) )
           {
              reponse_a_envoyer = 6;
           }
        else if ( ((SMS_Recu[0]=='R')||(SMS_Recu[0]=='r')) && ((SMS_Recu[1]=='E')||(SMS_Recu[1]=='e')) && ((SMS_Recu[2]=='V')||(SMS_Recu[2]=='v')) )
           {
              ts1.ss = (((Gdh[15])-48)*10)+(((Gdh[16])-48));
              ts1.mn = (((Gdh[12])-48)*10)+(((Gdh[13])-48));
              ts1.hh = (((Gdh[9])-48)*10)+(((Gdh[10])-48));
              ts1.md = (((Gdh[6])-48)*10)+(((Gdh[7])-48));
              ts1.mo = (((Gdh[3])-48)*10)+(((Gdh[4])-48));
              ts1.yy = 2000 + ((((Gdh[0])-48)*10)+(((Gdh[1])-48))) ;

              ts2.ss = (((SMS_Recu[22])-48)*10)+(((SMS_Recu[23])-48)) ;
              ts2.mn = (((SMS_Recu[19])-48)*10)+(((SMS_Recu[20])-48)) ;
              ts2.hh = (((SMS_Recu[16])-48)*10)+(((SMS_Recu[17])-48)) ;
              ts2.md = (((SMS_Recu[13])-48)*10)+(((SMS_Recu[14])-48)) ;
              ts2.mo = (((SMS_Recu[10])-48)*10)+(((SMS_Recu[11])-48)) ;
              ts2.yy = 2000 + ((((SMS_Recu[7])-48)*10)+(((SMS_Recu[8])-48)))  ;

              epoch1 =Time_dateToEpoch(&ts1) ;
              epoch2 = Time_dateToEpoch(&ts2) ;

              diff = epoch2 - epoch1 ;
              
              if (Demande_Lancement_Reveil == 1)
                   reponse_a_envoyer = 9;
              else if ( epoch2 <= epoch1)  // Le reveil est inferieur à la date actuelle
                   reponse_a_envoyer = 10;
              else if ( diff > 604800) // le reveil est supérieur à une semaine
                     reponse_a_envoyer = 11;
              else
                  {
                    Chrono = diff ;

                    ByteToStr((diff/86400), Val_Jours_restant);
                    ByteToStr(((diff%86400)/3600), Val_Heures_restant);
                    ByteToStr((((diff%86400)%3600)/60), Val_Minutes_restant);
                    ByteToStr((((diff%86400)%3600)%60), Val_Secondes_restant);
                    
                    Demande_Lancement_Reveil = 1;
                    reponse_a_envoyer = 7;
                  }

           }
        else if ( ((SMS_Recu[0]=='T')||(SMS_Recu[0]=='t')) && ((SMS_Recu[1]=='E')||(SMS_Recu[1]=='e')) && ((SMS_Recu[2]=='S')||(SMS_Recu[2]=='s')) )
           {
              UART1_Write_Text("AT+CCLK?");
              UART1_Write(13);
              Attente();
              reponse_a_envoyer = 8;
           }
        else
           {
              reponse_a_envoyer = 99;
           }

        RAZ_SMS_Recu();
        Composition();
        delay_ms(200);
       }

   if (Fleche)       // Jattends pour envoyer le message
      {
        Fleche = 0;

        switch (reponse_a_envoyer){  // Suivant la question posée j'affiche la réponse adéquate

               case 1:{
                         UART1_Write_Text("Valeurs recues:\r\n");
                         UART1_Write_Text("h : ");
                         UART1_Write_Text(Val_Minutes);
                         UART1_Write_Text("m : ");
                         UART1_Write_Text(Val_Secondes);
                         UART1_Write_Text("s\r\n\r\n");
                         UART1_Write_Text("Voulez-vous le lancer ?");
                         UART1_Write_Text("\r\n");
                         break;
                       }
               case 2:{
                         TMR0IE_bit = 1; // On lance le chrono
                         UART1_Write_Text("Le chrono est lancé !");
                         break;
                       }
               case 3:{
                         UART1_Write_Text("Abandon de l'initialisation");
                         break;
                       }
               case 4:{
                         UART1_Write_Text("Etat du module:\r\n");
                         UART1_Write_Text("Date: ");
                         UART1_Write(Gdh[6]);
                         UART1_Write(Gdh[7]);
                         UART1_Write_Text("/");
                         UART1_Write(Gdh[3]);
                         UART1_Write(Gdh[4]);
                         UART1_Write_Text("/");
                         UART1_Write(Gdh[0]);
                         UART1_Write(Gdh[1]);
                         UART1_Write_Text("\r\n");

                         UART1_Write_Text("Heure:  ");
                         for (i=9;i<17;i++)
                             {
                               if ( (Gdh[i]<58) && Gdh[i]>47 )
                                  UART1_Write(Gdh[i]);
                                else
                                  UART1_Write_Text(":");
                             }
                         UART1_Write_Text("\r\n");
                         UART1_Write_Text("Force du signal :");
                         UART1_Write_Text(Val_Signal);
                         UART1_Write_Text("%\r\n");

                           if (Lancement==1)
                              {
                                UART1_Write_Text("Lancé : OUI\r\n");
                                UART1_Write_Text("Temps restant :\r\n");
                                UART1_Write_Text(Val_Heures_restant);
                                UART1_Write_Text("h");
                                UART1_Write_Text(Val_Minutes_restant);
                                UART1_Write_Text("m");
                                UART1_Write_Text(Val_Secondes_restant);
                                UART1_Write_Text("s\r\n");
                              }
                           else
                              {
                                UART1_Write_Text("Lancé : NON\r\n");
                              }
                         break;
                       }
               case 5:{
                         UART1_Write_Text("Arret du chrono");
                         break;
                       }
               case 6:{
                         UART1_Write_Text("Les mots clés:\r\nStop: pour arreter le chrono\r\nOui: pour lancer le chrono\r\nNon: pour annuler une demande\r\nEtat: pour connaitre les valeurs\r\nChrono Hxx Mxx Sxx: initialise le chrono");
                         break;
                       }
               case 7:{
                         UART1_Write_Text("Réveil reglé !\r\n");
                         UART1_Write_Text("Allumage dans:\r\n");
                         if ( (diff/86400) > 0)
                            {
                              UART1_Write_Text(Val_Jours_restant);
                              UART1_Write_Text("j");
                            }
                         if ( ((diff%86400)/3600)> 0)
                            {
                              UART1_Write_Text(Val_Heures_restant);
                              UART1_Write_Text("h");
                            }
                         UART1_Write_Text(Val_Minutes_restant);
                         UART1_Write_Text("m");
                         UART1_Write_Text(Val_Secondes_restant);
                         UART1_Write_Text("s\r\n");
                         UART1_Write_Text("Voulez-vous le lancer ?");
                         UART1_Write_Text("\r\n");
                         
                         break;
                       }
               case 8:{
                         UART1_Write_Text("Test\r\n");
                         Gdh[8]=',';
                         UART1_Write_Text(Gdh);
                         UART1_Write_Text("\r\n");
                         break;
                       }
               case 9:{
                         UART1_Write_Text("Le Chrono est déja lancé.\r\n");
                         UART1_Write_Text("Utilisez le mot \"STOP\" pour l'arreter");
                         break;
                       }
               case 10:{
                         UART1_Write_Text("La Valeur du réveil est anterieur a l\'heure actuelle\r\n");
                         break;
                       }
               case 11:{
                         UART1_Write_Text("La date reveil est supérieur a une semaine\r\n");
                         break;
                       }
               case 96:{
                         UART1_Write_Text("Test");
                         break;
                       }
               case 97:{
                         UART1_Write_Text("Erreur, les valeurs ne sont pas correctes\r\nHeures<100\r\nMinutes<60\r\nsecondes<60");
                         break;
                       }
               case 98:{
                         UART1_Write_Text("Erreur, ce mot ne convient pas ici !");
                         break;
                       }
               case 99:{
                         UART1_Write_Text("Erreur, mot inconnu!.\r\n");
                         break;
                       }
           }

        UART1_Write(13);
        UART1_Write(10);
        UART1_Write(0x1A);  // Envoi cu CTRL+Z pour envoyer le message
        attente();
      }

   if (( Fin_Chrono) && (Lancement) )
      {
          Fin_Chrono = 0;
          Lancement = 0;
          Chrono = 0;
          TMR0IE_bit = 0;
          for (i=0;i<=5;i++){
             Sound_Play(2000, 300); // On joue un son
             delay_ms(50);
          }
          Composition();
          UART1_Write_Text("Le Chrono est fini");
          UART1_Write(13);
          UART1_Write(10);
          UART1_Write(0x1A);  // Envoi cu CTRL+Z pour envoyer le message
          attente();
       }

   if (Erreur)             // Si flag Erreur levé
      {
        Erreur = 0;        // RAZ du flag
        i=0;
        while(Ok==0)      // Ici on envoie la commande "AT" tant que le Flag "Ok" n'est pas levé
            {
              i++;
              UART1_Write_Text("AT");
              UART1_Write(13);
              delay_ms(1000);
              if (i==5)        // RAZ des variables et flag
                 {
                  Valeur = SMS_enregistre = Chrono = CMTI = temp = Fleche = reponse_a_envoyer = 0;
                  Demande_Lancement = Lancement = 0 ;
                 }
              if (i>10)
                 asm reset;
            }
        i = 0;
        Ok = 0;          // RAZ flag "Ok"
      }

 }

}

Le header me permet d'utilise la fonction Time_dateToEpoch(&ts1) , qui me permet de connaitre le nombre de secondes s'étant ecoulées depuis le 1 janvier 1970.

[Guest]

tient ici nous avons parlé de la pile viewtopic.php?f=32&t=322

[Jérémy]

Yes maï ,j'ai recherché aussi ce post !

Après lecture de tout ca ( et plus) Je pense donc que ce n'est pas un probléme de débordement de pile !

Mon programme tourne à peu prêt. je testerais au fur et à mesure de mes optimisations.
Toutes vos remarques sur mon code sont le bienvenue !

[Claudius]

Merci pour la réponse.

Sauf erreur de ma part, aucune des fonctions attente(), RAZ_SMS_Recu() et Composition() ne "s'encastre", donc un seul niveau de pile utilisé ;-)
Avec la routine d'interruption, cela fait au maximum 2. Donc très inférieur aux 31 permis.

Maintenant, dans interrupt() (que je trouve un peu longue mais pas de pb au vu des traitements assez simples), préférer l'utilisation du switch() / case aux if ... else if ... else if ... else comme suit.

Code : Tout sélectionner

...
                    if (temp == 'O')
                        Valeur = 1;
                    else if (temp == 'C')
                         Valeur = 20;
                    else if (temp == '"')
                         Valeur = 30;
                    else if (temp == '>')
                         Valeur = 50;
                    else if (temp == 'E')
                         Valeur = 100;
                    else
                        Valeur = 0;
...


pouvant s'écrire

Code : Tout sélectionner

...
                    switch(temp) {
                    case  'O':
                        Valeur = 1;
                        break;
                    case  'C':
                         Valeur = 20;
                         break;
                    case '"':
                         Valeur = 30;
                         break;
                    case '>':
                         Valeur = 50;
                         break;
                    case 'E':
                         Valeur = 100;
                         break;
                    default:
                        Valeur = 0;
                        break;
                    }
...


Plusieurs avantages:
1 - Plus facilement maintenable
2 - Plus rapide à l'exécution car implémenté comme une table + goto (du moins sur les processeurs évolués)

Dernière remarque: Est-ce normal l'appel à Attente(); à la ligne 648 - au lieu de attente() ?

[Jérémy]

Ok merci. pour le switch case je tacherais de m'ne souvenir ua moment de l'optimisation !
Y-a-t-il une valeur disons "générale" pour un switch case plutôt qu'un else if

Pour l'interruption, j'ai pompé le système de machine état sur l'exemple de MikroC . franchement ca fonctionne super bien, en même temps je ne suis qu'a 4800 bauds
J'ai préféré cette méthode a l'extraction de chaine de caractères trop compliqué pour moi , j'ai pas encore assez l'habitude de manipuler tout ça . je m’emmêle les pinceaux.

Dernière remarque: Est-ce normal l'appel à Attente(); à la ligne 648 - au lieu de attente() ?

Non ce n'est pas normal est c'est vraiment bien vu ! même si ce n'est pas tro génant , mais c'est bizarre que le compilo ne me mette pas de message d'erreur sur une fonction qui n'existe pas !

Merci d'avoir jété un oeil

[paulfjujo]

bonjour


j'ai déja eu affaire à ce probleme de fonction sans le ; à la fin
et perdu pas mal d'heures sur ce point ..
ce n'est qu'en rajoutant un flag de passage ,que je m'en suis apercu .
encore une fois "on ne nous dit pas tout" .. et surtout le compilo qui voit rien


lien forum mikroC
If you don't write parenthesis the compiler won't report an error,
but the function won't be called.
You refer to it, but don't assign to anything, similar to a label.
It won't do anything in the code.

Je trouve TRES BIEN, ta presentation de code .. identé et commentée à souhait.

Chacun a le droit d'avoir sa personnalisation. Tu as démontré que tu utilisais déja le "switch case"
et que l'usage de if else n'est pas surfait, puisqu'il existe.
En C , on a pas le meme soucis de performance ou contrainte qu'en ASM
ou la rigueur est necessaire.

[Claudius]

Bonjour,

@Jérémy: Y-a-t-il une valeur disons "générale" pour un switch case plutôt qu'un else if

Dés lors que les if/else if portent sur le test de constantes, oui, il faut le transcrire en switch() / case

De plus, l'utilisation de l'opérateur ternaire apporte beaucoup plus de visibilité et de concision dans le cas d'un simple "Affectation suivant un test if/else"; exemple de la ligne 165 du programme:

Code : Tout sélectionner

           case 21: {
                    if (temp == 'T')
                        Valeur = 22;
                    else
                        Valeur = 0;
                    break;
                  }


Peut être remplacé par (bloc accolade supprimé car inutile ;-):

Code : Tout sélectionner

           case 21:
                    Valeur = (temp == 'T') ? 22 : 0;
                    break;


Avec ces évolutions, tu divises facilement le nombre de lignes de code par 2 voire 3...