Détection de front montant

[invite73838812]

Bonsoir,

Je voudrais lancer une temporisation sur un front montant.
Donc pour expliquer d'avantage, je surveille l'état d'une entrée logique, donc dés qu'elle passe à 1, je lance une temporisation.

Le code que j'utilise actuellement est :

void main ()
{
int Etat = 0;
int EtatPrecedent = 0;

EtatPrecedent = Etat;
Etat = Entrees.Logiques.Etat.NA.E_PAR K;

if (Etat != EtatPrecedent)
{
if (Etat == 1)
{
TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING);
}
}
}

Le problème est que la temporisation ne se lance jamais, et donc il ne rentre jamais dans la boucle ( méme quand l'entrée logique passe de 0 à 1)

Je ne sais pas si ca viens de l'initialisation de "etat" et "etatprecedent" ou ...

Merci de me répondre car je n'arrive vrmnt pas a savoir d ou ca peut venir et ca fait un petit moment que je bloque dessus.

merci
-----

[lucas.gautheron]

je ne suis pas sur de bien cerner ton problème.
Ici, tu assignes comme valeur 0 à EtatPrecedent et la valeur d'entrée à Etat.
Puis ton compares Etat à Etatprecedent (pourquoi faire), et s'ils sont différents, tu compares Etat à 1.
Ok.
Mais tu ne fais ce test qu'une fois, autrement dit si à l'instant ou tu veux le test, Etat != 1, (ou Etat == EtatPrecedent) alors c'est foutu, la tempo sera pas lancée et le test ne sera plus jamais effectué.
Ne manquerait-il pas une boucle ? Ou alors je n'ai pas compris ou tu voulais en venir.

PS : utilise la balise code

[invite73838812]

au fait je fais appel a cette fonction dans la fonction main ().

Cette fonction en vrai s appel securite ()

donc ca se reboucle

mais ca ne rentre jamais dans la boucle if ...

???

[lucas.gautheron]

et si tu nous montrais le vrai code code ?

[A voir en vidéo sur Futura]

[invite73838812]

c est un code très lourd !!

Mais pour résumer je me propose de bien montrer ou cette fonction intervient :

Voila, j'ai deux fichiers : un <main.c> et un <securite.c>

dans le main.c on a :

int main ()
{
SecuritesInitialise ();

EtatSysteme.PremiereBoucle = 1; // cette variable est déja déclarée dans le .h

for ( ; ; EtatSysteme.PremiereBoucle = 0)
{
SecuritesGere();
}
}

dans la fonction securiites.c on a :

int etat = 0;
int etatprecedent = 0;

void SecuritesInit()
{

// La je ne met rien qui soit en rapport avec ma fonction "detection de front montant"

}

void SecuriteGere ()
{
EtatPrecedent = Etat;
Etat = Entrees.Logiques.Etat.NA.E_PAR K;

if (Etat != EtatPrecedent)
{
if (Etat == 1)
{

TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING); // fonction déclarée au préalable

}
}

donc voila tout.

et avec ca, je ne rentre jamais dans le if () et donc ma tomporisation ne se lance pas


}
}

[lucas.gautheron]

Il aurait été mieux que tu suives le premier conseil (càd utiliser la balise code :P) mais bon déjà maintenant on en sait un peu plus...

Avec ce que tu as mis là, comme ça, à première vue, je ne vois pas l'origine du problème. As tu essayé, avec un code réduit au minimum, de détecter ce front montant ? (passage de Entrees.Logiques.Etat.NA.E_PAR K à 1 ?)

[invite73838812]

Il y auré une autre méthode pour détecter un front montant ??

Si oui j aimerais bien savoir comment, ca m aiderai a avancer

Et merci d avance

[invite73838812]

il ya une autre methode pour faire une detection de front montant ??

[Jack]

Il faudrait faire un effort au niveau de la présentation du code car ça ne donne vraiment pas envie de te lire.

void SecuriteGere ()
{
   EtatPrecedent = Etat;
   Etat = Entrees.Logiques.Etat.NA.E_PAR  K;
 
   if (Etat != EtatPrecedent)
   {
   if (Etat == 1)
   {
 
      TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING); // fonction déclarée au préalable
 
   }
}

Ces trois lignes ne conviennent pas pour détecter un front

   EtatPrecedent = Etat;
   Etat = Entrees.Logiques.Etat.NA.E_PAR  K;
 
   if (Etat != EtatPrecedent)

ou alors, il faut jouer au loto

   EtatPrecedent = Etat;
   Etat = Entrees.Logiques.Etat.NA.E_PAR  K;
 
   if (Etat != EtatPrecedent)

il ne faut pas rafraichir EtatPrecedent à chaque entrée dans la fonction sinon, en imaginant que l'entrée vient juste de changer avant d'exécuter cette ligne, tu auras lou^é ce changement.
Il faut que EtatPrécédent soit une variable globale, ou mieux une variable statique mise à jour uniquement à un changement d'état.

A+

[JPL]

Il aurait été mieux que tu suives le premier conseil (càd utiliser la balise code :P)

Balise Code ou non le programme n'est pas indenté (j'ai vérifié). Mauvaise habitude.

[invite73838812]

Bonjour,

Merci pour les informations.

J'ai modifié mon code en mettant EtatPrecedant en variable statique.

ca donne ca :

static EtatPrecedent;

EtatPrecedent = 0;

void SecuriteParking()
{
Etat = Entrees.Logiques.Etat.NA.E_PARK;

if (Etat != EtatPrecedent)
   {
    if (Etat == 1)
       {
       TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING);
       }
    EtatPrecedent = Etat;
    }
}

ca ne rentre toujours pas, et je ne sais pas si j'ai bien saisit ton explication

Merci

[invite4492c379]

Hello,

Si je comprends bien ton problème, tu cherches dans une fonction à vérifier si une variable (sur laquelle tu n'as pas vraiment la main) change de valeur et dans ce cas prend un valeur précise.
Utiliser des variables globales est mal (dans le sens croiser les effluves, il ne faut pas sauf en dernier recours si tu n'as plus aucune autre solution). Le C offre une alternative intéressante : déclarer une variable locale static, sa durée de vie sera celle du programme mais sa visibilité sera locale et seulement initialisée une fois. Regarde cet exemple :

 Cliquez pour afficher

#include <stdio.h>


void tester(int var)
{
    static int premierAppel = 1;
    static int ancienneValeur = 0;


    if (premierAppel) {
        premierAppel = 0;
        ancienneValeur = var;
        printf
            ("tester : premier appel,initialiasation avec %d comme ancienne valeur\n",
             var);
    } else {
        if (var != ancienneValeur) {
            printf("tester : var a changé de %d à %d\n", ancienneValeur,
                   var);
            if (var == 2)
                printf("tester : \tvar==2 : Je me déclenche\n");
            ancienneValeur = var;
        } else
            printf("tester : aucun changement\n");
    }
}


int main()
{
    int truc = 0;
    printf("main   : truc=%d\n", truc);
    tester(truc);
    tester(truc);
    truc = 1;
    printf("main   : truc=%d\n", truc);
    tester(truc);
    tester(truc);
    truc = 3;
    printf("main   : truc=%d\n", truc);
    tester(truc);
    tester(truc);
    truc = 2;
    printf("main   : truc=%d\n", truc);
    tester(truc);
    tester(truc);
    truc = 8;
    printf("main   : truc=%d\n", truc);
    tester(truc);
    tester(truc);
    truc = 2;
    printf("main   : truc=%d\n", truc);
    tester(truc);
    tester(truc);


    return 0;
}

Dans le main je teste la variable truc deux fois après chaque changement de valeur. La programme provoque cette sortie :

main   : truc=0
tester : premier appel,initialiasation avec 0 comme ancienne valeur
tester : aucun changement
main   : truc=1
tester : var a changé de 0 à 1
tester : aucun changement
main   : truc=3
tester : var a changé de 1 à 3
tester : aucun changement
main   : truc=2
tester : var a changé de 3 à 2
tester :        var==2 : Je me déclenche
tester : aucun changement
main   : truc=8
tester : var a changé de 2 à 8
tester : aucun changement
main   : truc=2
tester : var a changé de 8 à 2
tester :        var==2 : Je me déclenche
tester : aucun changement

Remarques :

* Tu ne détectes les changements que lors d'appel à la fonction tester, tu n'as pas le comportement désiré dans un cas de figure comme :

  ...
  truc=0;
  truc=3;
  tester(truc);
  truc=2;
  truc=4;
  tester(truc);
  ...

Si ton code modifie la valeur de la variable, alors tu peux (dois) tester à chaque affectation.

* Pièce jointe 168746 et évidemment à l'indentation de ton code

[invite73838812]

J'ai bien compris le code que tu m'a présenté et je t en remercie

pour bien expliquer ma situation

Je me propose de bien montrer ou cette fonction intervient :

Voila, j'ai deux fichiers : un <main.c> et un <securite.c>

dans le main.c j'ai :

int main ()
{
SecuritesInitialise ();

EtatSysteme.PremiereBoucle = 1; // cette variable est déja déclarée dans le .h

for ( ; ; EtatSysteme.PremiereBoucle = 0)
    {
    SecuritesGere();
    }
}

dans la fonction securiites.c j'ai :

int etat = 0;
static int etatprecedent = 0;

void SecuritesInit()
{

// La je ne met rien qui soit en rapport avec ma fonction "detection de front montant"

}

void SecuriteGere ()
{
EtatPrecedent = Etat;
Etat = Entrees.Logiques.Etat.NA.E_PAR K;

if (Etat != EtatPrecedent)
   {
   if (Etat == 1)
       {
       TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING); // fonction déclarée au préalable
       }
   }

}

donc voila tout.

et avec ca, je ne rentre jamais dans le if () et donc ma tomporisation ne se lance pas

[invite4492c379]

Tu as passé ton code au debuger en mettant un break en entrée de SecuriteGere puis en faisant du pas à pas en inspectant la valeur des variables ?


... ou à défaut en insérant des printf ????

[invite73838812]

Je n'ai pas de debuger pour l'instant, c'est pour ca que je n'arrive pas a faire une verification pas a pas !

donc je dois me debrouiller sans ca !

mais pour Etatprecedent, je ne sais pas si je dois la déclarer comme je l'ai fait

[Jack]

int etat = 0; static int etatprecedent = 0;

Il faut mettre ces déclarations DANS la fonction SecuriteGere ()
essaie ceci:

void SecuriteGere ()
{
    int etat;
    static int etatprecedent = 0;
    Etat = Entrees.Logiques.Etat.NA.E_PAR K; // Edit jack : je n'ai pas compris ce que fait ce K ici
    if (Etat != EtatPrecedent)
    {
       EtatPrecedent = Etat;
       if (Etat == 1)
       {
          TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING); // fonction déclarée au préalable
       }
    }
}

En principe, on ne détecte pas comme ceci un front. Je ne sais pas sur quel microcontrôleur tu travailles, mais il est normalement préférable de programmer l'entrée pour générer une interruption. Tel que tu l'as programmé, le microcontrôleur va rester bloqué sur l'exécution du code de détection du front, alors qu'on pourrait lui faire faire autre chose en attendant le front.
A+

[invite4492c379]

On y arrive toujours en insérant des printf ... quel est ton environnement de programmation ?

Il faut que tu déclares tes variables locales en static (comme dans mon exemple) ... et que tu «copies» mon code ...

La «variable» qui change de valeur, est-ce ton programme qui en change la valeur ?

Tu parles de front montant, je suppose que tu viens de l'électronique ?

[invite73838812]

C'est plutt de l'électronique embarquée

Je fais de la programmation sur microcontroleurs.

Et concernant l'entrée E_PARk, je l'actionne en utilisant un banc de test, donc physiquement.

j'ai utilisé le code que tu m'a conseillé, mais ca ne rentre tjr pas dans la boucle.

Je ne comprend pas

[invite4492c379]

Alors je ne suis pas compétant ... je ne sais même pas si ton compilo gère correctement (dans le sens respecte la norme) le static pour des varaibles locales ... Il faudra peut-être poster cette question dans le forum electronique.

[Jack]

j'ai utilisé le code que tu m'a conseillé, mais ca ne rentre tjr pas dans la boucle.

Le mien ou celui de Photon?

Mets des printf pour afficher les variables Etat et EtatPrecedent.

Et pour les interruptions? Il est possible de configurer les entrées pour détecter des fronts? Le compilateur gère-t-il les interruptions?

A+

[lucas.gautheron]

   EtatPrecedent = Etat;
   Etat = Entrees.Logiques.Etat.NA.E_PAR  K;
 
   if (Etat != EtatPrecedent)

il ne faut pas rafraichir EtatPrecedent à chaque entrée dans la fonction sinon, en imaginant que l'entrée vient juste de changer avant d'exécuter cette ligne, tu auras lou^é ce changement.
Il faut que EtatPrécédent soit une variable globale, ou mieux une variable statique mise à jour uniquement à un changement d'état.

A+

je ne vois pas : ici EtatPrecedent est bien global (voir sa déclaration).

[Jack]

je ne vois pas : ici EtatPrecedent est bien global (voir sa déclaration).

Regarde le code de mon message#16 et tu constateras que j'ai bien déclaré EtatPrecedent localement.

A+