Détection de front montant

Version imprimable

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 :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 void main () { int Etat = 0; int EtatPrecedent = 0; securite (); } void securite () { EtatPrecedent = Etat; Etat = Entrees.Logiques.Etat.NA.E_PARK; 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

03/01/2012, 20h40
Kirilenko

Bonjour,

- merci d'utiliser les balises codes.
- je suis plutôt novice dans ce style de programmation, mais c'est normal que tu ne passes pas Etat et EtatPrecedent en paramètre à ta fonction sécurité ?
03/01/2012, 20h54
amine_34

j ai bien déclaré etat et etatprecedent dans ma fonction securite

ca compile, mais c est juste que ca ne rentre pas dans la boucle

Merci pour ta réponse
03/01/2012, 20h59
Kirilenko

Nous manquerait-il une partie du code dans ce cas-là ? Je ne vois aucune déclaration de variable moi. Je te crois quand tu dis que ça compile, mais en l'état...
Non parce que je suis intrigué en fait. :mrgreen:

:) je comprend

Au fait c est un code bcp plus lourd.

Mais pour résumer j'ai choisit de faire une fonction qui traduit ce que je cherche a faire.

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 :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 void securite () { int Etat = 0; int EtatPrecedent = 0; EtatPrecedent = Etat; Etat = Entrees.Logiques.Etat.NA.E_PARK; if (Etat != EtatPrecedent) { if (Etat == 1) { TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING); } } }
ca seré plutt ca

03/01/2012, 21h27
Kirilenko

Ok merci, je vais pouvoir dormir tranquille. :aie:

Bon, ta logique me semble globalement bonne, mais tu appelles ta fonction dans une boucle ?
03/01/2012, 21h31
amine_34

oui je l appel dans une boucle, et je ne comprend vrmnt pas prk ca ne rentre pas !!!!
04/01/2012, 00h05
BlueMonkey
Bonsoir,

Il n'est pas impossible que la lecture du registre matériel Entrees.Logiques.Etat.NA.E_PARK retourne plus de bit qu'attendu.

Du coup le bit0 (de poid faible) vaut peut être bien 1, mais d'autres bits sont également à 1.
Et par conséquent, le test == 1 ne sera jamais vrai.
Il est également possible que E_PARK soit un registre à plusieurs bits.
Et que le bit de indiquant le front ne soit pas le bit de poids faible. (décalage à faire).
Ou bien le registre est à reseter pour qu'il mémorise un nouveau front.

L'idéal est de vérifier dans une sortie de log ou au débugger la valeur de ce registre. (passage de 0 à 1, et de 1 à 0 ?)
Et au besoin de forcer l'état avec un & binaire, comme dans l'exemple ci-dessous.
Code:

1 2 3 4 bool isUpFront () { return Entrees.Logiques.Etat.NA.E_PARK & 0x00000001; //lecture hardware. }
Code:

1 2 3 4 5 6 7 void securite () { if (isUpFront()) { TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING); } }

Citation:

Envoyé par amine_34

oui je l appel dans une boucle, et je ne comprend vrmnt pas prk ca ne rentre pas !!!!

Et si tu montrais vraiment le code en cause, parce que dans ce que tu publies, il n'y a pas de boucles, ça simplifierait la résolution du problème !

Il semble que ton code soit équivalent à :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void securite () { // int Etat = 0; // int EtatPrecedent = 0; // EtatPrecedent = Etat; donc EtatPrecedent = 0 int Etat = Entrees.Logiques.Etat.NA.E_PARK; //if (Etat != EtatPrecedent) EtatPrecedent vaut toujours 0 -> if(Etat !=0) //{ if (Etat == 1) // donc Etat est bien != 0 { TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING); } //} }
Une remarque : si la donnée à tester (Entrees.Logiques.Etat.NA.E_PARK) peut être modifiée par un évènement extérieur imprévisible par le programme, il est bon de la déclarer volatile pour éviter que le compilateur n'opère dessus des optimisations (en lui laissant la possibilité de supposer que sa valeur n'a pas changé) et le forcer à relire cette valeur à chaque fois qu'on en a besoin.

04/01/2012, 10h59
Bktero

Je vois des variables Etat et EtatPrecedent, ne serait-ce pas des variables à déclarer en tant que static ?

Autre question : tu ne peux pas faire une interruption sur ton entrée logique ? Attendre un front dans une boucle, c'est de l'attente active, ça ne s'utilise que dans des situations où l'arrivée est nécessaire pour continuer le programme (genre de top départ).

Bonjour à tous

Moi, je l'aurais codé comme ceci (mis à part les modifications faites pour être testé sur PC)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
int Etat = 0;
int Etattest;
 
void securite (void)
{
  static int EtatPrecedent = 0;
 
   Etat = Etattest /*Entrees.Logiques.Etat.NA.E_PARK;*/;
 
  if (Etat != EtatPrecedent)
  {
    EtatPrecedent = Etat;
    if (Etat == 1)
    {
        printf("Temporisation lancee\n"); 
		/*TemporisationLance(TpParking, TEMPS_ATTENTE_PARKING);*/
    }
  }
}
 
void main (void)
{
 
  securite ();
  Etattest = 1;
  securite ();
  Etattest = 0;
  securite ();
  Etattest = 1;
  securite ();
}

Cordialement