langage c ==> problème avec while

[michelcreuse]

Bonsoir,
je ne comprends pas:
j'ai fais un programme d'alarme et je bute sur une boucle pour définir une durée.
J'ai réalisé la partie avec "if" que voici et qui fonctionne:

/////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <12F629.h>

#use delay(clock=4000000)
#fuses WDT,INTRC_IO,NOCPD,NOPROTECT,NOMCLR,NOPUT,NOBROWNOUT
#define GP0 PIN_A0
#define GP1 PIN_A1
#define GP2 PIN_A2
#define GP3 PIN_A3
#define GP4 PIN_A4
#define GP5 PIN_A5
#use fast_io(A)

#BYTE TRIS = 0x85                              

void enclenchement_relais(void);        


byte  duree_alarme=10;                           // 10 secondes
byte  etape=1;

void main()
{
debut:
       output_low (GP0);                         
       output_low (GP1);                         // Led
       output_low (GP2);                         
       output_low (GP3);                        
       output_low (GP4);                         
       output_low (GP5);                         // départ signal relais
       setup_wdt(WDT_1152MS);                    // watchdog = 1152mS
       TRIS=0x1D;                                                                

/////////////////////////////  >>>> Gestion de la sortie /////////////////////////

 if (etape==0)
     {
      output_high (GP1);                         // allume une led rouge
     }
 if (etape==1)       
     {
      enclenchement_relais();
     } 
goto debut;
}

////////////////////////////////////// Sous-programmes ///////////////////////////////////////////

void enclenchement_relais(void)

{
     if (duree_alarme>0)                         // ouverture d'un relais pendant 10 secondes                  
       {
        output_high (GP5); 
        delay_ms(1000);   
        duree_alarme-=1;
       }

     if (duree_alarme==0)
       {
        etape=0;
       }
}     

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

et la même partie avec "while" qui ne fonctionne pas:
/////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <12F629.h>

#use delay(clock=4000000)
#fuses WDT,INTRC_IO,NOCPD,NOPROTECT,NOMCLR,NOPUT,NOBROWNOUT
#define GP0 PIN_A0
#define GP1 PIN_A1
#define GP2 PIN_A2
#define GP3 PIN_A3
#define GP4 PIN_A4
#define GP5 PIN_A5
#use fast_io(A)

#BYTE TRIS = 0x85                              

void enclenchement_relais(void);        


int duree;                            
byte etape=1;

void main()
{
debut:
       output_low (GP0);                         
       output_low (GP1);                         // Led rouge
       output_low (GP2);                         
       output_low (GP3);                        
       output_low (GP4);                         
       output_low (GP5);                         // départ signal relais
       setup_wdt(WDT_1152MS);                    // watchdog = 1152mS
       TRIS=0x1D;                                                                
/////////////////////////////  >>>> Gestion de la sortie /////////////////////////

 if (etape==0)
     {
      output_high (GP1);                         // allume une led rouge
     }
 if (etape==1)       
     {
      enclenchement_relais();
     } 
sleep();
goto debut;
}

////////////////////////////////////// Sous-programmes ///////////////////////////////////////////

void enclenchement_relais(void)
{
     duree=0;
     while(duree<10)                             // ouverture d'un relais pendant 10 secondes
       {
        output_high (GP5); 
        delay_ms(1000);   
        duree++;
       }
    etape=0;
}     

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

et c'est cette version que j'aimerai inclure car quand elle est lancée elle ne s'arrête normalement qu'au bout de 10 secondes,
or dans l'état actuel, elle ne s'arrête pas.

merci d'avance pour votre aide,

michel
-----

[micka_ch]

Bonsoir,

Dans le premier cas tu exécute le code du main toute les 1000ms plus le temps d’exécution des instructions mais certainement négligeable par rapport au délais de 1000 ms. Par contre dans le 2ème cas tu reste 10s dans :

while(duree<10) // ouverture d'un relais pendant 10 secondes
{
    output_high (GP5);
    delay_ms(1000);
    duree++;
}

Et donc ton watchdog, qui est à 1152mS reset le mcu.

Salutations

[michelcreuse]

Alors pourquoi cette partie de programme fonctionne pendant 15 secondes et repart au " debut " sans problème?

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

.......       setup_wdt(WDT_2304MS);  ......

.......         if (input(GP1))                         // si ouverture de la boucle3 pendant le mode veille (+) = ALARME
            { 
           output_high (GP2);
           duree_cycle_alarme=30;                // 15sec = 30
           traitement_boucle_ouverte();          // procédure de traitement de l'alarme Boucle1
           depart=1;
          }
   }
   output_low(GP2);                                 // fermeture du pulse "+" 
   sleep();
goto debut;
}


void traitement_boucle_ouverte(void) 
{
     while (duree_cycle_alarme>0)
    {
         pas_fini=180;                          // 400mS div. par 2222µS=180 boucles
         while (pas_fini>0)
             {
              output_low (GP5);
              delay_us(600);                     // largeur du pulse (pin à 1)
              output_high (GP5);
              delay_us(1622);                    // largeur du temps mort pour fréquence(pin à 0)
              pas_fini-=1;
             }
         pas_fini=55;                           // 100mS div. par 1818µS=55 boucles
         while (pas_fini>0)
             {
              output_low (GP5);
              delay_us(600);                     // largeur du pulse (pin à 1)
              output_high (GP5);
              delay_us(1218);                    // largeur du temps mort pour fréquence(pin à 0)
              pas_fini-=1;
             }
        duree_cycle_alarme-=1;              // "duree_cycle_alarme=0;" si arrêt immédiat de l'alarme
     }
   restart_wdt();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Dans le programme initial la boucle ne s'arrête pas au bout de 10sec. pour repartir au début du "void main()".

Est-ce que c'est grâce au " restart_wdt(); " ???

Michel

[gienas]

Bonjour à tous

[HS]

À l’attention de michelcreuse qui m’interroge sur la pose des balises code mais aussi de tous ceux qui "oublient" de les utiliser, je viens de placer une explication en forum de test, qui finira peut-être ailleurs.

Ne pas hésiter à s’y exprimer pour améliorer la compréhension de certains mots réservés dont la signification ne tombe pas forcément sous le sens.


http://forums.futura-sciences.com/fo...ml#post6081852

[/HS]

[A voir en vidéo sur Futura]

[freepicbasic]

C'est le principe même du watch dog !

Il faut le relancer avant la fin de son cycle sinon ça reboot.
Si le prog est conçu correctement ça signifie que le prog s'est figé anormalement dans une boucle infini pour une raison inconnue ou inattendue et donc on le débloque en ressettant.

[micka_ch]

Bonjour,

Oui tu doit faire un restart_wdt(); au minimum toute les 2304MS, sinon ton MCU reset et reprend depuis le début. Par contre voici quelques conseils:

Pour des attentes de quelque secondes, utilise une attente passive basé sur un timer. Car avec une attente active ton MCU ne fait rien, pendant la duré de cette attente...

Ton programme principale n'est pas très bien structuré (les gouts et les couleurs). Voici un exemple de structure du main:

/* Includes ------------------------------------------------------------------*/
#include <12F629.h>
#include "timer.h"
#include "gpio.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/

/*
 * Main application entry point.
 */
int main(void) {
        // Initialisation, n'est executer qu'une seul foi à la mise sous 
        // tension ou après un reset
	timer_Init();
        watchdog_Init();
        gpio_Init();

	while (1) {
                //Ce code est exécute de manière cyclique, le temps de cycle 
                //dépend du nombre d'instruction et de la vitesse du clock
		timer_AsynchroneProcess();
                relay_ProcessStateMachine();
                watchdog_Restart();
	}
}

[Chtulhu]

Bonsoir,

il faudrait surtout apprendre à utiliser les interruptions, ça évite ce genre de gestion temporelle très hasardeuse.
Vous utilisez une base de temps (par exemple 1s) puis vous comptez dans la boucle d'interruption chaque passage 1s, vous déclencherez l'action très précisément à 10s et ne bloquerez pas le reste de votre programme.